Python初學者必須吃透這69個內置函數!

所謂內置函數，就是Python提供的, 可以直接拿來直接用的函數，比如print，enumerate、format等。Python內置的這些函數非常精巧且強大的，對初學者來說，經常會忽略，但是偶爾會碰到，我也是用了一段時間python之後才發現，哇還有這麼好的函數，每個函數都非常經典，而且經過嚴格測試，使用內置函數，不用自己閉門造車，並且代碼簡潔易讀了很多，真是方便又實用，值得花時間進行體系化研究學習。

初學者的代碼之所以寫的不簡潔，不是因為學的不夠好，而是學的不夠多，很多內置的東西都沒學透。

abs()

delattr()

hash()

memoryview()

set()

all()

dict()

help()

min()

setattr()

any()

dir()

hex()

next()

slice()

ascii()

divmod()

id()

object()

sorted()

bin()

enumerate()

input()

oct()

staticmethod()

bool()

eval()

int()

open()

str()

breakpoint()

exec()

isinstance()

ord()

sum()

bytearray()

filter()

issubclass()

pow()

super()

bytes()

float()

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()

 

一、數字相關

01 數據類型

bool()

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

語法：class bool([x])

參數：x -- 要進行轉換的參數。

bool([0,0,0])Truebool([])Falseissubclass(bool, int)  # bool 是 int 子類True
 
int()
描述：int() 函數用於將一個字符串或數字轉換為整型。x可能為字符串或數值，將x 轉換為一個普通整數。如果參數是字符串，那麼它可能包含符號和小數點。如果超出了普通整數的表示範圍，一個長整數被返回。
語法：int(x, base =10)
參數：
x -- 字符串或數字。
base -- 進位數，默認十進位。
int('12',16)18
int('12',10)12
float()
描述：將一個字符串或整數轉換為浮點數
語法：class float([x])
參數：x -- 整數或字符串
float(3)3.0float('123')  123.0
 
complex()
描述：創建一個複數
語法：class complex([real[, imag]])
參數：
real -- int, long, float或字符串；
imag -- int, long, float；
complex(1,2)(1+2j) 
complex('1')(1+0j)complex("1+2j")(1+2j)
02 進位轉換
bin()
描述：bin() 返回一個整數 int 或者長整數 long int 的二進位表示。將十進位轉換為二進位
語法：bin(x)
參數：x -- int 或者 long int 數字
bin(2)'0b10'
bin(20)'0b10100'
oct()
描述：將十進位轉換為八進位 otc() 將給的參數轉換成八進位
語法：oct(x)
參數：x -- 整數。
oct(8)'0o10'
oct(43)'0o53'
hex()
描述：hex() 函數用於將10進位整數轉換成16進位，以字符串形式表示。
語法：hex(x)
參數：x -- 10進位整數。
將十進位轉換為十六進位
hex(43)'0x2b'#43等於2B
hex(15)'0xf'
 
03 數學運算
abs()
描述：返回數字絕對值或複數的模
語法：abs( x )
參數：x 數值表達式。
abs(-6)6abs(5j+4)6.4031242374328485
 
