所謂內(nèi)置函數(shù)，就是Python/ target=_blank class=infotextkey>Python提供的, 可以直接拿來直接用的函數(shù)，比如大家熟悉的print，range、input等，也有不是很熟，但是很重要的，如enumerate、zip、join等，Python內(nèi)置的這些函數(shù)非常精巧且強(qiáng)大的，對初學(xué)者來說，經(jīng)常會忽略，但是偶爾會碰到，我也是用了一段時間python之后才發(fā)現(xiàn)，還有這么好的函數(shù)，每個函數(shù)都非常經(jīng)典，而且經(jīng)過嚴(yán)格測試，使用內(nèi)置函數(shù)，不用自己閉門造車，并且代碼簡潔易讀了很多，真是方便又實(shí)用，值得花時間進(jìn)行體系化研究學(xué)習(xí)。

初學(xué)者的代碼之所以寫的不簡潔，不是因?yàn)閷W(xué)的不夠好，而是學(xué)的不夠多，很多內(nèi)置的東西都沒學(xué)透。

一、數(shù)字相關(guān)

01 數(shù)據(jù)類型

bool()

描述：測試一個對象是True, 還是False.bool 是 int 的子類。

語法：class bool([x])

參數(shù)：x -- 要進(jìn)行轉(zhuǎn)換的參數(shù)。

bool([0,0,0])
True

bool([])
False

issubclass(bool, int)  # bool 是 int 子類
True

True+True
2

12/True
12.0

int()

描述：int() 函數(shù)用于將一個字符串或數(shù)字轉(zhuǎn)換為整型。 x可能為字符串或數(shù)值，將x 轉(zhuǎn)換為一個普通整數(shù)。如果參數(shù)是字符串，那么它可能包含符號和小數(shù)點(diǎn)。如果超出了普通整數(shù)的表示范圍，一個長整數(shù)被返回。

語法：int(x, base =10)

參數(shù)：

• x -- 字符串或數(shù)字。
• base -- 進(jìn)制數(shù)，默認(rèn)十進(jìn)制。

int('12',16)
18

int('12',10)
12

float()

描述：將一個字符串或整數(shù)轉(zhuǎn)換為浮點(diǎn)數(shù)

語法：class float([x])

參數(shù)：x -- 整數(shù)或字符串

float(3)
3.0

float('123') 
 123.0

complex()

描述：創(chuàng)建一個復(fù)數(shù)

語法：class complex([real[, imag]])

參數(shù)：

• real -- int, long, float或字符串；
• imag -- int, long, float；

complex(1,2)
(1+2j) 

complex('1')
(1+0j)
complex("1+2j")
(1+2j)

02 進(jìn)制轉(zhuǎn)換

bin()

描述：bin() 返回一個整數(shù) int 或者長整數(shù) long int 的二進(jìn)制表示。將十進(jìn)制轉(zhuǎn)換為二進(jìn)制

語法：bin(x)

參數(shù)：x -- int 或者 long int 數(shù)字

bin(2)
'0b10'

bin(20)
'0b10100'

oct()

描述：將十進(jìn)制轉(zhuǎn)換為八進(jìn)制 otc() 將給的參數(shù)轉(zhuǎn)換成八進(jìn)制

語法：oct(x)

參數(shù)：x -- 整數(shù)。

oct(8)
'0o10'

oct(43)
'0o53'

hex()

描述：hex() 函數(shù)用于將10進(jìn)制整數(shù)轉(zhuǎn)換成16進(jìn)制，以字符串形式表示。

語法：hex(x)

參數(shù)：x -- 10進(jìn)制整數(shù)。

將十進(jìn)制轉(zhuǎn)換為十六進(jìn)制
hex(43)
'0x2b'#43等于2B

hex(15)
'0xf'

03 數(shù)學(xué)運(yùn)算

abs()

描述：返回?cái)?shù)字絕對值或復(fù)數(shù)的模

語法：abs( x )

參數(shù)：x 數(shù)值表達(dá)式。

abs(-6)
6
abs(5j+4)
6.4031242374328485

divmod()

