Python基礎學習之内置函數
Python3.5版本中的68個内置函數，按順序逐個進行了自認為詳細的解析，現在是時候進行個總結了。為了友善記憶，将這些内置函數進行了如下分類：
1. 數學運算(7個)
1.1 abs()，求絕對值
求數值的絕對值
abs(-10) # 輸出：10
1.2 divmod()，求商和餘數
求兩個數值的商和餘數
# divmod
divmod(10 , 3) # 輸出：(3, 1)
divmod(10.1,3) # 輸出：(3.0, 1.0999999999999996)
divmod(-10,4) # 輸出：(-3, 2)
1.3 max()，求最大值
求最大值
max(1,2,3) # 傳入3個參數 取3個中較大者；輸出：3
max('1234') # 傳入1個可疊代對象，取其最大元素值；輸出：'4'
max(-1,0) # 數值預設去數值較大者；輸出：0
max(-1,0,key = abs) # 傳入了求絕對值函數，則參數都會進行求絕對值後再取較大者；輸出：-1
1.4 min()，求最小值
求最小值
min(1, 2, 3) # 傳入3個參數 取3個中較小的；輸出：1
min('1234') # 傳入1個可疊代對象，取其最小元素值；輸出：'1'
min(-1,-2) # 數值預設去數值較小者；輸出：-2
min(-1,-2,key = abs) # 傳入了求絕對值函數，則參數都會進行求絕對值後再取較小者；輸出：-1
1.5 pow()，求幂運算
求兩個數的幂運算
pow(2, 3) # 2^3 = 8
1.6 round()，四舍五入
對數值進行四舍五入
round(1.131415926,1) # 輸出：1.1
round(1.131415926,5) # 輸出：1.13142
1.7 sum()，求和
求數值的和
# 傳入可疊代對象
sum((1,2,3,4)) # 輸出：10
# 元素類型必須是數值型
sum((1.5,2.5,3.5,4.5)) # 輸出：12.0
sum((1,2,3,4),-10) # 輸出：0
2. 類型轉換(24個)
2.1 bool()，布爾轉換
根據傳入的參數的邏輯值建立一個新的布爾值
bool() # 未傳入參數；輸出：False
bool(0) # 數值0、空序列等值為False；輸出：False
bool(1) # 輸出：True
2.2 int()，整型轉換
根據傳入的參數建立一個新的整數
int() #不傳入參數時，得到結果0；輸出：0
int(3) # 輸出：3
int(3.6) # 輸出：3
2.3 float()，浮點型轉換
根據傳入的參數建立一個新的浮點數
float() # 不提供參數的時候，傳回:0.0
float(3) # 傳回:3.0
float('3') # 傳回:3.0
2.4 complex()，複數
根據傳入參數建立一個新的複數
complex() # 當兩個參數都不提供時，傳回複數 0j。
complex('1+2j') # 傳入字元串建立複數，輸出：(1+2j)
complex(1,2) # 傳入數值建立複數，輸出：(1+2j)
2.5 str()，字元串轉換
傳回一個對象的字元串表現形式(給使用者)
str() # 傳回：''
str(None) # 輸出：'None'
str('abc') # 輸出：'abc'
str(123) # 輸出：'123'
2.6 bytearray()，位元組數組
根據傳入的參數建立一個新的位元組數組，不怎麼用；
bytearray('中文','utf-8') # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
2.7 bytes()，不可變位元組數組
根據傳入的參數建立一個新的不可變位元組數組
bytes('中文','utf-8') # b'\xe4\xb8\xad\xe6\x96\x87'
2.8 memoryview()，記憶體檢視
根據傳入的參數建立一個新的記憶體檢視對象
v = memoryview(b'abcefg')
v[1] # 輸出：98
v[-1] # 輸出：103
2.9 ord()，字元 --> ASC
傳回Unicode字元對應的整數
ord('a') # 輸出：97
2.10 chr() ，ASC --> 字元
傳回整數所對應的Unicode字元
chr(97) # 輸出：'a'
2.11 bin()，轉換成二進制
将整數轉換成2進制字元串
bin(3) # 輸出：'0b11'
2.12 oct()，轉換成八進制
将整數轉化成8進制數字元串
oct(10) # 輸出：'0o12'
2.13 hex()，轉換成十六進制
将整數轉換成16進制字元串
hex(15) # 輸出：'0xf'
2.14 tuple()，建立元組
根據傳入的參數建立一個新的元組
tuple() # 不傳入參數，建立空元組; 輸出：()
tuple('121') # 傳入可疊代對象。使用其元素建立新的元組；輸出: ('1', '2', '1')
2.15 list()，建立清單
根據傳入的參數建立一個新的清單
list() # 不傳入參數，建立空清單；輸出：[]
list('abcd') # 傳入可疊代對象，使用其元素建立新的清單；輸出：['a', 'b', 'c', 'd']
2.16 dict()，建立字典
根據傳入的參數建立一個新的字典
dict() # 不傳入任何參數時，傳回空字典。傳回：{}
dict(a = 1,b = 2) # 可以傳入鍵值對建立字典。傳回：{'b': 2, 'a': 1}
dict(zip(['a','b'],[1,2])) # 可以傳入映射函數建立字典。傳回：{'b': 2, 'a': 1}
dict((('a',1),('b',2))) # 可以傳入可疊代對象建立字典。傳回：{'b': 2, 'a': 1}
2.17 set()，建立集合
根據傳入的參數建立一個新的集合
set() # 不傳入參數，建立空集合；輸出：set()
set(range(10)) # 傳入可疊代對象，建立集合；輸出：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
2.18 frozenset()，建立不可變集合
根據傳入的參數建立一個新的不可變集合
a = frozenset(range(10)) # 輸出：frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
2.19 enumerate()，建立枚舉對象
根據可疊代對象建立枚舉對象
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons)) # 輸出：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1)) # 指定起始值，輸出：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
2.20 range()，建立range對象
根據傳入的參數建立一個新的range對象
a = range(10)
b = range(1,10)
c = range(1,10,3)
a,b,c # 分别輸出a,b,c，輸出：(range(0, 10), range(1, 10), range(1, 10, 3))
list(a),list(b),list(c) # 分别輸出a,b,c的元素;輸出：([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])
2.21 iter()，建立可疊代對象
根據傳入的參數建立一個新的可疊代對象
a = iter('abcd') #字元串序列
print(a) # 輸出：<str_iterator object at 0x03FB4FB0>
next(a) # 輸出：'a'
next(a) # 輸出：'b'
next(a) # 輸出：'c'
next(a) # 輸出：'d'
next(a) # 由于後面沒有元素了，是以會報錯；報錯内容如下：
# Traceback (most recent call last):
# File "<pyshell#29>", line 1, in <module>
# next(a)
# StopIteration
2.22 slice()，建立切片對象
根據傳入的參數建立一個新的切片對象
slice(5) # 輸出：slice(None, 5, None)
slice(2,5) # 輸出：slice(2, 5, None)
slice(1,10,3) # 輸出：slice(1, 10, 3)
2.23 super()，繼承
根據傳入的參數建立一個新的子類和父類關系的代理對象
#定義父類A
class A(object):
def __init__(self):
print('A.__init__')
#定義子類B，繼承A
class B(A):
def __init__(self):
print('B.__init__')
super().__init__()
#super調用父類方法
b = B()
print(b) # 輸出：
# B.__init__
# A.__init__
# <__main__.B object at 0x0000025B3398C160>
2.24 object()，建立對象
建立一個新的object對象
a = object()
3. 序列操作(8個)
3.1 all()，all運算
判斷可疊代對象的每個元素是否都為True值
all([1,2]) # 清單中每個元素邏輯值均為True，傳回True; 輸出：True
all([0,1,2]) #清單中0的邏輯值為False，傳回False；
all(()) # 空元組，輸出：True
all({}) # 空字典，輸出：True
3.2 any()，any運算
判斷可疊代對象的元素是否有為True值的元素
any([0,1,2]) # 清單元素有一個為True，則傳回True
any([0,0]) # 清單元素全部為False，則傳回False
any([]) # 空清單,輸出: False
any({}) # 空字典,輸出: False
3.3 filter()，過濾可疊代對象
使用指定方法過濾可疊代對象的元素
a = list(range(1,10)) #定義序列, 輸出 a 為：[1, 2, 3, 4, 5, 6, 7, 8, 9]
def if_odd(x): # 定義奇數判斷函數
return x % 2 == 1
list(filter(if_odd , a)) # 篩選序列中的奇數，輸出：[1, 3, 5, 7, 9]
3.4 map()，對可疊代對象中每個元素運算
使用指定方法去作用傳入的每個可疊代對象的元素，生成新的可疊代對象
a = map(ord,'abcd') # 此時，a為：<map object at 0x03994E50>
list(a) # 對字元串'abcd' 分别計算ord(), 輸出為：[97, 98, 99, 100]
3.5 next()，疊代對象中的下一個
傳回可疊代對象中的下一個元素值
a = iter('abcd') #字元串序列
print(a) # 輸出：<str_iterator object at 0x03FB4FB0>
next(a) # 輸出：'a'
next(a) # 輸出：'b'
next(a) # 輸出：'c'
next(a) # 輸出：'d'
next(a) # 由于後面沒有元素了，是以會報錯；報錯内容如下：
# Traceback (most recent call last):
# File "<pyshell#29>", line 1, in <module>
# next(a)
# StopIteration
3.6 reversed()，返序
反轉序列生成新的可疊代對象
a = reversed(range(10)) # 傳入range對象
list(a) # 輸出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
3.7 sorted()，排列
對可疊代對象進行排序，傳回一個新的清單
a = ['a','b','d','c','B','A']
sorted(a) # 預設按字元ascii碼排序，輸出：['A', 'B', 'a', 'b', 'c', 'd']
sorted(a,key = str.lower) # 轉換成小寫後再排序，'a'和'A'值一樣，'b'和'B'值一樣；輸出：['a', 'A', 'b', 'B', 'c', 'd']
3.8 zip()，清單 --> 字典
聚合傳入的每個疊代器中相同位置的元素，傳回一個新的元組類型疊代器
x = [1,2,3] #長度3
y = [4,5,6,7,8] #長度5
list(zip(x,y)) # 取最小長度3，輸出： [(1, 4), (2, 5), (3, 6)]
4. 對象操作(9個)
4.1 help()，幫助檔案
傳回對象的幫助資訊
help(list)
Help on class list in module builtins:
class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable's items
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
4.2 dir()，屬性清單
傳回對象或者目前作用域内的屬性清單
dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
4.3 id()，唯一辨別符
傳回對象的唯一辨別符
a = 'kai'
id(a) # 輸出：2332201834456
4.4 hash()，哈希值
擷取對象的哈希值
hash('good good study') # 輸出：6003936519601954108
4.5 type()，對象類型
傳回對象的類型，或者根據傳入的參數建立一個新的類型
type(10) # 輸出：<class 'int'>
type('10') # 輸出：<class 'str'>
4.6 len()，對象長度
傳回對象的長度
len('abcd') # 字元串,傳回：4
len(bytes('abcd','utf-8')) # 位元組數組，傳回：4
len((1,2,3,4)) # 元組,傳回：4
len([1,2,3,4]) # 清單,傳回：4
len(range(1,5)) # range對象,傳回：4
len({'a':1,'b':2,'c':3,'d':4}) # 字典，,傳回：4
len({'a','b','c','d'}) # 集合，,傳回：4
len(frozenset('abcd')) #不可變集合，,傳回：4
4.7 ascii()，可列印字元串
傳回對象的可列印表字元串表現方式
ascii(1) # 輸出：'1'
ascii('&') # 輸出："'&'"
ascii(9000000) # 輸出：'9000000'
ascii('中文') #非ascii字元 # 輸出："'\\u4e2d\\u6587'"
4.8 format()，格式化顯示
格式化顯示值
# 整形數值可以提供的參數有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
format(3,'b') #轉換成二進制，輸出：'11'
format(97,'c') # 轉換unicode成字元，輸出：'a'
format(11,'d') # 轉換成10進制，輸出：'11'
format(11,'o') # 轉換成8進制，輸出：'13'
format(11,'x') # 轉換成16進制 小寫字母表示，輸出：'b'
format(11,'X') # 轉換成16進制 大寫字母表示，輸出：'B'
format(11,'n') # 和d一樣，輸出：'11'
format(11) # 預設和d一樣，輸出：'11'
# 浮點數可以提供的參數有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
format(314159267,'e') # 科學計數法，預設保留6位小數，輸出：'3.141593e+08'
format(314159267,'0.2e') # 科學計數法，指定保留2位小數，輸出：'3.14e+08'
format(314159267,'0.2E') # 科學計數法，指定保留2位小數，采用大寫E表示，輸出：'3.14E+08'
format(314159267,'f') # 小數點計數法，預設保留6位小數，輸出：'314159267.000000'
format(3.14159267000,'f') # 小數點計數法，預設保留6位小數，輸出：'3.141593'
format(3.14159267000,'0.8f') # 小數點計數法，指定保留8位小數，輸出：'3.14159267'
format(3.14159267000,'0.10f') # 小數點計數法，指定保留10位小數，輸出：'3.1415926700'
format(3.14e+1000000,'F') # 小數點計數法，無窮大轉換成大小字母，輸出：'INF'
# g的格式化比較特殊，假設p為格式中指定的保留小數位數，先嘗試采用科學計數法格式化，得到幂指數exp，如果-4<=exp<p，則采用小數計數法，并保留p-1-exp位小數，否則按小數計數法計數，并按p-1保留小數位數
format(0.00003141566,'.1g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，輸出：'3e-05'
format(0.00003141566,'.2g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留1位小數點，輸出：'3.1e-05'
format(0.00003141566,'.3g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留2位小數點，輸出：'3.14e-05'
format(0.00003141566,'.3G') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，E使用大寫，輸出：'3.14E-05'
format(3.1415926777,'.1g') # p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留0位小數點，輸出：'3'
format(3.1415926777,'.2g') # p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留1位小數點，輸出：'3.1'
format(3.1415926777,'.3g') # p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留2位小數點，輸出：'3.14'
format(0.00003141566,'.1n') # 和g相同，輸出：'3e-05'
format(0.00003141566,'.3n') # 和g相同，輸出：'3.14e-05'
format(0.00003141566) # 和g相同，輸出：'3.141566e-05'
4.9 vars()，局部變量和值
傳回目前作用域内的局部變量和其值組成的字典，或者傳回對象的屬性清單
class A(object):
pass
a = A()
print(a.__dict__) # 輸出：{}
print(vars(a)) # 輸出：{}
a.name = 'Kim'
print(a.__dict__) # 輸出：{'name': 'Kim'}
print(vars(a)) # 輸出：{'name': 'Kim'}
5. 反射操作(8個)
5.1 import()，動态導入子產品
動态導入子產品
index = __import__('index')
index.sayHello()
5.2 isinstance()，判斷執行個體
判斷對象是否是類或者類型元組中任意類元素的執行個體
isinstance(1,int) # 輸出：True
isinstance(1,str) # 輸出：False
isinstance(1,(int,str)) # 輸出：True
5.3 issubclass()，判斷子類
判斷類是否是另外一個類或者類型元組中任意類元素的子類
issubclass(bool,int) # 輸出：True
issubclass(bool,str) # 輸出：False
issubclass(bool,(str,int)) # 輸出：True
5.4 hasattr()，判斷屬性
檢查對象是否含有屬性
class Student:
def __init__(self, name):
self.name = name
s = Student('Aim')
hasattr(s, 'name') # a含有name屬性,True
hasattr(s, 'age') # a不含有age屬性,False
5.5 getattr()，擷取屬性
擷取對象的屬性值
class Student:
def __init__(self, name):
self.name = name
s = Student('Aim')
hasattr(s, 'name') # a含有name屬性,True
hasattr(s, 'age') # a不含有age屬性,False
getattr(s, 'name') # 存在屬性name，傳回: Aim
getattr(s,'age',0) # 不存在屬性age，但提供了預設值，傳回預設值0;
getattr(s,'age') # 不存在屬性age，沒有預設值，則會報錯；AttributeError: 'Stduent' object has no attribute 'age'
5.6 setattr() ，設定屬性
設定對象的屬性值
class Student:
def __init__(self,name):
self.name = name
a = Student('Kim')
a.name # 輸出：'Kim'
setattr(a,'name','Bob') # 修改name
a.name # 輸出：'Bob'
5.7 delattr()，删除屬性
删除對象的屬性
#定義類A
class A:
def __init__(self,name):
self.name = name
def sayHello(self):
print('hello',self.name)
#測試屬性和方法
a.name # 輸出：'小麥'
a.sayHello() # 輸出： hello 小麥
#删除屬性
delattr(a,'name')
a.name # 報錯：'A' object has no attribute 'name'
5.8 callable()，對象是否可調用
檢測對象是否可被調用
class B: # 定義類B
def __call__(self):
print('instances are callable now.')
callable(B) # 類B是可調用對象，輸出：True
b = B() # 調用類B
callable(b) # 執行個體b是可調用對象，輸出：True
b() # 調用執行個體b成功，輸出：instances are callable now.
6. 作用域變量操作(2個)
6.1 globals()，全局變量 & 值
傳回目前作用域内的全局變量和其值組成的字典
globals() # 直接可以調用，檢視目前的全局變量和其值組成的字典；
6.2 locals()，局部變量 & 值
傳回目前作用域内的局部變量和其值組成的字典
locals() # 直接可以調用，檢視目前的局部變量和其值組成的字典；
7. 互動操作(2個)
7.1 print()，列印輸出
向标準輸出對象列印輸出
print(1,2,3) # 輸出：1 2 3
print(1,2,3,sep = '+') # 輸出：1+2+3
print(1,2,3,sep = '+',end = '=?') # 輸出：1+2+3=?
7.2 input()，使用者輸入
讀取使用者輸入值
s = input('please input your name:') # 代碼運作到此，就需要使用者進行輸入；
8. 檔案操作(1個)
8.1 open()，打開檔案
使用指定的模式和編碼打開檔案，傳回檔案讀寫對象
# t為文本讀寫，b為二進制讀寫
a = open('test.txt','rt')
a.read() # 輸出：'some text'
a.close()
9. 編譯執行(4個)
9.1 compile()，編譯代碼
将字元串編譯為代碼或者AST對象，使之能夠通過exec語句來執行或者eval進行求值
#流程語句使用exec
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)
9.2 eval（)，執行動态表達式
執行動态表達式求值
eval（'1+2+3+4') # 輸出：10
9.3 exec()，執行動态語句
執行動态語句塊
exec('a=1+2') # 執行語句，
9.4 repr()，字元串表現形式
傳回一個對象的字元串表現形式(給解釋器)
a = 'some text'
str(a) # 輸出：'some text'
repr(a) # 輸出："'some text'"
10. 裝飾器(3個)
10.1 property()，屬性裝飾器
标示屬性的裝飾器
class C:
def __init__(self):
self._name = ''
@property
def name(self):
"""i'm the 'name' property."""
return self._name
@name.setter
def name(self, value):
if value is None:
raise RuntimeError('name can not be None')
else:
self._name = value
c = C()
print(c.name) # 通路屬性,輸出為''
c.name = 'Kim' # 設定屬性
print(c.name) # 通路屬性，輸出為：Kim
c.name = None # 設定屬性時進行驗證
# 彈出錯誤： RuntimeError: name can not be None
del c.name # 删除屬性，不提供deleter則不能删除
10.2 classmethod()，類裝飾器
class C:
@classmethod
def f(cls, arg1):
print(cls)
print(arg1)
C.f('類對象調用類方法')
# 輸出如下：
# <class '__main__.C'>
# 類對象調用類方法
c = C()
c.f('類執行個體對象調用類方法')
# 輸出如下：
# <class '__main__.C'>
# 類執行個體對象調用類方法
10.3 staticmethod()，靜态方法裝飾器
# 使用裝飾器定義靜态方法
class Student(object):
def __init__(self, name):
self.name = name
@staticmethod
def sayHello(lang):
print(lang)
if lang == 'en':
print('Welcome!')
else:
print('你好！')
Student.sayHello('en') # 類調用,'en'傳給了lang參數
# 輸出如下：
# en
# Welcome!
b = Student('Kim')
b.sayHello('zh') # 類執行個體對象調用,'zh'傳給了lang參數
# 輸出如下：
# zh
# 你好
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)