divmod()
描述：divmod() 函數把除數和餘數運算結果結合起來，返回一個包含商和餘數的元組(a // b, a % b)。
語法：divmod(a, b)
參數：a: 數字--被除數
          b: 數字--除數
divmod(11,3)(3, 2)
divmod(20,4)(5, 0)
 
round()
描述：round() 函數返回浮點數x的四捨五入值。
語法：round( x [, n]  )
參數：
x -- 數值表達式。
n --代表小數點後保留幾位
round(10.0222222, 3)10.022
 
pow()
描述：pow(x，y) 方法返回x的y次方的值，等價於x**y。函數是計算x的y次方，如果z在存在，則再對結果進行取模，其結果等效於pow(x,y) %z
語法：pow(x, y[, z])
參數：
x -- 數值表達式。
y -- 數值表達式。
z -- 數值表達式。
pow(10, 2)100
10**2100
pow(4,3,5)4等價於4**3%
sum()
描述：sum() 方法對系列進行求和計算。
語法：sum(iterable[, start])
參數：
a = [1,4,2,3,1]sum(a)11
sum(a,10) #求和的初始值為1021
 
min()
描述：min() 方法返回給定參數的最小值，參數可以為序列。
語法：min( x, y, z, .... )
參數：
x -- 數值表達式。
y -- 數值表達式。
z -- 數值表達式。
min(80, 100, 1000)80min([80, 100, 1000])80
 
max()
描述：max() 方法返回給定參數的最大值，參數可以為序列。
語法：max( x, y, z, .... )
參數：
x -- 數值表達式。
y -- 數值表達式。
z -- 數值表達式。
max(3,1,4,2,1)4
di = {'a':3,'b1':1,'c':4}max(di)'c'
 
二、數據結構相關
01 序列數據類型
1）列表和元組
list()
描述：list() 函數創建列表或者用於將序列轉換為列表。
語法：list( iterable )
參數：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() 函數將列錶轉換為元組。語法：tuple( iterable )參數：iterable -- 要轉換為元組的可迭代序列。案例：tuple([1,2,3,4])(1, 2, 3, 4)
tuple({'a':2,'b':4})    #針對字典 會返回字典的key組成的tuple ('a', 'b')
tuple('小伍哥真是帥，特別帥') ('小', '伍', '哥', '真', '是', '帥', '，', '特', '別', '帥')   
2）集合數據類型
dict()
描述：創建數據字典
語法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
參數：
**kwargs -- 關鍵字
mapping -- 元素的容器。
iterable -- 可迭代對象。
#創建空字典dict()                       {}#傳入關鍵字dict(a='a', b='b', t='t')   {'a': 'a', 'b': 'b', 't': 't'}# 映射函數方式來構造字典dict(zip(['one', 'two', 'three'], [1, 2, 3]))  {'three': 3, 'two': 2, 'one': 1} #可迭代對象方式來構造字典dict([('one', 1), ('two', 2), ('three', 3)])    {'one': 1, 'two': 2, 'three': 3}
 
set()
描述：set() 函數創建一個無序不重複元素集，可進行關係測試，刪除重複數據，還可以計算交集、差集、併集等。
語法：class set([iterable])
參數：iterable -- 可迭代對象對象；
#返回一個set對象，可實現去重：a = [1,4,2,3,1]set(a){1, 2, 3, 4}
 
frozenset()
描述：frozenset() 返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素。
語法：class frozenset([iterable])
參數：iterable -- 可迭代的對象，比如列表、字典、元組等等。
創建一個不可修改的集合。frozenset([1,1,3,2,3])frozenset({1, 2, 3})
 
3）字符串
str()
描述：str() 函數將對象轉化為適於人閱讀的形式。將字符類型、數值類型等轉換為字符串類型
語法：class str(object='')
參數：object -- 對象。
integ = 100str(integ)'100'
dict = {'baidu': 'baidu.com', 'google': 'google.com'};str(dict)"{'baidu': 'baidu.com', 'google': 'google.com'}"
 
format()
描述：Python2.6 開始，新增了一種格式化字符串的函數 str.format()，它增強了字符串格式化的功能。基本語法是通過 {} 和 : 來代替以前的 % 。使用format()來格式化字符串時，使用在字符串中使用{}作為佔位符，佔位符的內容將引用format()中的參數進行替換。可以是位置參數、命名參數或者兼而有之。
format 函數可以接受不限個參數，位置可以不按順序。
語法：format(value, format_spec)
# 位置參數'{}:您{}購買的{}到了！請下樓取快遞。'.format('快遞小哥','淘寶','快遞')'快遞小哥:您淘寶購買的快遞到了！請下樓取快遞。'
#給批量客戶發短息n_list=['馬雲','馬化騰','麻子','小紅','李彥宏','二狗子']for name in n_list:print('{0}：您淘寶購買的快遞到了！請下樓取快遞！'.format(name))馬雲：您淘寶購買的快遞到了！請下樓取快遞！馬化騰：您淘寶購買的快遞到了！請下樓取快遞！麻子：您淘寶購買的快遞到了！請下樓取快遞！小紅：您淘寶購買的快遞到了！請下樓取快遞！李彥宏：您淘寶購買的快遞到了！請下樓取快遞！二狗子：您淘寶購買的快遞到了！請下樓取快遞！
#名字進行填充    for n in n_list:print('{0}：您淘寶購買的快遞到了！請下樓取快遞！'.format(n.center(3,'*')))
*馬雲：您淘寶購買的快遞到了！請下樓取快遞！馬化騰：您淘寶購買的快遞到了！請下樓取快遞！*麻子：您淘寶購買的快遞到了！請下樓取快遞！*小紅：您淘寶購買的快遞到了！請下樓取快遞！李彥宏：您淘寶購買的快遞到了！請下樓取快遞！二狗子：您淘寶購買的快遞到了！請下樓取快遞！
'{0}, {1} and {2}'.format('gao','fu','shuai')'gao, fu and shuai'x=3y=5'{0}+{1}={2}'.format(x,y,x+y)# 命名參數'{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai')'gao, fu and shuai'# 混合位置參數、命名參數'{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao')'fu, shuai and gao'
#for循環進行批量處理["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', 'f_e']
 
bytes()
描述：將一個字符串轉換成字節類型
語法：class bytes([source[, encoding[, errors]]])
參數：
如果 source 為整數，則返回一個長度為 source 的初始化數組；
如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節序列；
如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數；
如果 source 為與 buffer 接口一致的對象，則此對象也可以被用於初始化 bytearray。
如果沒有輸入任何參數，默認就是初始化數組為0個元素。
s = "apple"bytes(s,encoding='utf-8')b'apple'
bytes([1,2,3,4])b'\x01\x02\x03\x04'
bytearray()
描述：返回一個新字節數組. 這個數字的元素是可變的, 並且每個元素的值得範圍是[0,256)
語法：class bytearray([source[, encoding[, errors]]])
參數：
如果 source 為整數，則返回一個長度為 source 的初始化數組；
如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節序列；
如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數；
如果 source 為與 buffer 接口一致的對象，則此對象也可以被用於初始化 bytearray。
如果沒有輸入任何參數，默認就是初始化數組為0個元素。
bytearray()bytearray(b'')bytearray([1,2,3])bytearray(b'\x01\x02\x03')bytearray('baidu', 'utf-8')bytearray(b'baidu')
 
ord()
描述：查看某個ascii對應的十進位數
語法：ord(c)
參數：c -- 字符。
 
chr()
描述：chr() 用一個範圍在 range（256）內的（就是0～255）整數作參數，返回一個對應的字符。
語法：chr(i)
參數：i -- 可以是10進位也可以是16進位的形式的數字。
查看十進位整數對應的ASCII字符chr(65)'A'可以參考4案例中的表
 
ascii()
描述：ascii() 函數返回任何對象（字符串，元組，列表等）的可讀版本。
ascii() 函數會將所有非 ascii 字符替換為轉義字符：
å 將替換為 \xe5。
語法：ascii(object)
參數：object--對象，可以是元組、列表、字典、字符串、set()創建的集合。
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字符，轉義'\uff1f'print(type(ascii("？")))<class 'str'>
print(ascii({1:2,'name':5})) #字典{1: 2, 'name': 5}print(type(ascii({1:2,'name':5})))<class 'str'>
ASCII碼錶具體如下所示(節選)
Bin
(二進位)
Oct
(八進位)
Dec
(十進位)
Hex
(十六進位)
縮寫/字符
解釋
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 數據結構處理相關函數
len()
描述：len() 函數返回對象（字符、列表、元組等）長度或項目個數。
語法：len(s)
參數：s -- 對象。
#字典的長度dic = {'a':1,'b':3}len(dic)2
#字符串長度s='aasdf'len(s)5
#列表元素個數l = [1,2,3,4,5]len(l)
 
sorted() 
描述：sorted()函數對所有可迭代的對象進行排序操作。
語法：sorted(iterable,  key=None, reverse=False)
參數：
iterable--可迭代對象。
key--主要是用來進行比較的元素,只有一個參數,具體的函數的參數就是取自於可迭代對象中,指定可迭代對象中的一個元素來進行排序。
reverse -- 排序規則,reverse=True降序 ,reverse = False升序(默認)。
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]
#利用keyL=[('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 是應用在list 的方法，sorted可以對所有可迭代的對象進行排序操作；list的sort 方法返回的是對已經存在的列表進行操作，無返回值，而內建函數sorted方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。
reversed()
描述：reversed函數返回一個反轉的迭代器。
語法：reversed(seq)
參數：seq -- 要轉換的序列，可以是 tuple, string, list 或 range。
#反轉列表rev = reversed([1,4,2,3,1])list(rev)[1, 3, 2, 4, 1]
#反轉字符串rev = reversed('我愛中國')list(rev)['國', '中', '愛', '我']
''.join(rev)'國中愛我'
s = '我的世界開始下雪'''.join(reversed(s))'雪下始開界世的我'
 