描述：divmod() 函數(shù)把除數(shù)和余數(shù)運(yùn)算結(jié)果結(jié)合起來，返回一個包含商和余數(shù)的元組(a // b, a % b)。

語法：divmod(a, b)

參數(shù)：a: 數(shù)字--被除數(shù)

b: 數(shù)字--除數(shù)

divmod(11,3)
(3, 2)

divmod(20,4)
(5, 0)

round()

描述：round() 函數(shù)返回浮點(diǎn)數(shù)x的四舍五入值。

語法：round( x [, n] )

參數(shù)：

• x -- 數(shù)值表達(dá)式。
• n --代表小數(shù)點(diǎn)后保留幾位

round(10.0222222, 3)
10.022

pow()

描述：pow(x，y) 方法返回x的y次方的值，等價于x**y。函數(shù)是計(jì)算x的y次方，如果z在存在，則再對結(jié)果進(jìn)行取模，其結(jié)果等效于pow(x,y) %z

語法：pow(x, y[, z])

參數(shù)：

• x -- 數(shù)值表達(dá)式。
• y -- 數(shù)值表達(dá)式。
• z -- 數(shù)值表達(dá)式。

pow(10, 2)
100

10**2
100

pow(4,3,5)
 4
等價于4**3%

sum()

描述：sum() 方法對系列進(jìn)行求和計(jì)算。

語法：sum(iterable[, start])

參數(shù)：

• iterable -- 可迭代對象，如：列表、元組、集合。
• start -- 指定相加的參數(shù)，如果沒有設(shè)置這個值，默認(rèn)為0。

a = [1,4,2,3,1]
sum(a)
11
 
sum(a,10) #求和的初始值為10
21

min()

描述：min() 方法返回給定參數(shù)的最小值，參數(shù)可以為序列。

語法：min( x, y, z, .... )

參數(shù)：

• x -- 數(shù)值表達(dá)式。
• y -- 數(shù)值表達(dá)式。
• z -- 數(shù)值表達(dá)式。

min(80, 100, 1000)
80
min([80, 100, 1000])
80

max()

描述：max() 方法返回給定參數(shù)的最大值，參數(shù)可以為序列。

語法：max( x, y, z, .... )

參數(shù)：

• x -- 數(shù)值表達(dá)式。
• y -- 數(shù)值表達(dá)式。
• z -- 數(shù)值表達(dá)式。

最大值：
max(3,1,4,2,1)
4

di = {'a':3,'b1':1,'c':4}
max(di)
'c'

二、數(shù)據(jù)結(jié)構(gòu)相關(guān)

01 序列數(shù)據(jù)類型

1）列表和元組

list()

描述：list() 函數(shù)創(chuàng)建列表或者用于將序列轉(zhuǎn)換為列表。

語法：list( iterable )

參數(shù)：iterable -- 可迭代序列。

序列為元組時

s=(123, 'xyz', 'zara', 'abc')
list(S)
[123, 'xyz', 'zara', 'abc']

序列為字符串

s= '小伍哥真是帥，特別帥' 
list(s)
['小', '伍', '哥', '真', '是', '帥', '，', '特', '別', '帥']

序列為字典

s = {'nanme':'小伍哥','age':30,'address':'Hangzhou'}
list(s)
['nanme', 'age', 'address']

tuple()

描述： 元組 tuple() 函數(shù)將列表轉(zhuǎn)換為元組。

語法：tuple( iterable )

參數(shù)：iterable -- 要轉(zhuǎn)換為元組的可迭代序列。

tuple([1,2,3,4])
(1, 2, 3, 4)
 
tuple({'a':2,'b':4})    #針對字典 會返回字典的key組成的tuple
 ('a', 'b')

tuple('小新真的是帥，特別帥')
 ('小', '新', '真', '的', '是', '帥', '，', '特', '別', '帥')   

2）集合數(shù)據(jù)類型

dict()

描述：創(chuàng)建數(shù)據(jù)字典

語法：

class dict(**kwarg)

class dict(mApping, **kwarg)

class dict(iterable, **kwarg)

參數(shù)：

• **kwargs -- 關(guān)鍵字
• mapping -- 元素的容器。
• iterable -- 可迭代對象。

#創(chuàng)建空字典
dict()                       
{}

#傳入關(guān)鍵字
dict(a='a', b='b', t='t')   
{'a': 'a', 'b': 'b', 't': 't'}

# 映射函數(shù)方式來構(gòu)造字典
dict(zip(['one', 'two', 'three'], [1, 2, 3]))  
{'three': 3, 'two': 2, 'one': 1} 

#可迭代對象方式來構(gòu)造字典
dict([('one', 1), ('two', 2), ('three', 3)])    
{'three': 3, 'two': 2, 'one': 

set()

描述：set() 函數(shù)創(chuàng)建一個無序不重復(fù)元素集，可進(jìn)行關(guān)系測試，刪除重復(fù)數(shù)據(jù)，還可以計(jì)算交集、差集、并集等。

語法：class set([iterable])

參數(shù)：iterable -- 可迭代對象對象；

#返回一個set對象，可實(shí)現(xiàn)去重：
a = [1,4,2,3,1]
set(a)
{1, 2, 3, 4}

frozenset()

描述：frozenset() 返回一個凍結(jié)的集合，凍結(jié)后集合不能再添加或刪除任何元素。

語法：class frozenset([iterable])

參數(shù)：iterable -- 可迭代的對象，比如列表、字典、元組等等。

創(chuàng)建一個不可修改的集合。
frozenset([1,1,3,2,3])
frozenset({1, 2, 3})

3）字符串

str()

描述：str() 函數(shù)將對象轉(zhuǎn)化為適于人閱讀的形式。將字符類型、數(shù)值類型等轉(zhuǎn)換為字符串類型

語法：class str(object='')

參數(shù)：object -- 對象。

案例：

integ = 100
str(integ)
'100'

dict = {'baidu': 'baidu.com', 'google': 'google.com'};
str(dict)
"{'baidu': 'baidu.com', 'google': 'google.com'}"

format()

描述：Python2.6 開始，新增了一種格式化字符串的函數(shù) str.format()，它增強(qiáng)了字符串格式化的功能?；菊Z法是通過 {} 和 : 來代替以前的 % 。使用format()來格式化字符串時，使用在字符串中使用{}作為占位符，占位符的內(nèi)容將引用format()中的參數(shù)進(jìn)行替換?？梢允俏恢脜?shù)、命名參數(shù)或者兼而有之。

format 函數(shù)可以接受不限個參數(shù)，位置可以不按順序。

語法：format(value, format_spec)

參數(shù)：

# 位置參數(shù)
'{}:您{}購買的{}到了！請下樓取快遞。'.format('快遞小哥','淘寶','快遞')
'快遞小哥:您淘寶購買的快遞到了！請下樓取快遞。'

#給批量客戶發(fā)短息
n_list=['李白','王昭君','西施','小喬','李信','馬超']
for name in n_list:
    print('{0}：您淘寶購買的快遞到了！請下樓取快遞！'.format(name))
李白：您淘寶購買的快遞到了！請下樓取快遞！
王昭君：您淘寶購買的快遞到了！請下樓取快遞！
西施：您淘寶購買的快遞到了！請下樓取快遞！
小喬：您淘寶購買的快遞到了！請下樓取快遞！
李信：您淘寶購買的快遞到了！請下樓取快遞！
馬超：您淘寶購買的快遞到了！請下樓取快遞！  
    
#名字進(jìn)行填充    
for n in n_list:
    print('{0}：您淘寶購買的快遞到了！請下樓取快遞！'.format(n.center(3,'*')))
    
*李白：您淘寶購買的快遞到了！請下樓取快遞！
王昭君：您淘寶購買的快遞到了！請下樓取快遞！
*西施：您淘寶購買的快遞到了！請下樓取快遞！
*小喬：您淘寶購買的快遞到了！請下樓取快遞！
李信：您淘寶購買的快遞到了！請下樓取快遞！
馬超：您淘寶購買的快遞到了！請下樓取快遞！


'{0}, {1} and {2}'.format('gao','fu','shuai')
'gao, fu and shuai'

x=3
y=5
'{0}+{1}={2}'.format(x,y,x+y)

# 命名參數(shù)
'{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai')
'gao, fu and shuai'


