Python3中的68個內建函式總結
一、內建函式
10大類
- 數學運算(7個)
- 型別轉換(24個)
- 序列操作(8個)
- 物件操作(9個)
- 反射操作(8個)
- 變數操作(2個)
- 互動操作(2個)
- 檔案操作(1個)
- 編譯執行(4個)
- 裝飾器(3個
1、數學運算(7個)
(1)abs()
- 返回數字的絕對值
(2)divmod()
- 返回兩個數值的商和餘數,是一個元組
(a//b, a%b)
>>>divmod(7, 2)
(3, 1)
(3)max()
- 返回可迭代物件中的元素中的最大值或者所有引數的最大值
(4)min()
- 返回可迭代物件中的元素中的最小值或者所有引數的最小值
>>> min(-1,-2,key = abs) # 傳入了求絕對值函式,則引數都會進行求絕對值後再取較小者
-1
(5)pow()
- 返回兩個數值的冪運算值或其與指定整數的模值,語法:
pow(x,y[,z])
,如果z存在,則再對結果進行取模,其結果等效於pow(x,y) %z - 注意:pow() 通過內建的方法直接呼叫,內建方法會把引數作為整型,而math模組則會把引數轉換為float
(6)round()
- 返回浮點數x的四捨五入值,語法:
round(x[,n])
- 除非對精確度沒什麼要求,否則儘量避開用round()函式,近似計算我們還有其他的選擇:
①使用math模組中的一些函式,比如math.ceiling(天花板除法)。
②python自帶整除,//和div函式。
③字串格式化可以做截斷使用,例如"%.2f"% value(保留兩位小數並變成字串……如果還想用浮點數請披上float()的外衣)。
④當然,對浮點數精度要求如果很高的話,請用decimal模組。
(7)sum()
- 對元素型別是數值的可迭代物件中的每個元素求和,語法:
sum(iterable[, start])
>>>sum([0,1,2]) 3 >>> sum((2, 3, 4), 1) # 元組計算總和後再加 1 10 >>> sum([0,1,2,3,4], 2) # 列表計算總和後再加 2 12
2、型別轉換(24個)
(1)bool()
- 將給定引數轉換為布林型別,如果沒有引數,返回False,bool 是int的子類。
>>>bool()
False
>>> bool(0)
False
>>> issubclass(bool, int) # bool 是 int 子類
True
(2)int()
- 將一個字串或數字轉換為整型。語法:class int(x,base=10),x是字串或數字,base為進位制數,預設十進位制。
(3)float()
- 根據傳入的引數建立一個新的浮點數
>>> float() #不提供引數的時候,返回0.0
0.0
>>> float(3)
3.0
>>> float('3')
3.0
(4)complex()
- 建立一個值為
real + imag*j
的複數或者轉化一個字串或數為複數。如果第一個引數為字串,則不需要指定第二個引數。
語法:class complex([real[, imag]])
引數:
real -- int, long, float或字串
imag -- int, long, float
>>>complex(1, 2)
(1 + 2j)
>>> complex(1) # 數字
(1 + 0j)
>>> complex("1") # 當做字串處理
(1 + 0j)
# 注意:這個地方在"+"號兩邊不能有空格,也就是不能寫成"1 + 2j",應該是"1+2j",否則會報錯
>>> complex("1+2j")
(1 + 2j)
(5)str()
- 返回一個物件的字串表現形式(給使用者)
(6)bytearry()
- 根據傳入的引數建立一個新的可變位元組陣列,並且每個元素的值範圍:
0<=x<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('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
(7)bytes()
- 返回一個新的bytes物件,該物件是一個0<=x<256區間內的整數不可變序列,它是bytearray的不可變版本。語法:
class bytes([source[,encoding[,errors]]])
>>> bytes('中文','utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
(8)memoryview()
- 返回給定引數的記憶體檢視物件(Momory view)。所謂記憶體檢視物件,是指對支援緩衝區協議的資料進行包裝,在不需要複製物件基礎上允許Python程式碼訪問,語法:memoryview(obj),返回元組列表。
>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
(9)ord()
- 是
chr()
函式(對於8位的ASCII字串)的配對函式,它以一個字串(Unicode字元)作為引數,返回對應的ASCII數值,或者Unicode數值。
>>>ord('a')
97
>>> ord('€')
8364
(10)chr()
- 返回整數所對應的Unicode字元。語法:
chr(i)
,可以是10進位制也可以是16進位制形式的數字,數字範圍為0到1,114,111(16進製為0x10FFFF)。
(11)bin()
- 返回一個整數的2進位制字串表示。
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
(12)oct()
- 將一個整數轉換成8進位制字串。
(13)hex()
- 將一個指定數字轉換為16進位制數字符串,以
0x
開頭。
(14)tuple()
- 根據傳入的引數建立一個新的元組
>>> tuple() #不傳入引數,建立空元組
()
>>> tuple('121') #傳入可迭代物件,使用其元素建立新的元組
('1', '2', '1')
(15)list()
- 根據傳入的引數建立一個新的列表
>>>list() # 不傳入引數,建立空列表
[]
>>> list('abcd') # 傳入可迭代物件,使用其元素建立新的列表
['a', 'b', 'c', 'd']
(16)dict()
- 根據傳入的引數建立一個新的字典
# 建立空字典
>>>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)])
{'three': 3, 'two': 2, 'one': 1}
(17)set()
- 建立一個無序不重複元素集,可進行關係測試,刪除重複資料,還可以計算交集、差集、並集等。語法:
class set([iterable])
,返回新的集合物件。
>>> a = set(range(10)) # 傳入可迭代物件,建立集合
>>> a
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重複的被刪除
>>> x & y # 交集
set(['o'])
>>> x | y # 並集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y # 差集
set(['r', 'b', 'u', 'n'])
(18)frozenset()
- 返回一個凍結的不可變集合,凍結後集合不能再新增或刪除任何元素,語法:
class frozenset([iterable])
>>>a = frozenset(range(10)) # 生成一個新的不可變集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n']) # 建立不可變集合
(19)enumerate()
- 根據可迭代物件建立列舉物件,將一個可遍歷的資料物件(如列表、元組或字串)組合為一個索引序列,同時列出資料和資料下標,一般用在for迴圈當中,返回enumerate(列舉)物件。語法:
enumerate(sequence, [start=0])
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>>list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
# 指定起始值,小標從1開始
>>>list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
普通for迴圈:
>>>i = 0
>>>seq = ['one', 'two', 'three']
>>>for element in seq:
... print(i, seq[i])
... i += 1
for迴圈使用enumerate
>>>seq = ['one', 'two', 'three']
>>>for i, element in enumerate(seq):
... print(i, seq[i])
同樣輸出:
0 one
1 two
2 three
(20)range()
- 根據傳入的引數建立一個新的range物件,注意差一行為
(21)iter()
- 用來生成迭代器,語法:iter(object[,sentinel]),sentinel--如果傳遞了第二個引數,則引數object必須是一個可呼叫的物件(如,函式),此時,iter建立了一個迭代器物件,每次呼叫這個迭代器物件的__next__()方法時,都會呼叫object。
>>> a = iter('abcd') #字串序列
>>> 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
(22)slice()
- 根據傳入的引數建立一個新的切片物件
語法:
class slice(stop)
class slice(start, stop[, step])
# 設定擷取5個元素的切片
>>>myslice = slice(5)
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 擷取 5 個元素
>>> arr[myslice]
[0, 1, 2, 3, 4]
(23)super()
- 根據傳入的引數建立一個新的子類和父類關係的代理物件。用於呼叫父類(超類)的一個方法,可以解決多重繼承問題,因為在使用多繼承時,會涉及到查詢順序(MRO)、重複呼叫(鑽石繼承)等問題,無法像單繼承那樣直接用類名呼叫父類方法。
語法:super(type[, object-or-type])
# type -- 類。
# object-or-type -- 類,一般是 self
class A:
pass
class B(A):
def add(self, x):
super().add(x)
(24)object()
- 建立一個新的object物件
3、序列操作(8個)
(1)all()
- 判斷可迭代物件中的每個元素是否都為True值,如果是返回True,否則返回False,元素除了是0、空、False外都算True。注意:空元組、空列表返回值為True
>>> all(['a', 'b', '', 'd']) # 列表list,存在一個為空的元素
False
>>> all([0, 1,2, 3]) # 列表list,存在一個為0的元素
False
>>> all([]) # 空列表
True
>>> all(()) # 空元組
True
(2)any()
- 判斷給定的可迭代物件的每個元素是否都為False值,則返回False,如果有一個為True,則返回True,元素除了是0、空、False外都算True。注意:空元組、空列表返回值為False
(3)filter()
- 使用指定方法過濾可迭代物件的元素,返回一個迭代器物件。該接收兩個引數,第一個為函式,第二個為序列,序列的每個元素作為引數傳遞給函式進行判斷,然後返回True或False,最後將返回True的元素放到新列表中。
語法:filter(function, iterable)
(4)map()
- 使用指定方法去作用傳入的每個可迭代物件的元素,返回包含每次function函式返回值的新列表。
>>>def square(x) : # 計算平方數
... return x ** 2
>>> map(square, [1,2,3,4,5]) # 計算列表各個元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函式
[1, 4, 9, 16, 25]
# 提供了兩個列表,對相同位置的列表資料進行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
- 如果函式有多個引數, 但每個引數的序列元素數量不一樣, 會根據最少元素的序列進行。
(5)next()
- 返回迭代器物件中的下一個元素值。語法
next(iterator[,default])
。函式必須接收一個可迭代物件引數,每次呼叫的時候,返回可迭代物件的下一個元素。如果所有元素均已經返回過,則丟擲StopIteration異常;函式可以接收一個可選的default引數,傳入default引數後,如果可迭代物件還有元素沒有返回,則依次返回其元素值,如果所有元素已經返回,則返回default指定的預設值而不丟擲StopIteration異常。
>>> a = iter('abcd')
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)
Traceback (most recent call last):
File "<pyshell#18>", line 1, in <module>
next(a)
StopIteration
>>> next(a,'e')
'e'
>>> next(a,'e')
'e'
(6)reversed()`` + 反轉序列生成新的可迭代物件,語法:
reversed(seq)`
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
輸出:
[5, 3, 4, 2, 1]
(7)sorted()
- 對可迭代物件進行排序,返回一個新的列表。sort是應用在list上的方法,sorted可以對所有可迭代的物件進行排序操作。list的sort方法會對原始列表進行操作並返回,而內建函式sorted方法返回的是一個新list,而不是在原來的基礎上進行的操作。
語法:sorted(iterable, key=None, reverse=False)
# key主要是用來進行比較的元素,只有一個引數,具體的函式的引數就是取自於可迭代物件中,指定可迭代物件中的一個元素來進行排序,reverse=True降序,reverse=False升序(預設)。
>>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
# 利用key進行倒序排序
>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]
(8)zip()
- 聚合傳入的每個迭代器中相同位置的元素,返回一個新的元組型別迭代器,這樣做的好處是節約了不少的記憶體。如果各個迭代器的元素個數不一致,則返回列表長度與最短的物件相同,利用*號操作符,可以將元組解壓為列表。
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一個物件
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped) # list() 轉換為列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) # 元素個數與最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b)) # 與 zip 相反,zip(*) 可理解為解壓,返回二維矩陣式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
4、物件操作(9個)
(1)help()
- 返回物件的幫助資訊
(2)dir()
- 返回物件或者當前作用域內的屬性列表,語法
dir([object])
>>> import math
>>> math
<module 'math' (built-in)>
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
(3)id()
- 用於獲取物件的記憶體地址,返回物件的唯一識別符號,語法:
id([object])
(4)hash()
- 獲取物件(字串或者數值等)的雜湊值,語法:
hash(object)
。
>>>hash('test') # 字串
2314058222102390712
>>> hash(1) # 數字
1
>>> hash(str([1,2,3])) # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
(5)type()
- 返回物件的型別,或者根據傳入的引數建立一個新的型別。
- 注意和
isinstance()
的區別:在於是否考慮繼承關係;語法:(1)type(object);(2)type(name,bases,dict)
,有第一個引數則返回物件的型別,三個引數時返回新的型別物件。
引數:
name -- 類的名稱。
bases -- 基類的元組。
dict -- 字典,類內定義的名稱空間變數。
# 使用type函式建立型別D,含有屬性InfoD
>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))
>>> d = D()
>>> d.InfoD
'some thing defined in D'
(6)len()
- 返回物件的長度
(7)ascii()
- 類似repr()函式,返回一個表示物件的字串,但是對於字串中的非ASCII字元則返回通過repr()函式使用 \x, \u 或 \U 編碼的字元。語法:
ascii(object)
>>>a = ascii('paul你好')
>>>print(a)
'paul\u4f60\u597d'
(8)format()
- 格式化字串的函式
str.format()
。
>>>"{} {}".format("hello", "world") # 不設定指定位置,按預設順序
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 設定指定位置
'world hello world'
print("網站名:{name}, 地址 {url}".format(name="菜鳥教程", url="www.runoob.com"))
# 通過字典設定引數
site = {"name": "菜鳥教程", "url": "www.runoob.com"}
print("網站名:{name}, 地址 {url}".format(**site))
# 通過列表索引設定引數
my_list = ['菜鳥教程', 'www.runoob.com']
print("網站名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是**必須**的
輸出:
網站名:菜鳥教程, 地址 www.runoob.com
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 為: {0.value}'.format(my_value)) # "0" 是**可選**的
(9)vars()
- 返回當前作用域內的區域性變數和其值組成的字典,或者返回物件的屬性列表。語法:
vars([object])
,如果沒有引數,就列印當前呼叫位置的屬性和屬性值類似locals()。
>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
... a = 1
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}
5、反射操作(8個)
(1)import()
- 動態匯入模組
(2)isinstance()
- 判斷物件是否是類或者型別元組中任意類元素的例項。語法:
isinstance(object,classinfo)
,如果物件的型別與引數二的型別(classinfo)相同則返回True,否則返回False。 - isinstance() 與type()區別:
type() 不會認為子類是一種父類型別,==不考慮繼承關係==
isinstance() 會認為子類是一種父類型別,==考慮繼承關係==
==如果要判斷兩個型別是否相同推薦使用isinstance()==
>>> isinstance (a,(str,int,list)) # 是元組中的一個返回 True
True
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
(3)issubclass()
- 判斷類是否是另外一個類或者型別元組中任意類元素的子類,語法:
issubclass(class,classinfo)
,如果class是classinfo的子類返回True,否則返回False。
>>> issubclass(bool,int)
True
>>> issubclass(bool,str)
False
>>> issubclass(bool,(str,int))
True
(4)hasattr()
- 判斷物件是否包含對應的屬性,語法:
hasattr(object,name)
,如果物件有該屬性返回True,否則返回False。
>>> 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)getattr()
- 獲取物件的屬性值。語法:
getattr(object, name[, default])
>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 獲取屬性 bar 值
1
>>> getattr(a, 'bar2') # 屬性bar2不存在,觸發異常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3) # 屬性bar2不存在,但設定了預設值
3
(6)setattr()
- 設定物件的屬性值,前提是該屬性必須存在。
語法:setattr(object, name, value) #(物件,字串/物件屬性,屬性值)
>>>class A(object):
... bar = 1
...
>>> a = A()
# 獲取屬性 bar 值
>>> getattr(a, 'bar')
1
# 設定屬性 bar 值
>>> setattr(a, 'bar', 5)
>>> a.bar
5
(7)delattr()
- 刪除物件的屬性
delattr(x,'foobar')
相等於del x.foobar
,語法:delattr(object,name)
(8)callable()
- 檢查物件是否可被呼叫。如果返回True,object仍然可能呼叫失敗;但如果返回False,呼叫物件ojbect絕對不會成功。對於函式、方法、lambda函式、類以及實現了
__call__
方法的類例項, 它都返回True。語法:callable(object)
>>> class B: #定義類B
def __call__(self):
print('instances are callable now.')
>>> callable(B) #類B是可呼叫物件
True
>>> b = B() #呼叫類B
>>> callable(b) #例項b是可呼叫物件
True
>>> b() #呼叫例項b成功
6、變數操作(2個)
(1)globals()
- 返回當前作用域內的全域性變數和其值組成的字典
>>>a='runoob'
>>>print(globals())
# globals 函式返回一個全域性變數的字典,包括所有匯入的變數。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
(2)locals()
- 返回當前作用域內的區域性變數和其值組成的字典
>>>def runoob(arg): # 兩個區域性變數:arg、z
... z = 1
... print (locals())
...
>>> runoob(4)
{'z': 1, 'arg': 4} # 返回一個名字/值對的字典
7、互動操作(2個)
(1)print()
- 向標準輸出物件列印輸出
(2)input()
- 讀取使用者輸入值
8、檔案操作(1個)
(1)open()
- 使用指定的模式和編碼開啟檔案,返回檔案讀寫物件。在對檔案進行處理過程都需要使用到這個函式,如果該檔案無法被開啟,會丟擲OSError。使用open()方法一定要保證關閉檔案物件,即呼叫close()方法,open()函式常用形式是接收兩個引數:檔名(file)和模式(mode)。
- 完整的語法格式:
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
- 引數說明:
file: 必需,檔案路徑(相對或者絕對路徑)
mode: 可選,檔案開啟模式
buffering: 設定緩衝
encoding: 一般使用utf8
errors: 報錯級別
newline: 區分換行符
closefd: 傳入的file引數型別
opener:
- mode引數
模式 | 描述 |
---|---|
t | 文字模式 (預設)。 |
x | 寫模式,新建一個檔案,如果該檔案已存在則會報錯。 |
b | 二進位制模式。 |
+ | 開啟一個檔案進行更新(可讀可寫)。 |
U | 通用換行模式(不推薦)。 |
r | 以只讀方式開啟檔案。檔案的指標將會放在檔案的開頭。這是預設模式。 |
rb | 以二進位制格式開啟一個檔案用於只讀。檔案指標將會放在檔案的開頭。這是預設模式。一般用於非文字檔案如圖片等。 |
r+ | 開啟一個檔案用於讀寫。檔案指標將會放在檔案的開頭。 |
rb+ | 以二進位制格式開啟一個檔案用於讀寫。檔案指標將會放在檔案的開頭。一般用於非文字檔案如圖片等。 |
w | 開啟一個檔案只用於寫入。如果該檔案已存在則開啟檔案,並從開頭開始編輯,即原有內容會被刪除。如果該檔案不存在,建立新檔案。 |
wb | 以二進位制格式開啟一個檔案只用於寫入。如果該檔案已存在則開啟檔案,並從開頭開始編輯,即原有內容會被刪除。如果該檔案不存在,建立新檔案。一般用於非文字檔案如圖片等。 |
w+ | 開啟一個檔案用於讀寫。如果該檔案已存在則開啟檔案,並從開頭開始編輯,即原有內容會被刪除。如果該檔案不存在,建立新檔案。 |
wb+ | 以二進位制格式開啟一個檔案用於讀寫。如果該檔案已存在則開啟檔案,並從開頭開始編輯,即原有內容會被刪除。如果該檔案不存在,建立新檔案。一般用於非文字檔案如圖片等。 |
a | 開啟一個檔案用於追加。如果該檔案已存在,檔案指標將會放在檔案的結尾。也就是說,新的內容將會被寫入到已有內容之後。如果該檔案不存在,建立新檔案進行寫入。 |
ab | 以二進位制格式開啟一個檔案用於追加。如果該檔案已存在,檔案指標將會放在檔案的結尾。也就是說,新的內容將會被寫入到已有內容之後。如果該檔案不存在,建立新檔案進行寫入。 |
a+ | 開啟一個檔案用於讀寫。如果該檔案已存在,檔案指標將會放在檔案的結尾。檔案開啟時會是追加模式。如果該檔案不存在,建立新檔案用於讀寫。 |
ab+ | 以二進位制格式開啟一個檔案用於追加。如果該檔案已存在,檔案指標將會放在檔案的結尾。如果該檔案不存在,建立新檔案用於讀寫。 |
9、編譯執行(4個)
(1)compile()
- 將字串編譯為程式碼或者AST物件,使之能夠通過exec語句來執行或者eval進行求值
語法:compile(source, filename, mode[, flags[, dont_inherit]])
引數:
source -- 字串或者AST(Abstract Syntax Trees)物件。。
filename -- 程式碼檔名稱,如果不是從檔案讀取程式碼則傳遞一些可辨認的值。
mode -- 指定編譯程式碼的種類。可以指定為 exec, eval, single。
flags -- 變數作用域,區域性名稱空間,如果被提供,可以是任何對映物件。
flags和dont_inherit是用來控制編譯原始碼時的標誌
>>>str = "for i in range(0,3): print(i)"
>>> c = compile(str,'','exec') # 編譯為位元組程式碼物件
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
(2)eval()
- 執行動態表示式求值(只能執行計算數學表示式的結果的功能)。語法:
eval(expression[,globals[,locals]])
globals變數作用域,全域性名稱空間,如果被提供,則必須是一個字典物件;locals變數作用域,區域性名稱空間,如果被提供,可以是任何對映物件。
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
(3)exec()
- 執行動態語句塊,語法:
exec(object[,globals[,locals]])
,返回值永遠為None。(object:必選引數,表示需要被指定的Python程式碼。它必須是字串或code物件。如果object是一個字串,該字串會先被解析為一組Python語句,然後在執行(除非發生語法錯誤)。如果object是一個code物件,那麼它只是被簡單的執行)
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20 # 區域性變數y
exec(expr)
exec(expr, {'x': 1, 'y': 2})
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
# 在expr語句中,有三個變數x,y,z,其中z值已給定,我們可以在exec()函式外指定x,y的值,也可以在exec()函式中以字典的形式指定x,y的值。在最後的語句中,我們給出了x,y,z的值,並且y值重複,exec()函式接收後面一個y值,且z值傳遞不起作用,因此輸出結果為34
func()
輸出:
60
33
34
eval()函式和exec()函式的區別:
eval()函式只能計算單個表示式的值,而exec()函式可以動態執行程式碼段。
eval()函式可以有返回值,而exec()函式返回值永遠為None。
(4)repr()
- 返回一個物件的字串表現形式(給直譯器),語法:
repr(object)
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
10、裝飾器(3個)
(1)property
- 標示屬性的裝飾器,語法:
class property([fget[, fset[, fdel[, doc]]]])
引數:
fget -- 獲取屬性值的函式
fset -- 設定屬性值的函式
fdel -- 刪除屬性值函式
doc -- 屬性描述資訊
# 將 property 函式用作裝飾器可以很方便的建立只讀屬性
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
# 上面的程式碼將 voltage() 方法轉化成同名只讀屬性的getter方法。property的getter,setter 和deleter方法同樣可以用作裝飾器:
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
>>> 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()
>>> c.name # 訪問屬性
''
>>> c.name = None # 設定屬性時進行驗證
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
c.name = None
File "<pyshell#81>", line 11, in name
raise RuntimeError('name can not be None')
RuntimeError: name can not be None
>>> c.name = 'Kim' # 設定屬性
>>> c.name # 訪問屬性
'Kim'
>>> del c.name # 刪除屬性,不提供deleter則不能刪除
Traceback (most recent call last):
File "<pyshell#87>", line 1, in <module>
del c.name
AttributeError: can't delete attribute
>>> c.name
'Kim'
(2)classmethod
- 標示方法為類方法的裝飾器,classmethod修飾符對應的函式不需要例項化,不需要self引數,但第一個引數需要是表示自身類的cls引數,可以來呼叫類的屬性,類的方法,例項化物件等。返回函式的類方法。
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 呼叫 foo 方法
A.func2() # 不需要例項化
(3)staticmethod
- 標示方法為靜態方法的裝飾器,該方法不強制要求傳遞引數,如宣告一個靜態方法。
class C(object):
@staticmethod
def f(arg1, arg2, ...):
pass
# 以上例項聲明瞭靜態方法f,類可以不用例項化就可以呼叫該方法C.f(),當然也可以例項化後呼叫C().f()。
class C(object):
@staticmethod
def f():
print('runoob');
C.f() # 靜態方法無需例項化
cobj = C()
cobj.f() # 也可以例項化後呼叫
# 使用裝飾器定義靜態方法
>>> 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
你好
參考:
1、RUNOOB.COM-Python3 內建函式
2、部落格園-十月狐狸-Python內建函式詳解——總結篇 ==(強烈推薦)==