1、get() 返回指定鍵的值，如果值不在字典中返回default值。
創(chuàng)新互聯(lián)從2013年成立，是專業(yè)互聯(lián)網(wǎng)技術服務公司，擁有項目成都網(wǎng)站設計、成都網(wǎng)站制作網(wǎng)站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元嘉魚做網(wǎng)站,已為上家服務,為嘉魚各地企業(yè)和個人服務,聯(lián)系電話:028-86922220
語法：dict.get(key,default=None)
參數(shù)：
key 字典中要查找的鍵。
default 如果指定鍵的值不存在時，返回該默認值值。
例：
dict={'Name':'alex','Age':21}
print("Name is:%s"% dict.get('Name')+"\n"+ "Age is:%d"% dict.get('Age'))
顯示結果為：
Name is:alex
Age is:21
2、update() 將一個字典中的值更新到另一個字典中。
語法：dict.update(dict2)
參數(shù)：
dict2 添加到指定字典dict里的字典。
例：
dict={'Name':'alex','Age':21}
dict2={'Sex':'female'}
dict.update(dict2)
print("Value is %s" % dict)
顯示結果為：
Value is {'Name': 'alex', 'Age': 21, 'Sex': 'female'}
1.集合類型概述
Python語言中的集合類型與數(shù)學中的集合概念一致，即包含0個或多個數(shù)據(jù)項的無序組合。
集合是無序組合，用大括號{}表示，它沒有索引和位置的概念，集合中元素可以動態(tài)增加或刪除。
由于集合元素獨一無二，使用集合類型能夠過濾掉重復元素。
集合類型有4個操作符，交集、并集|、差集-、補集^，操作邏輯與數(shù)學定義相同
集合類型有一些常用的操作函數(shù)或方法
set()函數(shù)將其他的組合數(shù)據(jù)類型變成集合類型，返回結果是一個無重復且排序任意的集合。set()函數(shù)也可以生成空集合變量。
列表類型用中括號[]表示，也可以通過list(x)函數(shù)將集合或字符串類型轉(zhuǎn)換成列表類型。
列表屬于序列類型，所以列表類型支持序列類型對應的操作
1.序列類型有一些通用的操作符和函數(shù)
2.列表的索引
索引是列表的基本操作，用于獲得列表的一個元素。使用中括號作為索引操作符。
可以使用遍歷循環(huán)對列表類型的元素進行遍歷操作，
基本使用方式如下
3.列表的切片
切片是列表的基本操作，用于獲得列表的一個片段，即獲得一個或多個元素。切片后的結果也是列表類型。
切片的使用方式：
切片獲取列表類型從N到M（不包含M）的元素組成新的列表。當K存在時，切片獲取列表類型從N到M（不包含M）以K為步長所對應元素組成的列表。
1.列表的操作方法
ls.append(x)僅用于在列表中增加一個元素，如果希望增加多個元素，可以使用加號+，將兩個列表合并。
可以使用Python保留字del對列表元素或片段進行刪除。
如下：
或
使用索引配合等號（=）可以對列表元素進行修改。
補：元組
Python的元組與列表類似，不同之處在于元組的元素不能修改。
元組使用小括號()，列表使用方括號。
元組創(chuàng)建很簡單，只需要在括號中添加元素，并使用逗號隔開即可。
Python語言中的字典使用大括號{}建立，每個元素是一個鍵值對。
使用方式：
鍵和值通過冒號連接，不同鍵值對通過逗號隔開。大括號可以表示集合，字典類型也具有和集合類似的性質(zhì)，即鍵值對之間沒有順序且不能重復。
?字典的索引
列表類型采用元素順序的位置進行索引。由于字典元素“鍵值對”中鍵是值的索引，因此，可以直接利用鍵值對關系索引元素。
利用索引和賦值 = 配合，可以對字典中每個元素進行修改。
使用大括號可以創(chuàng)建字典。通過索引和賦值配合，可以向字典中增加元素。
字典類型有一些通用的操作函數(shù)
字典類型存在一些操作方法
d.keys()返回字典中的所有鍵信息，返回結果是Python的一種內(nèi)部數(shù)據(jù)類型dict_keys，專用于表示字典的鍵。如果希望更好的使用返回結果，可以將其轉(zhuǎn)換為列表類型。
d.values()返回字典中的所有值信息，返回結果是Python的一種內(nèi)部數(shù)據(jù)類型dict_values。如果希望更好的使用返回結果，可以將其轉(zhuǎn)換為列表類型。
d.items()返回字典中的所有鍵值對信息，返回結果是Python的一種內(nèi)部數(shù)據(jù)類型dict_items。
d.get(key, default)根據(jù)鍵信息查找并返回值信息，如果key存在則返回相應值，否則返回默認值，第二個元素default可以省略，如果省略則默認值為空。
d.pop(key, default)根據(jù)鍵信息查找并取出值信息，如果key存在則返回相應值，否則返回默認值，第二個元素default可以省略，如果省略則默認值為空。相比d.get()方法，d.pop()在取出相應值后，將從字典中刪除對應的鍵值對。
d.popitem()隨機從字典中取出一個鍵值對，以元組(key,value)形式返回。取出后從字典中刪除這個鍵值對。
d.clear()刪除字典中所有鍵值對。
此外，如果希望刪除字典中某一個元素， 可以使用Python保留字del。
字典類型也支持保留字in，用來判斷一個鍵是否在字典中。如果在則返回True，否則返回False。
字典可以遍歷循環(huán)對其元素進行遍歷
for循環(huán)返回的變量名是字典的索引值。如果需要獲得鍵對應的值，可以在語句塊中通過get()方法獲得。
def?exchange(d):
res?=?dict((v,k)?for?k,v?in?d.items())
print(res)
print(d)
一行代碼完成交換的，按你的需求定義了一個函數(shù)
一,python整數(shù)類型所表示的數(shù)據(jù)。
1,一般用以表示一類數(shù)值:所有正整數(shù),0和負整數(shù);
2,整型作為最常用的,頻繁參與計算的數(shù)據(jù)類型，在python3.5中解釋器會自動在內(nèi)存中創(chuàng)建-5-3000之間的（包含5，不包含3000）整型對象，也就是說在該范圍內(nèi),相等都是同一個已經(jīng)創(chuàng)建好的整型對象。范圍之外的即使相等也表示不同對象，該特性隨python版本而改變，不要過于依賴。
3,bool型繼承了int型，他是int的子類。
4,Python2中有長整型long，數(shù)值范圍更大，在python3中已取消，所有整型統(tǒng)一由int表示。
5,參與所有數(shù)值計算，數(shù)學運算，科學計算。這也是所有編程語言都有的數(shù)據(jù)類型，因為編程語言生而需要模擬人的思維，借助數(shù)學方式，自動計算、更好的解決大量重復性的事務，因此數(shù)值類型、整數(shù)類型在編程語言中不可或缺。
6,支持二進制(0b\0B開頭),十進制,八進制(0o\0O),十六進制(0x\0X)
二，python整數(shù)和浮點型支持常規(guī)的數(shù)值運算
整數(shù)和浮點數(shù)都可參與的運算：+ - * / %（取余） //（整除） **（冪）
Python字符型：
python字符型表示的數(shù)據(jù)：
python3支持Unicode編碼，由字母、數(shù)字和符號組成的形式就叫字符串，更接近或者相同與人們文字符號表示，因此在信息表示和傳遞時它也是最受認可的形式。在程序編寫中也是非常常用，對應的可操作的方法也很多，很有意思。
字符串不可被修改，可以拼接等方法創(chuàng)建新字符串對象；
支持分片和下標操作；a[2:]
支持+拼接，*重復操作和成員關系in/not in；
表示形式：用單引號雙引號包含起來的符號；a = str(‘sdfsdfsdf’) 或 r’\t\nabcd’ 原始字符，Bytes：b’abcd’；
6,字符串屬于不可變數(shù)據(jù)類型，內(nèi)部機制為了節(jié)省空間，相同的兩個字符串表示相同的一個對象。a = ‘python’ b = ‘python’ a is b :True
二, 字符串支持的運算方法
1,capitalize() :首字母大寫后邊的字母小寫 a = ‘a(chǎn)bcd’ b = a.capitalize() b:Abcd
2,casefold() lower():字母轉(zhuǎn)換為全小寫
3,center(width,fillchar) :居中，width填補的長度；fillchar添加的字符
a = a.center(10,’_’) //’____abcd____’ 默認無fillchar填充空格
4,count(sub,star,end) :字母計數(shù)：sub要查詢的字符
5,encode(encoding=’utf-8’,errors=’strict’) 設置編碼
Errors :設置錯誤類型
6,endswith(suffix,star,end) : 若以suffix結尾返回True
7，expandtabs(8) :設置字符串中tab按鍵符的空格長度：’\tabcde’
8,find(sub,star,end) : 返回指定范圍內(nèi)的字符串下標，未找到返回-1
9，index(sub,star,end) :返回指定范圍字符串下標未找到拋出異常
10，isalnum() :判斷字符串是否是字母或數(shù)字，或字母和數(shù)字組合
11，isalpha() :判斷是否全是字母
12，isdecimal() :判斷字符串是否是十進制數(shù)值
13，isdigit() :判斷字符串是否是數(shù)字
14，isidentifier() :判斷字符串中是否包含關鍵字
15，islower() :判斷是否全小寫
16，isnumeric() :判斷全是數(shù)字
17，isspace() :判斷是否是空格
18，isupper() 判斷是否大寫
19，istitle() :判斷是否首字母大寫
20，join(iterable) :把可迭代對象用字符串進行分割：a.join(‘123’)
21,ljust(width,fillchar);rjust() :左對齊右對齊
22, upper() :將字符串改為大寫
23，split(sep=None,maxsplit=-1) :分割一個字符串，被選中字符在字符串中刪除
‘a(chǎn)b1cd1efg’.split(‘1’) :[‘a(chǎn)b’,’cd’,’efg’]
三，字符串格式化：按照規(guī)格輸出字符串
format(*args,**kwargs) :args位置參數(shù)，kwargs關鍵字參數(shù)
‘{0:.1f}’.format(123.468) :格式化參數(shù)，小數(shù)點后保留1位四舍五入
四，字符串操作符%
1，%s :格式化字符串 ‘a(chǎn)bcd%sdef’%’dddd’
2，%d:格式化整數(shù)
3，%o格式化無符號八進制
4，%x格式化無符號十六進制
5，%f格式化定點數(shù)
6, %e: 科學計數(shù)法格式化定點數(shù)
7，%g 根據(jù)值大小自動選%f,%e
8, %G E X :大寫形式
五，格式化輔助命令：
m.n :m最小總寬度，n小數(shù)點后位數(shù)：’%12.4f’%23456.789
六，轉(zhuǎn)義字符：字符串前r避免轉(zhuǎn)義：r’\nhello\thi’
\n:換行符
\t:橫向制表符
\':'
\":"
\b:退格符
\r:回車
\v:縱向制表符
\f:換頁符
\o,\x:八進制和十六進制
\0:空字符串
Python列表list
一，Python的列表list類型表示的數(shù)據(jù)：
Python列表在cpython中被解釋為長度可變的數(shù)組，用其他對象組成的連續(xù)數(shù)組。
列表中元素可以是相同或不同的數(shù)據(jù)類型；
當列表元素增加或刪除時，列表對象自動進行擴展或收縮內(nèi)存，保證元素之間沒有縫隙，總是連續(xù)的。
Python中的列表是一個序列，也是一個容器類型
創(chuàng)建列表：a = []; b = [1,’python’]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加單個元素：list.append(object); //a.append(‘python’)
2,extend添加可迭代對象: list.extend(iterable); //a.extend(‘a(chǎn)bcde’/[1,2,3])
3,insert 插入元素：list.insert(index,object): 在index下標前插入元素//a.insert(2,’python’)
4,clear 清空所有元素：list.clear() //a.clear()
5,pop 刪除并返回一個元素：list.pop(index) //默認刪除默認一個元素
remove 刪除指定元素：list.remove(v) ,v元素不存在報錯 //a.remove(‘c’)
7，count 返回這個值在列表中數(shù)量：list.count(value)
8,copy 淺拷貝一個新列表：list.copy()
9,sort:排序list.sort(reverse=False/True) :默認升序
排序函數(shù)：sorted(list)
10，reverse: 原地翻轉(zhuǎn)：list.reverse()
11，index(value,star,stop) :指定范圍內(nèi)該值下標：list.index(2,0,5)
列表元素訪問：
下標訪問：list[1]
For循環(huán)遍歷
通過下標修改元素：list[2 ] = ‘hello’
列表常用運算符：
1,比較運算符：從第一個元素開始對比
2，+ 拼接一個新列表：l1+ l2
3, 重復操作符：* ,多個列表拼接
成員關系操作符：in/ not in
邏輯運算符：and not or
列表常用的排序方法：
冒泡排序；選擇排序；快速排序；歸并排序
Python元組tuple
一，Python元組tuple數(shù)據(jù)類型表示的數(shù)據(jù)：
元組是受到限制的、不可改變的列表；
可以是同構也可以是異構；
元組是序列類型、是可迭代對象，是容器類型。
元組的創(chuàng)建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]
二，python元組常用方法
1,index(value,star,stop) :指定范圍內(nèi)該值下標：tuple.index(2,0,5)
2,count(value) ：值出現(xiàn)次數(shù)
三，支持運算：
1,比較運算符：從第一個元素開始對比
2，+ 拼接一個新元組：l1+ l2
3, 重復操作符：* ,多個元組拼接
4成員關系操作符：in/ not in
邏輯運算符：and not or
四，元組的訪問
下標操作；
For循環(huán)遍歷訪問。
Python字典類型
一,Python字典dict表示的數(shù)據(jù)：{key:value}
可根據(jù)關鍵字：鍵快速索引到對應的值；
字典是映射類型，鍵值對一一對應關系，不是序列；
字典元素是無序的；
字典是可迭代對象，是容器類型；
字典的創(chuàng)建：k = {}; k1={‘keyword’:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)
二，字典的訪問：
通過key：k[‘key’]
修改key對應的值：K[‘key’] = value
For循環(huán)遍歷出來的是key；
For循環(huán)鍵值對：for I in d.items():
For 循環(huán)enumerate: for k,v in enumerate(k1):
In/not in 成員關系查詢鍵不支持查值
三，字典常用方法
get(key,de):獲取值：k.get(key,de) //若不存在則默認輸出de
pop(k,de):刪除一個鍵值對，不存在輸出de，未設置報錯；
keys() :返回字典所有key組成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value組成的序列：list(k.values())
items():返回鍵值對組成的元組為元素的序列：（類set）list(k.items())
update(e):更新字典：e可是字典或兩元素組成的單位元素序列：e=[(5,6),(7,8)];
k.update(e)
clear():清空字典；
popitem()刪除某個鍵值對，若字典為空則報錯
copy() :淺拷貝
10, fromkeys(iterable,value=None):從可迭代對象創(chuàng)建字典
{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}
11,setdefault(k,d=None) :若key不存在則生成一個鍵值對
k.setdefault(‘keyword’)
Python 集合set
集合表示的數(shù)據(jù)：
多個元素的無序組合，集合是無序的，集合元素是唯一的；
字典的鍵是由集合實現(xiàn)的；
集合是可迭代對象
集合創(chuàng)建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的訪問：
For 循環(huán)將集合所有元素全部訪問一遍，不重復
常用方法：
add(object):s.add(‘hi’) 向集合添加一個元素
pop() :彈棧，集合為空則報錯：刪除任意一個元素；
clear():清空集合，返回一個空集合對象；
remove(object):刪除一個元素，不存在和報錯：s.remove(‘hi’)
update(集合)：更新另一個集合，元素不存在則不更新；
copy() :淺拷貝
集合的運算：
交集：s1s2;
差集,補集：s1-s2;
并集：s1|s2;
Issubset():判斷是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判斷是否是父集：s1.issuperset()
不可變集合：
Frozenset():返回一個空的不可變集合對象
Frozenset(iterable):
S = frozenset(iterable)
Python序列類型共同特性
一,序列類型共同特性
python序列類型有:str字符串,list列表,tuple元組
都支持下標索引，切片操作；
下標都是從0開始，都可通過下標進行訪問；
擁有相同的操作符
二，支持的函數(shù)：
len(obj):返回對象長度；
list(iterable):將可迭代對象轉(zhuǎn)為列表；
tuple(iterable):將可迭代對象轉(zhuǎn)為元組；
str(ojb):將任何對象轉(zhuǎn)為字符串形式；
max(iterable): python3中元素要是同類型，python2中元素可異構：max([‘a(chǎn)’,1])
min(iterable):和max類似；
sum(iterable,star=0),求可迭代對象和，默認star為0，元素不能為字符串
sorted(iterable,key=None,reverse=False)
s=[(‘a(chǎn)’,3),(‘b’,2),(‘c’,9)]
sorted(s,key=lambda s:s[1]) //按照數(shù)字排序
reversed(sequence):翻轉(zhuǎn)序列，返回迭代器
enumerate(iterable):返回enumerate對象,其元素都是一個元組（下標，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]
序列類型的切片操作：
Slice:
L[index]; 訪問某個元素；
L[1:4]; 區(qū)間
L[star:stop:step]; 設置步長取區(qū)間元素
點擊上方 "Python人工智能技術" 關注，星標或者置頂
22點24分準時推送，第一時間送達
后臺回復“大禮包”，送你特別福利
編輯：樂樂 | 來自：pypypypy
上一篇：
正文
大家好，我是Pythn人工智能技術。
內(nèi)置函數(shù)就是Python給你提供的，拿來直接用的函數(shù)，比如print.，input等。
截止到python版本3.6.2 ，python一共提供了68個內(nèi)置函數(shù)，具體如下
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() ?lter() issubclass() pow() super()
bytes() ?oat() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()
本文將這68個內(nèi)置函數(shù)綜合整理為12大類，正在學習Python基礎的讀者一定不要錯過，建議收藏學習！
和數(shù)字相關 1. 數(shù)據(jù)類型
bool : 布爾型(True,False)
int : 整型(整數(shù))
float : 浮點型(小數(shù))
complex : 復數(shù)
2. 進制轉(zhuǎn)換
bin() 將給的參數(shù)轉(zhuǎn)換成二進制
otc() 將給的參數(shù)轉(zhuǎn)換成八進制
hex() 將給的參數(shù)轉(zhuǎn)換成十六進制
print(bin(10)) # 二進制:0b1010
print(hex(10)) # 十六進制:0xa
print(oct(10)) # 八進制:0o12
3. 數(shù)學運算
abs() 返回絕對值
divmode() 返回商和余數(shù)
round() 四舍五入
pow(a, b) 求a的b次冪, 如果有三個參數(shù). 則求完次冪后對第三個數(shù)取余
sum() 求和
min() 求最小值
max() 求最大值
print(abs(-2)) # 絕對值:2
print(divmod(20,3)) # 求商和余數(shù):(6,2)
print(round(4.50)) # 五舍六入:4
print(round(4.51)) #5
print(pow(10,2,3)) # 如果給了第三個參數(shù). 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55
print(min(5,3,9,12,7,2)) #求最小值:2
print(max(7,3,15,9,4,13)) #求最大值:15
和數(shù)據(jù)結構相關 1. 序列
（1）列表和元組
list() 將一個可迭代對象轉(zhuǎn)換成列表
tuple() 將一個可迭代對象轉(zhuǎn)換成元組
print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]
print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)
（2）相關內(nèi)置函數(shù)
reversed() 將一個序列翻轉(zhuǎn), 返回翻轉(zhuǎn)序列的迭代器
slice() 列表的切片
lst = "你好啊"
it = reversed(lst) # 不會改變原列表. 返回一個迭代器, 設計上的一個規(guī)則
print(list(it)) #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1]) #[2,3]
s = slice(1, 3, 1) # 切片用的
print(lst[s]) #[2,3]
（3）字符串
str() 將數(shù)據(jù)轉(zhuǎn)化成字符串
print(str(123)+'456') #123456
format() 與具體數(shù)據(jù)相關, 用于計算各種小數(shù), 精算等.
s = "hello world!"
print(format(s, "^20")) #劇中
print(format(s, "20")) #左對齊
print(format(s, "20")) #右對齊
# hello world!
# hello world!
# hello world!
print(format(3, 'b' )) # 二進制:11
print(format(97, 'c' )) # 轉(zhuǎn)換成unicode字符:a
print(format(11, 'd' )) # ?進制:11
print(format(11, 'o' )) # 八進制:13
print(format(11, 'x' )) # 十六進制(?寫字母):b
print(format(11, 'X' )) # 十六進制(大寫字母):B
print(format(11, 'n' )) # 和d?樣:11
print(format(11)) # 和d?樣:11
print(format(123456789, 'e' )) # 科學計數(shù)法. 默認保留6位小數(shù):1.234568e+08
print(format(123456789, '0.2e' )) # 科學計數(shù)法. 保留2位小數(shù)(小寫):1.23e+08
print(format(123456789, '0.2E' )) # 科學計數(shù)法. 保留2位小數(shù)(大寫):1.23E+08
print(format(1.23456789, 'f' )) # 小數(shù)點計數(shù)法. 保留6位小數(shù):1.234568
print(format(1.23456789, '0.2f' )) # 小數(shù)點計數(shù)法. 保留2位小數(shù):1.23
print(format(1.23456789, '0.10f')) # 小數(shù)點計數(shù)法. 保留10位小數(shù):1.2345678900
print(format(1.23456789e+3, 'F')) # 小數(shù)點計數(shù)法. 很大的時候輸出INF:1234.567890
bytes() 把字符串轉(zhuǎn)化成bytes類型
bs = bytes("今天吃飯了嗎", encoding="utf-8")
print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
bytearray() 返回一個新字節(jié)數(shù)組. 這個數(shù)字的元素是可變的, 并且每個元素的值得范圍是[0,256)
ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0]) #97
print(ret) #bytearray(b'alex')
ret[0] = 65 #把65的位置A賦值給ret[0]
print(str(ret)) #bytearray(b'Alex')
ord() 輸入字符找?guī)ё址幋a的位置
chr() 輸入位置數(shù)字找出對應的字符
ascii() 是ascii碼中的返回該值 不是就返回u
print(ord('a')) # 字母a在編碼表中的碼位:97
print(ord('中')) # '中'字在編碼表中的位置:20013
print(chr(65)) # 已知碼位,求字符是什么:A
print(chr(19999)) #丟
for i in range(65536): #打印出0到65535的字符
print(chr(i), end=" ")
print(ascii("@")) #'@'
repr() 返回一個對象的string形式
s = "今天\n吃了%s頓\t飯" % 3
print(s)#今天# 吃了3頓 飯
print(repr(s)) # 原樣輸出,過濾掉轉(zhuǎn)義字符 \n \t \r 不管百分號%
#'今天\n吃了3頓\t飯'
2. 數(shù)據(jù)集合
字典：dict 創(chuàng)建一個字典
集合：set 創(chuàng)建一個集合
frozenset() 創(chuàng)建一個凍結的集合，凍結的集合不能進行添加和刪除操作。
3. 相關內(nèi)置函數(shù)
len() 返回一個對象中的元素的個數(shù)
sorted() 對可迭代對象進行排序操作 (lamda)
語法：sorted(Iterable, key=函數(shù)(排序規(guī)則), reverse=False)
Iterable: 可迭代對象
key: 排序規(guī)則(排序函數(shù)), 在sorted內(nèi)部會將可迭代對象中的每一個元素傳遞給這個函數(shù)的參數(shù). 根據(jù)函數(shù)運算的結果進行排序
reverse: 是否是倒敘. True: 倒敘, False: 正序
lst = [5,7,6,12,1,13,9,18,5]
lst.sort() # sort是list里面的一個方法
print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
ll = sorted(lst) # 內(nèi)置函數(shù). 返回給你一個新列表 新列表是被排序的
print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
l2 = sorted(lst,reverse=True) #倒序
print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根據(jù)字符串長度給列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
return len(s)
l1 = sorted(lst, key=f, )
print(l1) #['one', 'two', 'six', 'four', 'five', 'three']
enumerate() 獲取集合的枚舉對象
lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1): # 把索引和元素一起獲取,索引默認從0開始. 可以更改
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
all() 可迭代對象中全部是True, 結果才是True
any() 可迭代對象中有一個是True, 結果就是True
print(all([1,'hello',True,9])) #True
print(any([0,0,0,False,1,'good'])) #True
zip() 函數(shù)用于將可迭代的對象作為參數(shù), 將對象中對應的元素打包成一個元組, 然后返回由這些元組組成的列表. 如果各個迭代器的元素個數(shù)不一致, 則返回列表長度與最短的對象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉鄉(xiāng)民謠', '驢得水', '放牛班的春天', '美麗人生', '辯護人', '被嫌棄的松子的一生']
lst3 = ['美國', '中國', '法國', '意大利', '韓國', '日本']
print(zip(lst1, lst1, lst3)) #
for el in zip(lst1, lst2, lst3):
print(el)
# (1, '醉鄉(xiāng)民謠', '美國')
# (2, '驢得水', '中國')
# (3, '放牛班的春天', '法國')
# (4, '美麗人生', '意大利')
# (5, '辯護人', '韓國')
# (6, '被嫌棄的松子的一生', '日本')
fiter() 過濾 (lamda)
語法：fiter(function. Iterable)
function: 用來篩選的函數(shù). 在?lter中會自動的把iterable中的元素傳遞給function. 然后根據(jù)function返回的True或者False來判斷是否保留留此項數(shù)據(jù) , Iterable: 可迭代對象
搜索公眾號頂級架構師后臺回復“面試”，送你一份驚喜禮包。
def func(i): # 判斷奇數(shù)
return i % 2 == 1
lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst) #l1是迭代器
print(l1) #
print(list(l1)) #[1, 3, 5, 7, 9]
map() 會根據(jù)提供的函數(shù)對指定序列列做映射(lamda)
語法 : map(function, iterable)
可以對可迭代對象中的每一個元素進行映射. 分別去執(zhí)行 function
def f(i): return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代對象中的每一個元素傳遞給前面的函數(shù)進行處理. 處理的結果會返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]
和作用域相關
locals() 返回當前作用域中的名字
globals() 返回全局作用域中的名字
def func():
a = 10
print(locals()) # 當前作用域中的內(nèi)容
print(globals()) # 全局作用域中的內(nèi)容
print("今天內(nèi)容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,
# '__spec__': None, '__annotations__': {}, '__builtins__':
# (built-in), '__file__': 'D:/pycharm/練習/week03/new14.py', '__cached__': None,
# 'func': }
# 今天內(nèi)容很多
和迭代器生成器相關
range() 生成數(shù)據(jù)
next() 迭代器向下執(zhí)行一次, 內(nèi)部實際使?用了__ next__()?方法返回迭代器的下一個項目
iter() 獲取迭代器, 內(nèi)部實際使用的是__ iter__()?方法來獲取迭代器
for i in range(15,-1,-5):
print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst) # __iter__()獲得迭代器
print(it.__next__()) #1
print(next(it)) #2 __next__()
print(next(it)) #3
print(next(it)) #4
字符串類型代碼的執(zhí)行
eval() 執(zhí)行字符串類型的代碼. 并返回最終結果
exec() 執(zhí)行字符串類型的代碼
compile() 將字符串類型的代碼編碼. 代碼對象能夠通過exec語句來執(zhí)行或者eval()進行求值
s1 = input("請輸入a+b:") #輸入:8+9
print(eval(s1)) # 17 可以動態(tài)的執(zhí)行代碼. 代碼必須有返回值
s2 = "for i in range(5): print(i)"
a = exec(s2) # exec 執(zhí)行代碼不返回任何內(nèi)容
# 0
# 1
# 2
# 3
# 4
print(a) #None
# 動態(tài)執(zhí)行代碼
exec("""
def func():
print(" 我是周杰倫")
""" )
func() #我是周杰倫
code1 = "for i in range(3): print(i)"
com = compile(code1, "", mode="exec") # compile并不會執(zhí)行你的代碼.只是編譯
exec(com) # 執(zhí)行編譯的結果
# 0
# 1
# 2
code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2)) # 18
code3 = "name = input('請輸入你的名字:')" #輸入:hello
com3 = compile(code3, "", mode="single")
exec(com3)
print(name) #hello
輸入輸出
print() : 打印輸出
input() : 獲取用戶輸出的內(nèi)容
print("hello", "world", sep="*", end="@") # sep:打印出的內(nèi)容用什么連接,end:以什么為結尾
#hello*world@
內(nèi)存相關
hash() : 獲取到對象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空間換的時間 比較耗費內(nèi)存
s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #報錯,列表是不可哈希的 id() : 獲取到對象的內(nèi)存地址s = 'alex'print(id(s)) #2278345368944
文件操作相關
open() : 用于打開一個文件, 創(chuàng)建一個文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()
模塊相關
__ import__() : 用于動態(tài)加載類和函數(shù)
# 讓用戶輸入一個要導入的模塊
import os
name = input("請輸入你要導入的模塊:")
__import__(name) # 可以動態(tài)導入模塊
幫 助
help() : 函數(shù)用于查看函數(shù)或模塊用途的詳細說明
print(help(str)) #查看字符串的用途
調(diào)用相關
callable() : 用于檢查一個對象是否是可調(diào)用的. 如果返回True, object有可能調(diào)用失敗, 但如果返回False. 那調(diào)用絕對不會成功
a = 10
print(callable(a)) #False 變量a不能被調(diào)用
def f():
print("hello")
print(callable(f)) # True 函數(shù)是可以被調(diào)用的
查看內(nèi)置屬性
dir() : 查看對象的內(nèi)置屬性, 訪問的是對象中的__dir__()方法
print(dir(tuple)) #查看元組的方法
你還有什么想要補充的嗎？
免責聲明：本文內(nèi)容來源于網(wǎng)絡，文章版權歸原作者所有，意在傳播相關技術知識行業(yè)趨勢，供大家學習交流，若涉及作品版權問題，請聯(lián)系刪除或授權事宜。
技術君個人微信
添加技術君個人微信即送一份驚喜大禮包
→ 技術資料共享
→ 技術交流社群
--END--
往日熱文：
Python程序員深度學習的“四大名著”：
這四本書著實很不錯！我們都知道現(xiàn)在機器學習、深度學習的資料太多了，面對海量資源，往往陷入到“無從下手”的困惑出境。而且并非所有的書籍都是優(yōu)質(zhì)資源，浪費大量的時間是得不償失的。給大家推薦這幾本好書并做簡單介紹。
獲得方式：
2.后臺回復關鍵詞：名著
Python 字典(Dictionary) get() 函數(shù)返回指定鍵的值，如果值不在字典中返回默認值。
重慶分公司
重慶分公司