slice()
描述：slice() 函數實現切片對象，主要用在切片操作函數裡的參數傳遞。返回一個表示由 range(start, stop, step) 所指定索引集的 slice對象
語法：
參數：
start -- 起始位置
stop -- 結束位置
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() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在for循環當中。返回一個可以枚舉的對象，該對象的next()方法將返回一個元組。enumerate在字典上是枚舉、列舉的意思。
語法：enumerate(sequence, [start=0])
參數：sequence -- 一個序列、迭代器或其他支持迭代對象。
           start -- 下標起始位置。
L = ['Spring', 'Summer', 'Fall', 'Winter']enumerate(L)<enumerate at 0x226e1ee1138>#生成的額迭代器，無法直接查看list(enumerate(L))#列表形式，可以看到內部結構，默認下標從0開始[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(L, start=1)) #下標從 1 開始[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
for i,v in enumerate(L):print(i,v)0 Spring1 Summer2 Fall3 Winter
for i,v in enumerate(L,1):    print(i,v)1 Spring2 Summer3 Fall4 Winter
s = ["a","b","c"]
for i ,v in enumerate(s,2):print(i,v)2 a3 b4 c
普通的 for 循環i = 0seq = ['one', 'two', 'three']for element in seq:print (i, seq[i])    i+= 10 one1 two2 three
在看一個普通循環的對比案例    for 循環使用 enumerate
seq = ['one', 'two', 'three']for i, element in enumerate(seq):    print (i, element)0 one1 two2 three seq = ['one', 'two', 'three']for i, element in enumerate(seq,2):print (i, element)2 one3 two4 three