# 混合位置參數(shù)、命名參數(shù)
'{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao')
'fu, shuai and gao'

#for循環(huán)進(jìn)行批量處理
["vec_{0}".format(i) for i in range(0,5)]
['vec_0', 'vec_1', 'vec_2', 'vec_3', 'vec_4']

['f_{}'.format(r) for r in list('abcde')]
['f_a', 'f_b', 'f_c', 'f_d',

bytes()

描述：將一個字符串轉(zhuǎn)換成字節(jié)類型

語法：class bytes([source[, encoding[, errors]]])

參數(shù)：

• 如果 source 為整數(shù)，則返回一個長度為 source 的初始化數(shù)組；
• 如果 source 為字符串，則按照指定的 encoding 將字符串轉(zhuǎn)換為字節(jié)序列；
• 如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數(shù)；
• 如果 source 為與 buffer 接口一致的對象，則此對象也可以被用于初始化 bytearray。
• 如果沒有輸入任何參數(shù)，默認(rèn)就是初始化數(shù)組為0個元素。

s = "apple"
bytes(s,encoding='utf-8')
b'apple'

bytes([1,2,3,4])
b'x01x02x03x04'

bytearray()

描述：返回一個新字節(jié)數(shù)組. 這個數(shù)字的元素是可變的, 并且每個元素的值得范圍是[0,256)

語法：class bytearray([source[, encoding[, errors]]])

參數(shù)：

• 如果 source 為整數(shù)，則返回一個長度為 source 的初始化數(shù)組；
• 如果 source 為字符串，則按照指定的 encoding 將字符串轉(zhuǎn)換為字節(jié)序列；
• 如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數(shù)；
• 如果 source 為與 buffer 接口一致的對象，則此對象也可以被用于初始化 bytearray。
• 如果沒有輸入任何參數(shù)，默認(rèn)就是初始化數(shù)組為0個元素。

bytearray()
bytearray(b'')
bytearray([1,2,3])
bytearray(b'x01x02x03')
bytearray('baidu', 'utf-8')
bytearray(b'baidu')

ord()

描述：查看某個ascii對應(yīng)的十進(jìn)制數(shù)

語法：ord(c)

參數(shù)：c -- 字符。

ord('A')
65

ord('~')
126

chr()

描述：chr() 用一個范圍在 range（256）內(nèi)的（就是0～255）整數(shù)作參數(shù)，返回一個對應(yīng)的字符。

語法：chr(i)

參數(shù)：i -- 可以是10進(jìn)制也可以是16進(jìn)制的形式的數(shù)字。

查看十進(jìn)制整數(shù)對應(yīng)的ASCII字符
chr(65)
'A'
可以參考4案例中的表

ascii()

描述：ascii() 函數(shù)返回任何對象（字符串，元組，列表等）的可讀版本。

ascii() 函數(shù)會將所有非 ascii 字符替換為轉(zhuǎn)義字符：

å 將替換為 xe5。

語法：ascii(object)

參數(shù)：object--對象，可以是元組、列表、字典、字符串、set()創(chuàng)建的集合。

ascii('中國')
"'\u4e2d\u56fd'"

ascii('新冠肺炎')
"'\u65b0\u51a0\u80ba\u

ascii("My name is Ståle")
"'My name is St\xe5le'"

print(ascii((1,2))) #元組
(1, 2)
print(type(ascii((1,2))))
<class 'str'>

print(ascii([1,2])) #列表
[1, 2]
print(type(ascii([1,2])))
<class 'str'>

print(ascii('？')) #字符串，非 ASCII字符，轉(zhuǎn)義
'uff1f'
print(type(ascii("？")))
<class 'str'>

print(ascii({1:2,'name':5})) #字典
{1: 2, 'name': 5}
print(type(ascii({1:2,'name':5})))
<class '

ASCII碼表具體如下所示(節(jié)選)

Bin(二進(jìn)制)	Oct(八進(jìn)制)	Dec(十進(jìn)制)	Hex(十六進(jìn)制)	縮寫/字符	解釋
0000 0000	00	0	0x00	NUL(null)	空字符
0010 0001	041	33	0x21	!	嘆號
0010 0010	042	34	0x22	"	雙引號
0010 1010	052	42	0x2A	*	星號
...	...	...	...	...	...
0111 1101	0175	125	0x7D	}	閉花括號
0111 1110	0176	126	0x7E	~	波浪號
0111 1111	0177	127	0x7F	DEL (delete)	刪除

