abs()
abs() 函數返回數字的絕對值。
abs( x )
x -- 數值表達式，可以是整數，浮點數，復數。
函數返回 x（數字）的絕對值，如果參數是一個復數，則返回它的大小。
all()
all() 函數用於判斷給定的可迭代參數 iterable 中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。
all(iterable)
iterable -- 元組或列表。
如果iterable的所有元素不為0、''、False或者iterable為空，all(iterable)返回True，否則返回False；
注意：空元組、空列表返回值為True，這里要特別注意。
any()
any() 函數用於判斷給定的可迭代參數 iterable 是否全部為 False，則返回 False，如果有一個為 True，則返回 True。
any(iterable)
iterable -- 元組或列表。
如果都為空、0、false，則返回false，如果不都為空、0、false，則返回true。
ascii() 函數類似 repr() 函數, 返回一個表示對象的字符串, 但是對於字符串中的非 ASCII 字符則返回通過 repr() 函數使用 \x, \u 或 \U 編碼的字符。 生成字符串類似 Python2 版本中 repr() 函數的返回值。
ascii(object)
object -- 對象。
返回字符串。
>>> ascii('runoob') "'runoob'"
bin()
bin() 返回一個整數 int 或者長整數 long int 的二進制表示。
bin(x)
x -- int 或者 long int 數字
字符串。
>>>bin(10) '0b1010' >>> bin(20) '0b10100'
bool()
bool() 函數用於將給定參數轉換為布爾類型，如果沒有參數，返回 False。
bool 是 int 的子類。
class bool([x])
x -- 要進行轉換的參數。
返回 Ture 或 False。
bytearray()
bytearray() 方法返回一個新字節數組。這個數組里的元素是可變的，並且每個元素的值范圍: 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('runoob', 'utf-8') bytearray(b'runoob')
bytes()
bytes 函數返回一個新的 bytes 對象，該對象是一個 0 <= x < 256 區間內的整數不可變序列。它是 bytearray 的不可變版本。
class bytes([source[, encoding[, errors]]])
如果 source 為整數，則返回一個長度為 source 的初始化數組；
如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節序列；
如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數；
如果 source 為與 buffer 接口一致的對象，則此對象也可以被用於初始化 bytearray。
如果沒有輸入任何參數，默認就是初始化數組為0個元素。
返回一個新的 bytes 對象。
>>>a = bytes([1,2,3,4]) >>> a b'\x01\x02\x03\x04' >>> a = bytes('hello','ascii') >>> a b'hello'
$callable()
callable() 函數用於檢查一個對象是否是可調用的。如果返回 True，object 仍然可能調用失敗；但如果返回 False，調用對象 object 絕對不會成功。
對於函數、方法、lambda 函式、 類以及實現了 call 方法的類實例, 它都返回 True。
callable(object)
object -- 對象
可調用返回 True，否則返回 False。
>>>callable(0) False >>> callable("runoob") False >>> def add(a, b): ... return a + b ... >>> callable(add) # 函數返回 True True >>> class A: # 類 ... def method(self): ... return 0 ... >>> callable(A) # 類返回 True True >>> a = A() >>> callable(a) # 沒有實現 __call__, 返回 False False >>> class B: ... def __call__(self): ... return 0 ... >>> callable(B) True >>> b = B() >>> callable(b) # 實現 __call__, 返回 True True
chr()
chr() 用一個整數作參數，返回一個對應的字符。
chr(i)
i -- 可以是 10 進制也可以是 16 進制的形式的數字，數字范圍為 0 到 1,114,111 (16 進制為0x10FFFF)。
返回值是當前整數對應的 ASCII 字符。
classmethod修飾符
classmethod 修飾符對應的函數不需要實例化，不需要 self 參數，但第一個參數需要是表示自身類的 cls 參數，可以來調用類的屬性，類的方法，實例化對象等。
classmethod
返回函數的類方法。
class A(object): bar = 1 def func1(self): print ('foo') @classmethod def func2(cls): print ('func2') print (cls.bar) cls().func1() # 調用 foo 方法 A.func2() # 不需要實例化
$compile()
compile() 函數將一個字符串編譯為字節代碼。
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 3 >>> str = "3 * 4 + 5" >>> a = compile(str,'','eval') >>> eval(a) 17
complex()
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)
delattr()
delattr 函數用於刪除屬性。
delattr(x, 'foobar') 相等於 del x.foobar。
delattr(object, name)
object -- 對象。
name -- 必須是對象的屬性。
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print('x = ',point1.x) print('y = ',point1.y) print('z = ',point1.z) delattr(Coordinate, 'z') print('--刪除 z 屬性后--') print('x = ',point1.x) print('y = ',point1.y) # 觸發錯誤 print('z = ',point1.z)
dict()
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)]) # 可迭代對象方式來構造字典 {'three': 3, 'two': 2, 'one': 1}
dir()
dir() 函數不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。如果參數包含方法dir()，該方法將被調用。如果參數不包含dir()，該方法將最大限度地收集參數信息。
dir([object]) object -- 對象、變量、類型。 返回模塊的屬性列表。
divmod()
Python divmod() 函數接收兩個數字類型（非復數）參數，返回一個包含商和余數的元組(a // b, a % b)。
在 python 3.x 版本該函數不支持復數。
divmod(a, b) a: 數字，非復數。 b: 數字，非復數。
enumerate()
enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。
enumerate(sequence, [start=0]) sequence -- 一個序列、迭代器或其他支持迭代對象。 start -- 下標起始位置。 返回 enumerate(枚舉) 對象。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>>list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] >>>list(enumerate(seasons, start=1)) # 小標從 1 開始 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
eval()
eval() 函數用來執行一個字符串表達式，並返回表達式的值。
eval(expression[, globals[, locals]]) expression -- 表達式。 globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。 locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。 返回表達式計算結果。
>>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> n=81 >>> eval("n + 4") 85
exec()
exec 執行儲存在字符串或文件中的 Python 語句，相比於 eval，exec可以執行更復雜的 Python 代碼。
exec(object[, globals[, locals]]) object：必選參數，表示需要被指定的Python代碼。它必須是字符串或code對象。如果object是一個字符串，該字符串會先被解析為一組Python語句，然后在執行（除非發生語法錯誤）。如果object是一個code對象，那么它只是被簡單的執行。 globals：可選參數，表示全局命名空間（存放全局變量），如果被提供，則必須是一個字典對象。 locals：可選參數，表示當前局部命名空間（存放局部變量），如果被提供，可以是任何映射對象。如果該參數被忽略，那么它將會取與globals相同的值。 exec 返回值永遠為 None。
>>>exec('print("Hello World")') Hello World # 單行語句字符串 >>> exec("print ('runoob.com')") runoob.com # 多行語句字符串 >>> exec ("""for i in range(5): ... print ("iter time: %d" % i) ... """) iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4
filter()
filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，如果要轉換為列表，可以使用 list() 來轉換。
該接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判，然后返回 True 或 False，最后將返回 True 的元素放到新列表中。
filter(function, iterable) function -- 判斷函數。 iterable -- 可迭代對象。 返回一個迭代器對象
def is_odd(n): return n % 2 == 1 tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) newlist = list(tmplist) print(newlist)
float()
float() 函數用於將整數和字符串轉換成浮點數。
class float([x]) x -- 整數或字符串 返回浮點數。
format()
Python2.6 開始，新增了一種格式化字符串的函數 str.format()，它增強了字符串格式化的功能。
基本語法是通過 {} 和 : 來代替以前的 % 。
format 函數可以接受不限個參數，位置可以不按順序。
| 數字 | 格式 | 輸出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小數點后兩位 |
| 3.1415926 | {:+.2f} | +3.14 | 帶符號保留小數點后兩位 |
| -1 | {:+.2f} | -1.00 | 帶符號保留小數點后兩位 |
| 2.71828 | {:.0f} | 3 | 不帶小數 |
| 5 | {:0>2d} | 05 | 數字補零 (填充左邊, 寬度為2) |
| 5 | {:x<4d} | 5xxx | 數字補x (填充右邊, 寬度為4) |
| 10 | {:x<4d} | 10xx | 數字補x (填充右邊, 寬度為4) |
| 1000000 | {:,} | 1,000,000 | 以逗號分隔的數字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指數記法 |
| 13 | {:>10d} | 13 | 右對齊 (默認, 寬度為10) |
| 13 | {:<10d} | 13 | 左對齊 (寬度為10) |
| 13 | {:^10d} | 13 | 中間對齊 (寬度為10) |
| 11 | '{:b}'.format(11) '{:d}'.format(11)'{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11) |
1011 11 13 b 0xb 0XB |
進制 |
frozenset()
frozenset() 返回一個凍結的集合，凍結后集合不能再添加或刪除任何元素。
class frozenset([iterable]) iterable -- 可迭代的對象，比如列表、字典、元組等等。 返回新的 frozenset 對象，如果不提供任何參數，默認會生成空集合。
>>>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']) # 創建不可變集合
getattr()
getattr() 函數用於返回一個對象屬性值。
getattr(object, name[, default]) object -- 對象。 name -- 字符串，對象屬性。 default -- 默認返回值，如果不提供該參數，在沒有對應屬性時，將觸發 AttributeError。 返回對象屬性值。
>>>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
globals()
globals() 函數會以字典類型返回當前位置的全部全局變量。
globals() 返回全局變量的字典。
>>>a='runoob' >>> print(globals()) # globals 函數返回一個全局變量的字典，包括所有導入的變量。 {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
hasattr()
hasattr() 函數用於判斷對象是否包含對應的屬性。
hasattr(object, name) object -- 對象。 name -- 字符串，屬性名。 如果對象有該屬性返回 True，否則返回 False。
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print(hasattr(point1, 'x')) print(hasattr(point1, 'y')) print(hasattr(point1, 'z')) print(hasattr(point1, 'no')) # 沒有該屬性
hash()
hash() 用於獲取取一個對象（字符串或者數值等）的哈希值。
hash(object) object -- 對象； 返回對象的哈希值。
>>>hash('test') # 字符串 2314058222102390712 >>> hash(1) # 數字 1 >>> hash(str([1,2,3])) # 集合 1335416675971793195 >>> hash(str(sorted({'1':1}))) # 字典 7666464346782421378
help()
help() 函數用於查看函數或模塊用途的詳細說明。
help([object]) object -- 對象； 返回對象幫助信息。
hex()
hex() 函數用於將一個指定數字轉換為 16 進制數。
hex(x) x -- 一個整數 返回一個字符串，以 0x 開頭。
id()
id() 函數用於獲取對象的內存地址。
id([object]) object -- 對象。 返回對象的內存地址。
input()
Python3.x 中 input() 函數接受一個標准輸入數據，返回為 string 類型。
input([prompt]) prompt: 提示信息
int()
int() 函數用於將一個字符串或數字轉換為整型。
class int(x, base=10) x -- 字符串或數字。 base -- 進制數，默認十進制。 返回整型數據。
isinstance()
isinstance() 函數來判斷一個對象是否是一個已知的類型，類似 type()。
isinstance(object, classinfo) object -- 實例對象。 classinfo -- 可以是直接或間接類名、基本類型或者由它們組成的元組。 如果對象的類型與參數二的類型（classinfo）相同則返回 True，否則返回 False。。
issubclass()
issubclass() 方法用於判斷參數 class 是否是類型參數 classinfo 的子類。
issubclass(class, classinfo) class -- 類。 classinfo -- 類。 如果 class 是 classinfo 的子類返回 True，否則返回 False。
iter()
iter() 函數用來生成迭代器。
iter(object[, sentinel]) object -- 支持迭代的集合對象。 sentinel -- 如果傳遞了第二個參數，則參數 object 必須是一個可調用的對象（如，函數），此時，iter 創建了一個迭代器對象，每次調用這個迭代器對象的__next__()方法時，都會調用 object。 迭代器對象。
>>>lst = [1, 2, 3] >>> for i in iter(lst): ... print(i) ... 1 2 3
len()
Python len() 方法返回對象（字符、列表、元組等）長度或項目個數。
len( s ) s -- 對象。 返回對象長度。
list()
list() 方法用於將元組或字符串轉換為列表。
注：元組與列表是非常類似的，區別在於元組的元素值不能修改，元組是放在括號中，列表是放於方括號中。
list( seq ) seq -- 要轉換為列表的元組或字符串。 返回列表。
locals()
locals() 函數會以字典類型返回當前位置的全部局部變量。
對於函數, 方法, lambda 函式, 類, 以及實現了 call 方法的類實例, 它都返回 True。
locals() 返回字典類型的局部變量。
>>>def runoob(arg): # 兩個局部變量：arg、z ... z = 1 ... print (locals()) ... >>> runoob(4) {'z': 1, 'arg': 4} # 返回一個名字/值對的字典
map()
map() 會根據提供的函數對指定序列做映射。
第一個參數 function 以參數序列中的每一個元素調用 function 函數，返回包含每次 function 函數返回值的新列表。
map(function, iterable, ...) function -- 函數 iterable -- 一個或多個序列 Python 2.x 返回列表。 Python 3.x 返回迭代器。
max()
max() 方法返回給定參數的最大值，參數可以為序列。
max( x, y, z, .... ) x -- 數值表達式。 y -- 數值表達式。 z -- 數值表達式。 返回給定參數的最大值。
$memoryview()
memoryview() 函數返回給定參數的內存查看對象(Momory view)。
所謂內存查看對象，是指對支持緩沖區協議的數據進行包裝，在不需要復制對象基礎上允許Python代碼訪問。
memoryview(obj) obj -- 對象 返回元組列表。
>>>v = memoryview(bytearray("abcefg", 'utf-8')) >>> print(v[1]) 98 >>> print(v[-1]) 103 >>> print(v[1:4]) <memory at 0x10f543a08> >>> print(v[1:4].tobytes()) b'bce'
min()
min() 方法返回給定參數的最小值，參數可以為序列。
min( x, y, z, .... ) x -- 數值表達式。 y -- 數值表達式。 z -- 數值表達式。 返回給定參數的最小值。
next()
next() 返回迭代器的下一個項目。
next(iterator[, default]) iterator -- 可迭代對象 default -- 可選，用於設置在沒有下一個元素時返回該默認值，如果不設置，又沒有下一個元素則會觸發 StopIteration 異常。 返回對象幫助信息。
oct()
oct() 函數將一個整數轉換成8進制字符串。
oct(x) x -- 整數。 返回8進制字符串。
open()
Python open() 函數用於打開一個文件，並返回文件對象，在對文件進行處理過程都需要使用到這個函數，如果該文件無法被打開，會拋出 OSError。
open(file, mode='r') 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+ | 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。如果該文件不存在，創建新文件用於讀寫。 |
默認為文本模式，如果要以二進制模式打開，加上 b 。
ord()
ord() 函數是 chr() 函數（對於 8 位的 ASCII 字符串）的配對函數，它以一個字符串（Unicode 字符）作為參數，返回對應的 ASCII 數值，或者 Unicode 數值。
ord(c) c -- 字符。 返回值是對應的十進制整數。
>>>ord('a') 97 >>> ord('€') 8364 >>>
pow()
pow() 方法返回 xy（x的y次方） 的值。
pow(x, y[, z]) x -- 數值表達式。 y -- 數值表達式。 z -- 數值表達式。 函數是計算x的y次方，如果z在存在，則再對結果進行取模，其結果等效於pow(x,y) %z 返回 xy（x的y次方） 的值。
print()
print() 方法用於打印輸出，最常見的一個函數。
print(*objects, sep=' ', end='\n', file=sys.stdout) objects -- 復數，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。 sep -- 用來間隔多個對象，默認值是一個空格。 end -- 用來設定以什么結尾。默認值是換行符 \n，我們可以換成其他字符串。 file -- 要寫入的文件對象。
property()
property() 函數的作用是在新式類中返回屬性值。
class property([fget[, fset[, fdel[, doc]]]]) fget -- 獲取屬性值的函數 fset -- 設置屬性值的函數 fdel -- 刪除屬性值函數 doc -- 屬性描述信息 返回新式類屬性。
class C(object): def __init__(self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.")
如果 c 是 C 的實例化, c.x 將觸發 getter,c.x = value 將觸發 setter ， del c.x 觸發 deleter。 如果給定 doc 參數，其將成為這個屬性值的 docstring，否則 property 函數就會復制 fget 函數的 docstring（如果有的話）。
將 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
range()
Python3 range() 函數返回的是一個可迭代對象（類型是對象），而不是列表類型， 所以打印的時候不會打印列表。
range(stop) 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)
repr()
repr() 函數將對象轉化為供解釋器讀取的形式。
repr(object) object -- 對象。 返回一個對象的 string 格式。
>>>s = 'RUNOOB' >>> repr(s) "'RUNOOB'" >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> repr(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}"
recersed()
reversed 函數返回一個反轉的迭代器。
reversed(seq) seq -- 要轉換的序列，可以是 tuple, string, list 或 range。 返回一個反轉的迭代器。
round()
round() 方法返回浮點數x的四舍五入值。
round( x [, n] ) x -- 數字表達式。 n -- 表示從小數點位數，其中 x 需要四舍五入，默認值為 0。 返回浮點數x的四舍五入值。
set()
set() 函數創建一個無序不重復元素集，可進行關系測試，刪除重復數據，還可以計算交集、差集、並集等。
class set([iterable]) iterable -- 可迭代對象對象； 返回新的集合對象。
setattr()
setattr() 函數對應函數 getattr()，用於設置屬性值，該屬性不一定是存在的。
setattr(object, name, value) object -- 對象。 name -- 字符串，對象屬性。 value -- 屬性值。
>>>class A(object): ... bar = 1 ... >>> a = A() >>> getattr(a, 'bar') # 獲取屬性 bar 值 1 >>> setattr(a, 'bar', 5) # 設置屬性 bar 值 >>> a.bar 5
slice()
slice() 函數實現切片對象，主要用在切片操作函數里的參數傳遞。
class slice(stop) class slice(start, stop[, step]) start -- 起始位置 stop -- 結束位置 step -- 間距 返回一個切片對象。
>>>myslice = slice(5) # 設置截取5個元素的切片 >>> myslice slice(None, 5, None) >>> arr = range(10) >>> arr [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> arr[myslice] # 截取 5 個元素 [0, 1, 2, 3, 4]
sort()
sorted() 函數對所有可迭代的對象進行排序操作。
sort 與 sorted 區別：
sort 是應用在 list 上的方法，sorted 可以對所有可迭代的對象進行排序操作。
list 的 sort 方法返回的是對已經存在的列表進行操作，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。
sorted(iterable, key=None, reverse=False) iterable -- 可迭代對象。 key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。 reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。 返回重新排序的列表。
>>>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] >>>example_list = [5, 0, 6, 1, 2, 7, 3, 4] >>> sorted(example_list, reverse=True) [7, 6, 5, 4, 3, 2, 1, 0]
staticmethod()
python staticmethod 返回函數的靜態方法。
該方法不強制要求傳遞參數，如下聲明一個靜態方法：
staticmethod(function) class C(object): @staticmethod def f(): print('runoob'); C.f(); # 靜態方法無需實例化 cobj = C() cobj.f() # 也可以實例化后調用
str()
str() 函數將對象轉化為適於人閱讀的形式。
class str(object='') object -- 對象。 返回一個對象的string格式。
sum()
sum() 方法對系列進行求和計算。
sum(iterable[, start]) iterable -- 可迭代對象，如：列表、元組、集合。 start -- 指定相加的參數，如果沒有設置這個值，默認為0。 返回計算結果。
>>>sum([0,1,2]) 3 >>> sum((2, 3, 4), 1) # 元組計算總和后再加 1 10 >>> sum([0,1,2,3,4], 2) # 列表計算總和后再加 2 12
super()
super() 函數是用於調用父類(超類)的一個方法。
super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重復調用（鑽石繼承）等種種問題。
MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。
super(type[, object-or-type]) type -- 類。 object-or-type -- 類，一般是 self
tuple()
tuple 函數將列表轉換為元組。
tuple( seq ) seq -- 要轉換為元組的序列。 返回元組。
type()
type() 函數如果你只有第一個參數則返回對象的類型，三個參數返回新的類型對象。
type(object) type(name, bases, dict) name -- 類的名稱。 bases -- 基類的元組。 dict -- 字典，類內定義的命名空間變量。 一個參數返回對象類型, 三個參數，返回新的類型對象。
vars()
vars() 函數返回對象object的屬性和屬性值的字典對象。
vars([object]) object -- 對象 返回對象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)) {}
zip()
zip() 函數用於將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的對象，這樣做的好處是節約了不少的內存。
zip([iterable, ...]) iterabl -- 一個或多個迭代器; 返回一個對象。
import()
import() 函數用於動態加載類和函數 。
如果一個模塊經常變化就可以使用 import() 來動態載入。
__import__(name[, globals[, locals[, fromlist[, level]]]]) name -- 模塊名 返回元組列表。
import sys
__import__('a') # 導入 a.py 模塊