all()
描述：接受一個迭代器，如果迭代器(元組或列表)的所有元素都為真，那麼返回True，否則返回False，元素除了是0、空、None、False外都算 True。注意：空元組、空列表返回值為True，這裡要特別注意。
語法：all(iterable)
參數：iterable -- 元組或列表
案例：
all([1,0,3,6])False
all([1,9,3,6])True
all(['a', 'b', '', 'd'])Falseall([]) #空列表為真True
all(()) #空元組為真True
any()描述：接受一個迭代器，如果迭代器裡有一個元素為真，那麼返回True，否則返回False，元素除了是 0、空、None、False 外都算 True。語法：any(iterable)參數：iterable -- 元組或列表案例：any([0,0,0,[]])False
any([0,0,1])True
any((0, '', False))  False
any([]) # 空列表False
any(()) # 空元組False

zip()
描述：zip() 函數用於將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的對象，這樣做的好處是節約了不少的內存。我們可以使用 list() 轉換來輸出列表。，如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。
語法：zip([iterable,...])
參數：iterable 一個或多個迭代器
創建一個聚合了來自每個可迭代對象中的元素的迭代器：x = [3,2,1]y = [4,5,6]list(zip(y,x))[(4, 3), (5, 2), (6, 1)]#搭配for循環，數字與字符串組合 a = range(5)b = list('abcde')[str(y)+str(x) for x,y in zip(a,b)]['a0', 'b1', 'c2', 'd3', 'e4']#數數相乘list1 = [2,3,4]list2 = [5,6,7]for x,y in zip(list1,list2):print(x,'*',y,'--',x*y)2 * 5 -- 103 * 6 -- 184 * 7 -- 28#元素個數與最短的列表一致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','e')

filter()
描述：filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。該接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判斷，然後返回 True 或 False，最後將返回 True 的元素放到新列表中。
語法：filter(function, iterable)
參數：
function -- 判斷函數。
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() 會根據提供的函數對指定序列做映射。返回一個將 function 應用於 iterable 中每一項並輸出其結果的迭代器
語法：map(function, iterable, ...)
參數：
function -- 函數
iterable -- 一個或多個序列
def square(x) :            # 計算平方數    return x ** 2list(map(square, [1,2,3,4,5]))   # 計算列表各個元素的平方[1, 4, 9, 16, 25]
list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))  # 使用 lambda 匿名函數[1, 4, 9, 16, 25]
# 提供了兩個列表，對相同位置的列表數據進行相加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]
 