repr()

返回一個對象的string形式

03 數(shù)據(jù)結(jié)構(gòu)處理相關(guān)函數(shù)

len()

描述：len() 函數(shù)返回對象（字符、列表、元組等）長度或項(xiàng)目個數(shù)。

語法：len(s)

參數(shù)：s -- 對象。

#字典的長度
dic = {'a':1,'b':3}
len(dic)
2


#字符串長度
s='aasdf'
len(s)
5


#列表元素個數(shù)
l = [1,2,3,4,5]
len(l)              

sorted()

描述：sorted()函數(shù)對所有可迭代的對象進(jìn)行排序操作。

語法：sorted(iterable, key=None, reverse=False)

參數(shù)：

• iterable--可迭代對象。
• key--主要是用來進(jìn)行比較的元素,只有一個參數(shù),具體的函數(shù)的參數(shù)就是取自于可迭代對象中,指定可迭代對象中的一個元素來進(jìn)行排序。
• reverse -- 排序規(guī)則,reverse=True降序 ,reverse = False升序(默認(rèn))。

a = [5,7,6,3,4,1,2]
b = sorted(a)       #保留原列表
a 
[5, 7, 6, 3, 4, 1, 2]
b
[1, 2, 3, 4, 5, 6, 7]
 
#利用key
L=[('b',2),('a',1),('c',3),('d',4)]


sorted(L, key=lambda x:x[1])  
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]


#按年齡排序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) 
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]


#按降序
sorted(students, key=lambda s: s[2], reverse=True)  
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
 
