一、內置函數

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參數

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內置函數詳解——總結篇 ==(強烈推薦)==

Python3中的68個內置函數總結