三、和作用域相關
locals()
描述：locals() 函數會以字典類型返回當前位置的全部局部變量。對於函數, 方法, lambda 函式, 類, 以及實現了 __call__ 方法的類實例, 它都返回 True。
語法：locals()
 
globals()
描述： 函數會以字典類型返回當前位置的全部全局變量。
語法：globals()
參數：無
a='runoob'print(globals()) #globals 函數返回一個全局變量的字典，包括所有導入的變量。
 
四、迭代器生成器
range()
描述：range() 函數可創建一個整數列表，一般用在 for 循環中。
語法：range(start, stop[, step])
參數：
start: 計數從 start 開始。默認是從 0 開始。例如range（5）等價於range（0， 5）;
stop: 計數到 stop 結束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5
step：步長，默認為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)0123

next()
描述：next() 返回迭代器的下一個項目。next() 函數要和生成迭代器的iter() 函數一起使用。
語法：next(iterator[, default])
參數：
不加默認值的情況，最後會報錯StopIteration
it = iter([5,3,4,1])next(it)5next(it)3next(it)4next(it)1next(it)Traceback (most recent call last):  File "<ipython-input-392-bc1ab118995a>", line 1, in <module>    next(it)StopIteration
加默認值的情況，最後迭代完了，會返回默認值
it = iter([0,1,2,3,4])next(it,'結束了')0next(it,'結束了')1next(it,'結束了')2next(it,'結束了')3next(it,'結束了')4next(it,'結束了')'結束了'
 
iter()
描述：返回一個 iterator 對象
語法：iter(object[, sentinel])
參數：
iter([0,1,2,3,4])<list_iterator at 0x2aa87d32988>
for i in iter([0,1,2,3,4]):print(i)01234
 
五、字符串類型代碼的執行
eval()
描述：將字符串str 當成有效的表達式來求值並返回計算結果取出字符串中內容
語法：eval(expression[, globals[, locals]])
參數：
s = "1 + 3 +5"eval(s)9
#要統計圖片的數量str1 = "['https://ww1.sin5n.jpg', 'https://ww1.siqk4he.jpg']"len(eval(str1))2
len(str1)5
 
exec()
描述：執行儲存在字符串或文件中的Python語句，相比於eval，exec可以執行更複雜的Python代碼。
語法：exec(object, globals, locals)
參數：
object-- 要執行的表達式。
globals -- 可選。包含全局參數的字典。
locals -- 可選。包含局部參數的字典。
執行字符串或compile方法編譯過的字符串，沒有返回值
s = "print('helloworld')"r = compile(s,"<string>", "exec")exec(r)helloworld
x = 10expr = """z = 30sum = x + y + zprint(sum)"""def func():    y = 20    exec(expr)    exec(expr, {'x': 1, 'y': 2})    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
func()603334
 
compile()
描述：compile() 將 source 編譯成代碼或 AST 對象，將字符串類型的代碼編碼, 代碼對象能夠通過exec語句來執行或者eval()進行求值
語法：compile(source, filename, mode[, flags[, dont_inherit]])
參數：
source -- 字符串或者AST（Abstract Syntax Trees）對象。。
filename -- 代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。
mode -- 指定編譯代碼的種類。可以指定為 exec, eval, single。
flags -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。。
flags和dont_inherit是用來控制編譯源碼時的標誌
將字符串編譯成python能識別或可以執行的代碼，也可以將文字讀成字符串再編譯。
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')   # 編譯為字節代碼對象 c<code object <module> at 0x000001EB82C91ED0, file "", line 1>
exec(c)0123

六、輸入輸出
print()
描述：print() 方法用於列印輸出，最常見的一個函數。在 Python3.3 版增加了 flush 關鍵字參數。print 在 Python3.x 是一個函數，但在 Python2.x 版本不是一個函數，只是一個關鍵字。
語法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
參數：
objects -- 複數，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。
sep -- 用來間隔多個對象，默認值是一個空格。
end -- 用來設定以什麼結尾。默認值是換行符 \n，我們可以換成其他字符串。
file -- 要寫入的文件對象。
flush -- 輸出是否被緩存通常決定於 file，但如果 flush 關鍵字參數為 True，流會被強制刷新。
print("Hello World")  Hello World#設置間隔符print("www","baidu","com",sep=".")www.baidu.com
 