#降序排列
a = [1,4,2,3,1]
sorted(a,reverse=True) 
[4, 3, 2, 1, 1

sort 與 sorted 區(qū)別：

sort 是應(yīng)用在list 的方法，sorted可以對所有可迭代的對象進(jìn)行排序操作；list的sort 方法返回的是對已經(jīng)存在的列表進(jìn)行操作，無返回值，而內(nèi)建函數(shù)sorted方法返回的是一個新的 list，而不是在原來的基礎(chǔ)上進(jìn)行的操作。

reversed()

描述：reversed函數(shù)返回一個反轉(zhuǎn)的迭代器。

語法：reversed(seq)

參數(shù)：seq -- 要轉(zhuǎn)換的序列，可以是 tuple, string, list 或 range。

#反轉(zhuǎn)列表
rev = reversed([1,4,2,3,1])
list(rev)
[1, 3, 2, 4, 1]


#反轉(zhuǎn)字符串
rev = reversed('我愛中國')
list(rev)
['國', '中', '愛', '我']


''.join(rev)
'國中愛我'


s = '我的世界開始下雪'
''.join(reversed(s))
'雪下始開界世的

slice()

描述：slice() 函數(shù)實(shí)現(xiàn)切片對象，主要用在切片操作函數(shù)里的參數(shù)傳遞。返回一個表示由 range(start, stop, step) 所指定索引集的 slice對象

語法：

• class slice(stop)
• class slice(start, stop[, step])

參數(shù)：

• start -- 起始位置
• stop -- 結(jié)束位置
• step -- 間距

a = [1,4,2,3,1]
a[slice(0,5,2)] #等價于a[0:5:2]
[1, 2, 1]

a = list(range(10))
a[slice(3)]
[0, 1, 2

enumerate()

描述：enumerate() 函數(shù)用于將一個可遍歷的數(shù)據(jù)對象(如列表、元組或字符串)組合為一個索引序列，同時列出數(shù)據(jù)和數(shù)據(jù)下標(biāo)，一般用在for循環(huán)當(dāng)中。返回一個可以枚舉的對象，該對象的next()方法將返回一個元組。enumerate在字典上是枚舉、列舉的意思。

語法：enumerate(sequence, [start=0])

參數(shù)：sequence -- 一個序列、迭代器或其他支持迭代對象。

start -- 下標(biāo)起始位置。

L = ['Spring', 'Summer', 'Fall', 'Winter']
enumerate(L)
<enumerate at 0x226e1ee1138>#生成的額迭代器，無法直接查看


list(enumerate(L))#列表形式，可以看到內(nèi)部結(jié)構(gòu)，默認(rèn)下標(biāo)從0開始
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
 
list(enumerate(L, start=1)) #下標(biāo)從 1 開始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]


for i,v in enumerate(L):
    print(i,v)
0 Spring
1 Summer
2 Fall
3 Winter

for i,v in enumerate(L,1):
    print(i,v)


1 Spring
2 Summer
3 Fall
4 Winter

s = ["a","b","c"]
 
for i ,v in enumerate(s,2):
    print(i,v)
2 a
3 b
4 c

普通的 for 循環(huán)
i = 0
seq = ['one', 'two', 'three']
for element in seq:
    print (i, seq[i])
    i+= 1
0 one
1 two
2 three

在看一個普通循環(huán)的對比案例    
for 循環(huán)使用 enumerate
 
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print (i, element)
 
0 one
1 two
2 three
 
seq = ['one', 'two', 'three']
for i, element in enumerate(seq,2):
    print (i, element)
2 one
3 two
4 three

all()

描述：接受一個迭代器，如果迭代器(元組或列表)的所有元素都為真，那么返回True，否則返回False，元素除了是0、空、None、False外都算 True。注意：空元組、空列表返回值為True，這里要特別注意。

語法：all(iterable)

參數(shù)：iterable -- 元組或列表

案例：

all([1,0,3,6])
False
 
all([1,9,3,6])
True
 
all(['a', 'b', '', 'd'])
False


all([]) #空列表為真
True
 
all(()) #空元組為真
True

any()

描述：接受一個迭代器，如果迭代器里有一個元素為真，那么返回True，否則返回False，元素除了是 0、空、None、False 外都算 True。

語法：any(iterable)

參數(shù)：iterable -- 元組或列表

any([0,0,0,[]])
False
 
any([0,0,1])
True
 
any((0, '', False))  
False
 
any([]) # 空列表
False
 
any(()) # 空元組
False

zip()

描述：zip() 函數(shù)用于將可迭代的對象作為參數(shù)，將對象中對應(yīng)的元素打包成一個個元組，然后返回由這些元組組成的對象，這樣做的好處是節(jié)約了不少的內(nèi)存。我們可以使用 list() 轉(zhuǎn)換來輸出列表。，如果各個迭代器的元素個數(shù)不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。

語法：zip([iterable, ...])

參數(shù)：iterable 一個或多個迭代器

創(chuàng)建一個聚合了來自每個可迭代對象中的元素的迭代器：
x = [3,2,1]
y = [4,5,6]
list(zip(y,x))
[(4, 3), (5, 2), (6, 1)]


#搭配for循環(huán)，數(shù)字與字符串組合 
a = range(5)
b = list('abcde')
[str(y)+str(x) for x,y in zip(a,b)]
['a0', 'b1', 'c2', 'd3', 'e4']


#數(shù)數(shù)相乘
list1 = [2,3,4]
list2 = [5,6,7]
for x,y in zip(list1,list2):
    print(x,'*',y,'--',x*y)
2 * 5 -- 10
3 * 6 -- 18
4 * 7 -- 28


#元素個數(shù)與最短的列表一致
list(zip(x,b))
 [(3, 'a'), (2, 'b'), (1, 'c')]s


#與 zip 相反，zip(* ) 可理解為解壓，返回二維矩陣式
a1, a2 = zip(*zip(a,b))          
a1
(0, 1, 2, 3, 4)
a2
('a', 'b', 'c', 'd', 

filter()

描述：filter() 函數(shù)用于過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。該接收兩個參數(shù)，第一個為函數(shù)，第二個為序列，序列的每個元素作為參數(shù)傳遞給函數(shù)進(jìn)行判斷，然后返回 True 或 False，最后將返回 True 的元素放到新列表中。

語法：filter(function, iterable)

參數(shù)：

• function -- 判斷函數(shù)。
• iterable -- 可迭代對象。

fil = filter(lambda x: x>10,[1,11,2,45,7,6,13])
fil
 <filter at 0x28b693b28c8>
list(fil)
[11, 45, 13]


def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))
[1, 3, 5, 7, 9]

map()

描述：map() 會根據(jù)提供的函數(shù)對指定序列做映射。返回一個將 function 應(yīng)用于 iterable 中每一項(xiàng)并輸出其結(jié)果的迭代器

語法：map(function, iterable, ...)

參數(shù)：

• function -- 函數(shù)
• iterable -- 一個或多個序列

def square(x) :            # 計(jì)算平方數(shù)
    return x ** 2
list(map(square, [1,2,3,4,5]))   # 計(jì)算列表各個元素的平方
[1, 4, 9, 16, 25]


list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))  # 使用 lambda 匿名函數(shù)
[1, 4, 9, 16, 25]


# 提供了兩個列表，對相同位置的列表數(shù)據(jù)進(jìn)行相加
list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
[3, 7, 11, 15, 19]

list(map(lambda x: x%2==1, [1,3,2,4,1]))
[True, True, False, False, True]

三、和作用域相關(guān)

locals()

描述：locals() 函數(shù)會以字典類型返回當(dāng)前位置的全部局部變量。對于函數(shù), 方法, lambda 函式, 類, 以及實(shí)現(xiàn)了 __call__ 方法的類實(shí)例, 它都返回 True。

語法：locals()

globals()

描述： 函數(shù)會以字典類型返回當(dāng)前位置的全部全局變量。

語法：globals()

參數(shù)：無

a='runoob'
print(globals()) # globals 函數(shù)返回一個全局變量的字典，包括所有導(dǎo)入的變量。

四、迭代器生成器

range()

描述：range() 函數(shù)可創(chuàng)建一個整數(shù)列表，一般用在 for 循環(huán)中。

語法：range(start, stop[, step])

參數(shù)：

• start: 計(jì)數(shù)從 start 開始。默認(rèn)是從 0 開始。例如range（5）等價于range（0， 5）;
• stop: 計(jì)數(shù)到 stop 結(jié)束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5
• step：步長，默認(rèn)為1。例如：range（0，5）等價于 range(0, 5, 1)

案例：

list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
list(range(1, 11))  # 從 1 開始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]

for i in range(5):
    print(i)
0
1
2
3
4

next()

描述：next() 返回迭代器的下一個項(xiàng)目。next() 函數(shù)要和生成迭代器的iter() 函數(shù)一起使用。