input()
描述：Python3.x 中 input() 函數接受一個標準輸入數據，返回為 string 類型。獲取用戶輸入內容
語法：input([prompt])
參數：prompt:--提示信息
a = input("input:")input:1234print(a)123
 
七、內存相關
hash()
描述：返回該對象的哈希值（如果它有的話）。哈希值是整數。它們在字典查找元素時用來快速比較字典的鍵。相同大小的數字變量有相同的哈希值（即使它們類型不同，如 1 和 1.0），hash表.用空間換的時間 比較耗費內存，hash() 函數可以應用於數字、字符串和對象，不能直接應用於 list、set、dictionary。
語法：hash(object)
參數：object -- 對象
案例：
在hash()對對象使用時，所得的結果不僅和對象的內容有關，還和對象的id()，也就是內存地址有關。
class Test:    def __init__(self, i):        self.i = ifor 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() 函數的用途：hash() 函數的對象字符不管有多長，返回的hash值都是固定長度的，也用於校驗程序在傳輸過程中是否被第三方（木馬）修改，如果程序（字符）在傳輸過程中被修改hash值即發生變化，如果沒有被修改，則hash值和原始的hash值吻合，只要驗證hash值是否匹配即可驗證程序是否帶木馬（病毒）。
name1 = '正常程序代碼'name2 = '正常程序代碼帶病毒'print(hash(name1)) -3048480827538126659print(hash(name2)) -9065726187242961328
 
memoryview()
描述：memoryview() 函數返回給定參數的內存查看對象(Momory view)。返回由給定實參創建的「內存視圖」對象， Python 代碼訪問一個對象的內部數據，只要該對象支持緩衝區協議 而無需進行拷貝
語法：memoryview(obj)
參數：obj -- 對象
v = memoryview(bytearray("abcefg", 'utf-8'))v[1]98v[-1]98 v[1:4]<memory at 0x0000028B68E26AC8>v[1:4].tobytes()b'bce'
 
八、文件讀寫
open()
描述：open()函數用於打開一個文件，創建一個file對象，相關的方法才可以調用它進行讀寫。所以open()讀取文件分為兩步。
語法：open(name[, mode[, buffering]])
參數：
name : 一個包含了你要訪問的文件名稱的字符串值。
mode : mode決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數是非強制的，默認文件訪問模式為只讀(r)。
buffering : 如果 buffering 的值被設為 0，就不會有寄存。如果 buffering 的值取 1，訪問文件時會寄存行。如果將 buffering 的值設為大於1的整數，表明了這就是的寄存區的緩衝大小。如果取負值，寄存區的緩衝大小則為系統默認。
打開文件的模式：
r： 打開一個文件用於只讀，文件的指針將會放在文件的開頭，這是默認模式。
w：打開一個文件用於寫入，如果文件存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。
a：打開一個文件用於追加，如果文件已存在，文件指針將會放在文件的結尾，如果文件不存在，創建新文件進行寫入。
 
r+：打開一個文件用於讀寫，文件指針將會放在文件的開頭。
w+：打開一個文件用於讀寫。如果該文件已存在，刪除原有內容並從開頭開始編輯；如果該文件不存在，創建新文件。
a+：打開一個文件用於讀寫。如果該文件已存在，文件指針將會放在文件的結尾，如果該文件不存在，創建新文件用於讀寫。
 
rb：以二進位格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。
rb+：以二進位格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。
wb：以二進位格式打開一個文件只用於寫入。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。
wb+：以二進位格式打開一個文件用於讀寫。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。
ab：以二進位格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該文件不存在，創建新文件進行寫入。
ab+：以二進位格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。如果該文件不存在，創建新文件用於讀寫。
注意：當讀取音視頻、圖片等二進位文件時，需要採用二進位的讀取方法。
 