語法：next(iterator[, default])

參數(shù)：

• iterator -- 可迭代對象
• default -- 可選，用于設(shè)置在沒有下一個元素時返回該默認(rèn)值，如果不設(shè)置，又沒有下一個元素則會觸發(fā)StopIteration異常。

不加默認(rèn)值的情況，最后會報(bào)錯StopIteration

it = iter([5,3,4,1])
next(it)
5
next(it)
3
next(it)
4
next(it)
1
next(it)
Traceback (most recent call last):
  File "<ipython-input-392-bc1ab118995a>", line 1, in <module>
    next(it)
StopIteration

加默認(rèn)值的情況，最后迭代完了，會返回默認(rèn)值

it = iter([0,1,2,3,4])
next(it,'結(jié)束了')
0
next(it,'結(jié)束了')
1
next(it,'結(jié)束了')
2
next(it,'結(jié)束了')
3
next(it,'結(jié)束了')
4
next(it,'結(jié)束了')
'結(jié)束了'

iter()

描述：返回一個 iterator 對象

語法：iter(object[, sentinel])

參數(shù)：

• object -- 支持迭代的集合對象。
• sentinel -- 如果傳遞了第二個參數(shù)，則參數(shù) object 必須是一個可調(diào)用的對象（如，函數(shù)），此時，iter 創(chuàng)建了一個迭代器對象，每次調(diào)用這個迭代器對象的__next__()方法時，都會調(diào)用 object。

iter([0,1,2,3,4])
<list_iterator at 0x2aa87d32988>


for i in iter([0,1,2,3,4]):
print(i)
0
1
2
3
4   

五、字符串類型代碼的執(zhí)行

eval()

描述：將字符串str 當(dāng)成有效的表達(dá)式來求值并返回計(jì)算結(jié)果取出字符串中內(nèi)容

語法：eval(expression[, globals[, locals]])

參數(shù)：

• expression -- 表達(dá)式。
• globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。
• locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。

s = "1 + 3 +5"
eval(s)
9

#要統(tǒng)計(jì)圖片的數(shù)量
str1 = "['https://ww1.sin5n.jpg', 'https://ww1.siqk4he.jpg']"
len(eval(str1))
2

len(str1)
5

exec()

描述：執(zhí)行儲存在字符串或文件中的Python語句，相比于eval，exec可以執(zhí)行更復(fù)雜的Python代碼。

語法：exec(object, globals, locals)

參數(shù)：

• object-- 要執(zhí)行的表達(dá)式。
• globals -- 可選。包含全局參數(shù)的字典。
• locals -- 可選。包含局部參數(shù)的字典。

執(zhí)行字符串或compile方法編譯過的字符串，沒有返回值
s = "print('helloworld')"
r = compile(s,"<string>", "exec")
exec(r)
helloworld

x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
    
func()
60
33
34

compile()

描述：compile() 將 source 編譯成代碼或 AST 對象，將字符串類型的代碼編碼, 代碼對象能夠通過exec語句來執(zhí)行或者eval()進(jìn)行求值

語法：compile(source, filename, mode[, flags[, dont_inherit]])

參數(shù)：

• source -- 字符串或者AST（Abstract Syntax Trees）對象。。
• filename -- 代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認(rèn)的值。
• mode -- 指定編譯代碼的種類。可以指定為 exec, eval, single。
• flags -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。。
• flags和dont_inherit是用來控制編譯源碼時的標(biāo)志

將字符串編譯成python能識別或可以執(zhí)行的代碼，也可以將文字讀成字符串再編譯。
s = "print('helloworld')"
r = compile(s,"<string>", "exec")
 
r
<code object <module> at 0x000000000F819420, file "<string>", line 1>
exec(r)
helloworld

str = "for i in range(0,5): print(i)" 
c = compile(str,'','exec')   # 編譯為字節(jié)代碼對象 
c
<code object <module> at 0x000001EB82C91ED0, file "", line 1>

exec(c)
0
1
2
3
4

六、輸入輸出

print()

描述：print() 方法用于打印輸出，最常見的一個函數(shù)。在 Python3.3 版增加了 flush 關(guān)鍵字參數(shù)。print 在 Python3.x 是一個函數(shù)，但在 Python2.x 版本不是一個函數(shù)，只是一個關(guān)鍵字。

語法：print(*objects, sep=' ', end='n', file=sys.stdout, flush=False)

參數(shù)：

• objects -- 復(fù)數(shù)，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。
• sep -- 用來間隔多個對象，默認(rèn)值是一個空格。
• end -- 用來設(shè)定以什么結(jié)尾。默認(rèn)值是換行符 n，我們可以換成其他字符串。
• file -- 要寫入的文件對象。
• flush -- 輸出是否被緩存通常決定于 file，但如果 flush 關(guān)鍵字參數(shù)為 True，流會被強(qiáng)制刷新。

print("Hello World")  
Hello World


#設(shè)置間隔符
print("www","baidu","com",sep=".")
www.baidu.com

input()

描述：Python3.x 中 input() 函數(shù)接受一個標(biāo)準(zhǔn)輸入數(shù)據(jù)，返回為 string 類型。獲取用戶輸入內(nèi)容

語法：input([prompt])

參數(shù)：prompt:--提示信息

a = input("input:")
input:1234
print(a)
123

七、內(nèi)存相關(guān)

hash()

描述：返回該對象的哈希值（如果它有的話）。哈希值是整數(shù)。它們在字典查找元素時用來快速比較字典的鍵。相同大小的數(shù)字變量有相同的哈希值（即使它們類型不同，如 1 和 1.0），hash表.用空間換的時間 比較耗費(fèi)內(nèi)存，hash() 函數(shù)可以應(yīng)用于數(shù)字、字符串和對象，不能直接應(yīng)用于 list、set、dictionary。

語法：hash(object)

參數(shù)：object -- 對象

在hash()對對象使用時，所得的結(jié)果不僅和對象的內(nèi)容有關(guān)，還和對象的id()，也就是內(nèi)存地址有關(guān)。
class Test:
    def __init__(self, i):
        self.i = i
for i in range(10):
    t = Test(1)
    print(hash(t), id(t))
-9223371853633304640 2931543538696
-9223371853633350840 2931542799496
-9223371853633350832 2931542799624
-9223371853633350756 2931542800840
-9223371853520958964 2933341069512
-9223371853633350668 2931542802248
-9223371853633350796 2931542800200
-9223371853633350748 2931542800968
-9223371853633350856 2931542799240
-9223371853633350880 2931542798856    

hash() 函數(shù)的用途：hash() 函數(shù)的對象字符不管有多長，返回的hash值都是固定長度的，也用于校驗(yàn)程序在傳輸過程中是否被第三方（木馬）修改，如果程序（字符）在傳輸過程中被修改hash值即發(fā)生變化，如果沒有被修改，則hash值和原始的hash值吻合，只要驗(yàn)證hash值是否匹配即可驗(yàn)證程序是否帶木馬（病毒）。

name1 = '正常程序代碼'
name2 = '正常程序代碼帶病毒'
print(hash(name1)) 
-3048480827538126659
print(hash(name2)) 
-9065726187242961328

memoryview()

描述：memoryview() 函數(shù)返回給定參數(shù)的內(nèi)存查看對象(Momory view)。返回由給定實(shí)參創(chuàng)建的“內(nèi)存視圖”對象， Python 代碼訪問一個對象的內(nèi)部數(shù)據(jù)，只要該對象支持緩沖區(qū)協(xié)議 而無需進(jìn)行拷貝

語法：memoryview(obj)

參數(shù)：obj -- 對象

v = memoryview(bytearray("abcefg", 'utf-8'))
v[1]
98
v[-1]
98
 v[1:4]
<memory at 0x0000028B68E26AC8>
v[1:4].tobytes()
b'bce'

八、文件讀寫

open()

描述：open() 函數(shù)用于打開一個文件，創(chuàng)建一個file對象，相關(guān)的方法才可以調(diào)用它進(jìn)行讀寫。所以open（）讀取文件分為兩步。

語法：open(name[, mode[, buffering]])

參數(shù)：

• name : 一個包含了你要訪問的文件名稱的字符串值。
• mode : mode決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數(shù)是非強(qiáng)制的，默認(rèn)文件訪問模式為只讀(r)。
• buffering : 如果 buffering 的值被設(shè)為 0，就不會有寄存。如果 buffering 的值取 1，訪問文件時會寄存行。如果將 buffering 的值設(shè)為大于1的整數(shù)，表明了這就是的寄存區(qū)的緩沖大小。如果取負(fù)值，寄存區(qū)的緩沖大小則為系統(tǒng)默認(rèn)。

打開文件的模式：

r： 打開一個文件用于只讀，文件的指針將會放在文件的開頭，這是默認(rèn)模式。

w：打開一個文件用于寫入，如果文件存在則打開文件，并從開頭開始編輯，即原有內(nèi)容會被刪除。如果該文件不存在，創(chuàng)建新文件。

a：打開一個文件用于追加，如果文件已存在，文件指針將會放在文件的結(jié)尾，如果文件不存在，創(chuàng)建新文件進(jìn)行寫入。

r+：打開一個文件用于讀寫，文件指針將會放在文件的開頭。

w+：打開一個文件用于讀寫。如果該文件已存在，刪除原有內(nèi)容并從開頭開始編輯；如果該文件不存在，創(chuàng)建新文件。

a+：打開一個文件用于讀寫。如果該文件已存在，文件指針將會放在文件的結(jié)尾，如果該文件不存在，創(chuàng)建新文件用于讀寫。

rb：以二進(jìn)制格式打開一個文件用于只讀。文件指針將會放在文件的開頭。這是默認(rèn)模式。

rb+：以二進(jìn)制格式打開一個文件用于讀寫。文件指針將會放在文件的開頭。

wb：以二進(jìn)制格式打開一個文件只用于寫入。如果該文件已存在則打開文件，并從開頭開始編輯，即原有內(nèi)容會被刪除。如果該文件不存在，創(chuàng)建新文件。

wb+：以二進(jìn)制格式打開一個文件用于讀寫。如果該文件已存在則打開文件，并從開頭開始編輯，即原有內(nèi)容會被刪除。如果該文件不存在，創(chuàng)建新文件。

ab：以二進(jìn)制格式打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結(jié)尾。也就是說，新的內(nèi)容將會被寫入到已有內(nèi)容之后。如果該文件不存在，創(chuàng)建新文件進(jìn)行寫入。

ab+：以二進(jìn)制格式打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結(jié)尾。如果該文件不存在，創(chuàng)建新文件用于讀寫。

注意：當(dāng)讀取音視頻、圖片等二進(jìn)制文件時，需要采用二進(jìn)制的讀取方法。

file對象方法