file對象方法
file.read([size])：size 未指定則返回整個文件，如果文件大小>2 倍內存則有問題，f.read()讀到文件尾時返回""(空字串)。
file.readline()：返回一行。
file.readlines([size]) ：返回包含size行的列表, size 未指定則返回全部行。
for line in file: print(line)：通過迭代器訪問。
file.write()：如果要寫入字符串以外的數據,先將他轉換為字符串。
file.tell()：返回一個整數,表示當前文件指針的位置(就是到文件頭的比特數)。
file.seek(偏移量,[起始位置])：用來移動文件指針。偏移量: 單位為比特，可正可負；起始位置: 0 - 文件頭, 默認值; 1 - 當前位置; 2 - 文件尾
file.close()：關閉文件
file = open('test.txt',encoding='utf-8')   #打開文件file.read()#直接顯示文件所有內容file.readline#顯示第一行file.close()  #關閉文件

test.txt存儲的的內容如下
 
read()方法
file = open('test.txt')file.read() 'hello\npython\ni\nlove you'
readline(）方法
file = open('test.txt')file.readline()'hello\n'
readlines()方法
file= open('test.txt')file.readlines()['python\n', 'i\n', 'love you']
逐行讀取
file = open('test.txt')for line in file:    print(line)hellopythonilove you
 
九、模塊相關
__ import__()
描述：該函數會導入 name 模塊，有可能使用給定的 globals 和 locals 來確定如何在包的上下文中解讀名稱。fromlist 給出了應該從由 name 指定的模塊導入對象或子模塊的名稱。標準實現完全不使用其 locals 參數，而僅使用 globals 參數來確定 import 語句的包上下文。level 指定是使用絕對還是相對導入。 0 (默認值) 意味著僅執行絕對導入。
語法：__import__(name, globals=None, locals=None, fromlist=(), level=0)
參數：object -- 對象
語句 import spam的結果將為與以下代碼作用相同的字節碼:
spam = __import__('spam.ham', globals(), locals(), [], 0)
 
十、獲取幫助
help()
描述：返回對象的幫助文檔
語法：help(object)
參數：object -- 對象
  
可以看到文檔的網址：https://docs.python.org/3.7/library/sys
查看str數據類型的幫助
可以看到，字符串相關的所有方法用法介紹       
a = [1,2,3]help(a) # 查看列表list幫助信息help(a.append)# 顯示list的append方法的幫助


十一、對象調用
callable()
描述：callable() 函數用於檢查一個對象是否是可調用的。如果返回 True，object 仍然可能調用失敗；但如果返回 False，調用對象object絕對不會成功。對於函數、方法、lambda 函式、 類以及實現了 __call__ 方法的類實例, 它都返回True。
這個函數一開始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。
語法：callable(object)
參數：object -- 對象
#檢查一個數字callable(0)False
#創建一個函數def add(x,y):    return x+y callable(add)True
#創建一個帶有__call__方法的類class Dogs:    def __call__(self):        return 0callable(Dogs)    True
 
十二、內置屬性
dir()
描述：dir() 查看對象的內置屬性, 訪問的是對象中的__dir__()方法，函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。如果參數包含方法__dir__()，該方法將被調用，如果參數不包含__dir__()，該方法將最大限度地收集參數信息。
語法：dir(object)
參數：object 對象、變量、類型。
#獲得當前模塊的屬性列表dir()['In','Out', 'exit', 'get_ipython', 'quit']

#查看列表的方法，使用dir([ ])或者dir(list())#查看列表的方法print(dir(list()))['__add__', ... 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'reverse', 'sort'，'remove']
dir()訪問的是對象中的__dir__()方法，因此下面的調用也能得到相同的結果：
list().__dir__()[__repr__',, ... 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'rever']
print(dir(str))、print(dir(list))、print(dir(dict))、分別獲取各個數據類型的方法，不帶參數時返回當前範圍內的變量，方法和定義的類型列表；帶參數時返回參數的屬性，方法列表。
 
hasattr()
描述：函數用於判斷對象是否包含對應的屬性。
語法：hasattr(object, name)
參數：
object -- 對象。
name -- 字符串，屬性名。
class Coordinate:    x = 10    y = -5    z = 0
point1 = Coordinate() print(hasattr(point1, 'x'))Trueprint(hasattr(point1, 'y'))Trueprint(hasattr(point1, 'z'))Trueprint(hasattr(point1, 'no'))  # 沒有該屬性False
長按加群，一起學習交流
↓掃描關注本號↓
推薦閱讀：
Python字典詳解-超級完整版
全面理解Python集合，17個方法全解，看完就夠了