file.read([size])：size 未指定則返回整個文件，如果文件大小>2 倍內(nèi)存則有問題，f.read()讀到文件尾時返回""(空字串)。

file.readline()：返回一行。

file.readlines([size]) ：返回包含size行的列表, size 未指定則返回全部行。

for line in file: print(line)：通過迭代器訪問。

file.write()：如果要寫入字符串以外的數(shù)據(jù),先將他轉(zhuǎn)換為字符串。

file.tell()：返回一個整數(shù),表示當(dāng)前文件指針的位置(就是到文件頭的比特?cái)?shù))。

file.seek(偏移量,[起始位置])：用來移動文件指針。偏移量: 單位為比特，可正可負(fù)；起始位置: 0 - 文件頭, 默認(rèn)值; 1 - 當(dāng)前位置; 2 - 文件尾

file.close()：關(guān)閉文件

file = open('test.txt',encoding='utf-8')   #打開文件
file.read()#直接顯示文件所有內(nèi)容
file.readline#顯示第一行
file.close()  #關(guān)閉文件

https://docs.python.org/zh-cn/3/tutorial/inputoutput.html#tut-files

test.txt存儲的的內(nèi)容如下

hello
python
i
love you

read()方法

file = open('test.txt')
file.read() 
'hellonpythonninlove you'

readline(）方法

file = open('test.txt')
file.readline()
'hellon'

readlines()方法

file= open('test.txt')
file.readlines()
['pythonn', 'in', 'love you']

逐行讀取

file = open('test.txt')
for line in file:
    print(line)
hello
python
i
love you    

九、模塊相關(guān)

__ import__()

描述：該函數(shù)會導(dǎo)入 name 模塊，有可能使用給定的 globals 和 locals 來確定如何在包的上下文中解讀名稱。 fromlist 給出了應(yīng)該從由 name 指定的模塊導(dǎo)入對象或子模塊的名稱。 標(biāo)準(zhǔn)實(shí)現(xiàn)完全不使用其 locals 參數(shù)，而僅使用 globals 參數(shù)來確定 import 語句的包上下文。level 指定是使用絕對還是相對導(dǎo)入。 0 (默認(rèn)值) 意味著僅執(zhí)行絕對導(dǎo)入。

語法：__import__(name, globals=None, locals=None, fromlist=(), level=0)

參數(shù)：object -- 對象

語句 import spam的結(jié)果將為與以下代碼作用相同的字節(jié)碼:

spam = __import__('spam.ham', globals(), locals(), [], 0)

十、獲取幫助

help()

描述：返回對象的幫助文檔

語法：help(object)

參數(shù)：object -- 對象

help('sys') # 查看sys模塊的幫助

 

 

可以看到文檔的網(wǎng)址：
https://docs.python.org/3.7/library/sys

查看str數(shù)據(jù)類型的幫助

help('str')  

可以看到，字符串相關(guān)的所有方法用法介紹

 

 

a = [1,2,3]
help(a) # 查看列表list幫助信息
help(a.append)# 顯示list的append方法的幫助

 

 

十、對象調(diào)用

callable()

描述：callable() 函數(shù)用于檢查一個對象是否是可調(diào)用的。如果返回 True，object 仍然可能調(diào)用失??；但如果返回 False，調(diào)用對象object絕對不會成功。對于函數(shù)、方法、lambda 函式、 類以及實(shí)現(xiàn)了 __call__ 方法的類實(shí)例, 它都返回True。

這個函數(shù)一開始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

語法：callable(object)

參數(shù)：object -- 對象

#檢查一個數(shù)字
callable(0)
False

#創(chuàng)建一個函數(shù)
def add(x,y):
    return x+y 
callable(add)
True

#創(chuàng)建一個帶有__call__方法的類
class Dogs:
    def __call__(self):
        return 0
callable(Dogs)    
True

十一、內(nèi)置屬性

dir()

描述：dir() 查看對象的內(nèi)置屬性, 訪問的是對象中的__dir__()方法，函數(shù)不帶參數(shù)時，返回當(dāng)前范圍內(nèi)的變量、方法和定義的類型列表；帶參數(shù)時，返回參數(shù)的屬性、方法列表。如果參數(shù)包含方法__dir__()，該方法將被調(diào)用，如果參數(shù)不包含__dir__()，該方法將最大限度地收集參數(shù)信息。

語法：dir(object)

參數(shù)：object 對象、變量、類型。

#獲得當(dāng)前模塊的屬性列表
dir()
['In','Out', 'exit', 'get_ipython', 'quit']

#查看列表的方法，使用dir([ ])或者dir(list())#查看列表的方法
print(dir(list()))
['__add__', ... 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

dir()訪問的是對象中的__dir__()方法，因此下面的調(diào)用也能得到相同的結(jié)果：

list().__dir__()
[__repr__',, ... 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

print(dir(str))、print(dir(list))、print(dir(dict))、分別獲取各個數(shù)據(jù)類型的方法，不帶參數(shù)時返回當(dāng)前范圍內(nèi)的變量，方法和定義的類型列表；帶參數(shù)時返回參數(shù)的屬性，方法列表。

hasattr()

描述：函數(shù)用于判斷對象是否包含對應(yīng)的屬性。

語法：hasattr(object, name)

參數(shù)：

• object -- 對象。
• name -- 字符串，屬性名。

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
True
print(hasattr(point1, 'y'))
True
print(hasattr(point1, 'z'))
True
print(hasattr(point1, 'no'))  # 沒有該屬性
False