image.png

• abs(x)

返回一個數(shù)的絕對值棵癣。
參數(shù)可以是一個整數(shù)或浮點數(shù)。
如果參數(shù)是一個復數(shù)夺衍，則返回它的模狈谊。
如果 x 定義了 __abs__()，則 abs(x) 將返回 x.__abs__()

• all(iterable)

如果 iterable 的所有元素為真（或迭代器為空）沟沙，返回 True 河劝。等價于(這個等價真的一語中的):

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

• any(iterable)

任一 ，和 all() 相反矛紫，只滿足一個即可赎瞎，相當于是 all() 的取反。
如果 iterable 的任一元素為真則返回 True颊咬。
如果迭代器為空务甥，返回 False。 等價于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

• ascii(object)

就像函數(shù) repr()喳篇，返回一個對象可打印的字符串敞临，但是 repr() 返回的字符串中非 ASCII 編碼的字符，會使用 \x麸澜、\u 和 \U 來轉(zhuǎn)義挺尿。生成的字符串和 Python 2 的 repr() 返回的結(jié)果相似。

• bin(x)

bin 即：binary 二進制的縮寫炊邦，轉(zhuǎn)化為二進制的意思
將一個整數(shù)轉(zhuǎn)變?yōu)橐粋€前綴為“0b”的二進制字符串编矾。結(jié)果是一個合法的 Python 表達式。如果 x 不是 Python 的 int 對象铣耘，那它需要定義 __index__() 方法返回一個整數(shù)洽沟。一些例子：

>>> bin(3)    
'0b11'
>>> bin(-10)
'-0b1010'

• class bool([x])

返回一個布爾值，True 或者 False蜗细。 x 使用標準的 真值測試過程 來轉(zhuǎn)換。如果 x 是假的或者被省略，返回 False炉媒；其他情況返回 True踪区。bool 類是 int 的子類（參見 數(shù)字類型 --- int, float, complex）。其他類不能繼承自它吊骤。它只有 False 和 True 兩個實例（參見 布爾值）缎岗。

• breakpoint(*args, **kws)

此函數(shù)會在調(diào)用時將你陷入調(diào)試器中，神馬pdb啥的白粉，感覺太難了传泊，哈哈哈，以后有機會再看

• class bytearray([source[, encoding[, errors]]])

返回一個新的 bytes 數(shù)組

• class bytes([source[, encoding[, errors]]])

返回一個新的“bytes”對象鸭巴， 是一個不可變序列眷细，包含范圍為 0 <= x < 256 的整數(shù)。bytes 是 bytearray 的不可變版本

• callable(object)

如果參數(shù) object 是可調(diào)用的就返回 True鹃祖，否則返回 False溪椎。 如果返回 True，調(diào)用仍可能失敗恬口，但如果返回 False校读，則調(diào)用 object 將肯定不會成功。如果是類本身祖能，肯定是callable 的（因為所有類都可以（ ） 初始化）歉秫，所以一般判斷的是類的實例，只要實例所在的類有 _ call _ 就是判True
這個函數(shù)一開始在 3.0 的時候被移除了养铸，3.2 之后又重新引入

• chr(i)

i 合法范圍是 0 到 1,114,111（16 進制表示是 0x10FFFF）雁芙，把整數(shù)轉(zhuǎn)化為 Unicode 字符（所有的單個字符，所有國家的語言揭厚，比如中文就轉(zhuǎn)化為 一個喊漢字却特，或者一個 中文標點符號等等。）表示（是ord 的逆函數(shù)）

幾乎可以轉(zhuǎn)化為所有字符

中文真實博大精深50010 是什么漢字筛圆？裂明？

韓文大概是40000+ 之后了

• @classmethod

裝飾器，把一個方法封裝成類方法太援，就像實例把自己傳入給 第一個參數(shù)self 一樣闽晦，類方法會把所屬類 傳給方法第一個參數(shù)
調(diào)用直接使用類，或者其實例都可以的提岔，如果是繼承的子類調(diào)用仙蛉，則會把子類自己傳入。

如果類方法在其所屬類的派生類上調(diào)用碱蒙，則該派生類對象會被作為隱含的第一個參數(shù)被傳入 (派生類理解為子類)

• compile (source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

這個函數(shù)內(nèi)容還挺多的
簡單來說和eval() 有點類似的感覺
參數(shù)：
source -- 字符串或者AST（Abstract Syntax Trees）對象荠瘪。夯巷。
filename -- 代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值哀墓。
mode -- 指定編譯代碼的種類趁餐。可以指定為 exec, eval, single篮绰。

指定編譯代碼的種類后雷。可以指定為 exec, eval, single
compile（）方法返回一個Python代碼對象

如果Python代碼為字符串形式或是AST對象吠各，并且您想將其更改為代碼對象臀突，則使用compile（）方法
稍后可以使用諸如exec（） 和 eval（）之類的方法來調(diào)用compile（）方法返回的代碼對象，這些方法 將執(zhí)行動態(tài)生成的Python代碼
Python可執(zhí)行對象——exec贾漏、eval候学、compile
compile 返回的是 可以被eval exec 或 single 可以調(diào)用的對象

簡單來說：

compile語句是從type類型（包括’eval’: 配合eval使用，’single’: 配合單一語句的exec使用磕瓷，’exec’: 配合多語句的exec使用）中將str里面的語句創(chuàng)建成代碼對象盒齿。file是代碼存放的地方，通常為""困食。
compile語句的目的是提供一次性的字節(jié)碼編譯边翁，就不用在以后的每次調(diào)用中重新進行編譯了

其實可直接使用eval 和exec 的，只不過compile 和re.compile 的目的是一樣的硕盹，編譯一次符匾，加快執(zhí)行速度。
關于eval 和exec的使用以及參數(shù)的不同瘩例，參見下面的 這兩個內(nèi)置函數(shù)的介紹
eval 只能執(zhí)行單一語句啊胶，比如"a+1", "print(22)" ,不執(zhí)行 "for i in range(5):print(21)",但是exec 卻可以

• class complex([real[, imag]])

把參數(shù)(數(shù)字或數(shù)字類字符串)轉(zhuǎn)化復數(shù)表示；
例子：

complex(1, 2)
結(jié)果：(1 + 2j)
complex(1)    # 數(shù)字 第二個參數(shù)默認為 0 
(1 + 0j)
complex()  # 不傳參數(shù)默認都為 0 
結(jié)果 （0j）
 # 注意：這個地方在"+"號兩邊不能有空格垛贤，也就是不能寫成"1 + 2j"焰坪，應該是"1+2j"，否則會報錯
>>> complex("1+2j")
(1 + 2j)

如果參數(shù)是 Python 對象：
對于一個普通 Python 對象 x聘惦，complex(x) 會委托給 x.__complex__()某饰。 如果 __complex__() 未定義則將回退至 __float__()。 如果 __float__() 未定義則將回退至 __index__()善绎。

多講一點黔漂，int() float() complex() index() 分別調(diào)用是對象的
__int__(), __float__() 和 __complex__()
__index__(self)

類似的內(nèi)置函數(shù) ，如果他們的參數(shù)是對象禀酱，而不是常規(guī)參數(shù) 炬守。有很多都是調(diào)用的這些對應的內(nèi)置魔法方法。（一般來說 就是內(nèi)置函數(shù)前后加上 _ _）

比如 int("2") 結(jié)果是 2
傳入對象如果沒有 _ _ int_ _() 會報錯剂跟，因為他既不是 明顯的數(shù)字字符串减途，也不是帶有 可以調(diào)用 的 _ int _() 對象：

沒有 __ int__ 會觸發(fā)錯誤的

• delattr(object, name)

這個很熟悉了酣藻。 和setattr() getattr() hasattr()都是一起的
delattr(x, 'foobar') 等價于 del x.foobar

• class dict(**kwarg)

穿件一個新字典的函數(shù)，這個很熟悉了

• dir([object])

如果沒有實參观蜗，則返回當前本地作用域中的名稱列表臊恋。如果有實參衣洁，它會嘗試返回該對象的有效屬性列表

無參數(shù)

有參數(shù)就返回對象的所有屬性

如果對象是模塊對象，則列表包含模塊的屬性名稱环凿。
如果對象是類型或類對象梧兼，則列表包含它們的屬性名稱，并且遞歸查找所有基類的屬性智听。
否則羽杰，列表包含對象的屬性名稱，它的類屬性名稱到推，并且遞歸查找它的類的所有基類的屬性

返回的列表按字母表排序考赛。例如：

>>> import struct
>>> dir()   # show the names in the module namespace  # doctest: +SKIP
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module # doctest: +SKIP
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

• divmod(a, b)

返回 一個結(jié)果元祖，第一個元素是商莉测，第二個參數(shù)是余數(shù)

如：

>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

• enumerate(iterable, start=0)

這個也很熟悉了颜骤，迭代列表元素的時候經(jīng)常用，返回 （index,value） 元祖 的迭代器（帶yield ,那就是一個迭代器了）
原理如下：

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

• eval(expression[, globals[, locals]])

很熟悉了

• exec(object[, globals[, locals]])

和eval 類似捣卤，但是支持動態(tài)執(zhí)行語句忍抽，一大串的那種
可以是 compile 編譯過的pythoN 對象
該函數(shù)返回值是 None 請注意

只會執(zhí)行代碼，但是不會返回任何東西

• filter(function, iterable)

這個也用過董朝，經(jīng)常和map 函數(shù)一起使用的來著 ,map 是不判斷鸠项，直接把后面的可迭代參數(shù) ，傳入前面的 func子姜，結(jié)果也是一個可迭代對象

Python2.x 中返回的是過濾后的列表, 而 Python3 中返回到是一個 filter 類祟绊。
filter 類實現(xiàn)了 iter 和 next 方法, 可以看成是一個迭代器, 有惰性運算的特性, 相對 Python2.x 提升了性能, 可以節(jié)約內(nèi)存。

function -- 判斷函數(shù)闲询。
iterable -- 可迭代對象久免。
下面說的就比較清晰了

filter(function, iterable) 相當于一個生成器表達式，當 function 不是 None 的時候為 (item for item in iterable if function(item))扭弧；function 是 None 的時候為 (item for item in iterable if item) 阎姥。

例子：

過濾出1~100中平方根是整數(shù)的數(shù)：
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101))
print(list(newlist))
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• class float([x])

返回從數(shù)字或字符串 x 生成的浮點數(shù)
如果實參是字符串，則它必須是包含十進制數(shù)字的字符串
普通Python對象 會交個 __float__() 如果沒有float()鸽捻，則將回退至 __index__()
如果沒有實參呼巴，則返回 0.0

• format(value[, format_spec])

這個比較熟悉泽腮，不單獨詳說

• class frozenset([iterable])

• getattr(object, name[, default])

這個很熟悉了，不多介紹

• globals()

返回表示當前全局符號表的字典衣赶。這總是當前模塊的字典

演示

• hasattr(object, name)

獲取對象的屬性诊赊，name是字符串
是調(diào)用 getattr(object, name) 看是否有 AttributeError 異常來實現(xiàn)的
如果字符串是對象的屬性之一的名稱，則返回 True府瞄，否則返回 False碧磅。

• hash(object)

返回該對象的哈希值（如果它有的話）。哈希值是整數(shù)遵馆。它們在字典查找元素時用來快速比較字典的鍵鲸郊。相同大小的數(shù)字變量有相同的哈希值（即使它們類型不同，如 1 和 1.0）货邓。

• help([object])

和dir 有點像秆撮，但是會詳細一點

• hex(x)

整數(shù)轉(zhuǎn)化為16 進制
將整數(shù)轉(zhuǎn)換為以“0x”為前綴的小寫十六進制字符串。如果 x 不是 Python int 對象换况，則必須定義返回整數(shù)的 __index__() 方法职辨。一些例子：

hex(255)
'0xff'
hex(-42)
'-0x2a'

別忘了轉(zhuǎn)化字符串要 也可以用 % 或者 format 實現(xiàn):

'%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

image.png

image.png

格式化字符串文字: 就是常見的 f 或者 F 開頭的 常簡稱為 f-字符串
將表達式寫成 {expression} 來在字符串中包含 Python 表達式的值。
例子一：

import math
print(f'The value of pi is approximately {math.pi:.3f}.')
The value of pi is approximately 3.142

例子二：

在 ':' 后傳遞一個整數(shù)可以讓該字段成為最小字符寬度戈二。這在使列對齊時很有用
table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
for name, phone in table.items():
...     print(f'{name:10} ==> {phone:10d}')
...
Sjoerd     ==>       4127
Jack       ==>       4098
Dcab       ==>       7678

animals = 'eels'
print(f'My hovercraft is full of {animals}.')
My hovercraft is full of eels.`

從上面看出舒裤，這是 % fromat 的另一種 實現(xiàn)方式。{} 里面可以傳變量挽拂，或者表達式惭每，并且可以在 后面加 { varname :xx } 來格式化這個變量的值,總的來說，你如果使用了這個格式化字符串亏栈，你就是高大上了
最后弄一個台腥，對齊的例子，回憶一下format 把

2d  表示 長度為 2 的十進制整數(shù)
for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

• id(object)

很熟悉了
返回對象的“標識值”绒北。該值是一個整數(shù)黎侈，在此對象的生命周期中保證是唯一且恒定的。兩個生命期不重疊的對象可能具有相同的 id() 值

以下函數(shù)記錄記錄的比較快了闷游，雖然比較熟悉峻汉，但是原理并不是太別的了解，需要經(jīng)称晖看看

• input([prompt])

當讀取到 EOF 時休吠，則觸發(fā) EOFError。

• class int([x])

在 3.8 版更改: 如果 __int__() 未定義則回退至 __index__()

• isinstance(object, classinfo)

如果 classinfo 既不是類型业簿，也不是類型元組或類型元組的元組瘤礁，則將引發(fā) TypeError異常。
classinfo 可以是默認類梅尤，也可以是你自定義的柜思，可以是多個類型的元祖岩调， 只滿足一個就是 True

• issubclass(class, classinfo)

和上一個 isinstance 類似，只不過是直接判斷類的赡盘，而不是實例

• iter(object[, sentinel])

這個很熟悉了号枕，把克迭代對象，轉(zhuǎn)化為 迭代器
這個函數(shù)的解釋很麻煩陨享。
寫一個文件讀寫的例子：

from functools import partial  # 這個是偏函數(shù)葱淳，他返回的是函數(shù)對象哦，這里
相當于給了他一個初始參數(shù) 64 
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

關于：partial 函數(shù) 定義：

func = functools.partial(func, *args, **keywords)
func: 需要被擴展的函數(shù)霉咨，返回的函數(shù)其實是一個類 func 的函數(shù)
*args: 需要被固定的位置參數(shù)
**kwargs: 需要被固定的關鍵字參數(shù)
# 如果在原來的函數(shù) func 中關鍵字不存在蛙紫，將會擴展，如果存在途戒，則會覆蓋

關于 partial 的使用例子：

def add(*args, **kwargs):
    # 打印位置參數(shù)
    for n in args:
        print(n)
    print("-"*20)
    # 打印關鍵字參數(shù)
    for k, v in kwargs.items():
       print('%s:%s' % (k, v))
add_partial = partial(add, 10, k1=10, k2=20)
add_partial(1, 2, 3, k3=20)
"""
10
1
2
3
--------------------
k1:10
k2:20
k3:20

可以看出，partial 只是為了傳入?yún)?shù)的方便僵驰，并且 會把參數(shù)放到函數(shù)真正傳入的參數(shù)之前喷斋。比如一個函數(shù)都要傳入固定的幾個參數(shù)值，那么可以統(tǒng)一用 partial 包裝一下蒜茴，精簡代碼之用

• len(s)

返回對象的長度（元素個數(shù)）星爪。實參可以是序列（如 string、bytes粉私、tuple顽腾、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）

• class list([iterable])

• locals()

在函數(shù)代碼塊但不是類代碼塊中調(diào)用 locals() 時將返回自由變量

def runoob(arg):    # 兩個局部變量：arg诺核、z
...     z = 1
...     print (locals())
... 
runoob(4)
{'z': 1, 'arg': 4}

在模塊層級上 locals() 和 globals()是同一個字典

• map(function, iterable, ...)

返回一個將 function 應用于 iterable 中每一項并輸出其結(jié)果的迭代器

numbers1 = [1, 2, 3] 
numbers2 = [4, 5, 6] 
  
result = map(lambda x, y: x + y, numbers1, numbers2) 
print(list(result)) 
 >> [5抄肖、7、9]

• max(iterable, *[, key, default])

返回最大值窖杀，很簡單

• memoryview(obj)

• min(iterable, *[, key, default])

返回最小值 很簡單

• next(iterator[, default])

很熟悉，通過調(diào)用迭代器的 _ next _ 返回下一個值，
如果迭代器耗盡征堪，則返回給定的 default嚎莉，如果沒有默認值則觸發(fā) StopIteration
可以返回默認值，以前并不知道桌硫，哈哈哈

• class object

基類 它具有所有 Python 類實例的通用方法夭咬。這個函數(shù)不接受任何實參

• oct(x)

整數(shù)返回8 進制的，方法同hex

• open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

如果該文件不能打開铆隘，則觸發(fā) OSError
打開文件這個函數(shù)還是有點多的內(nèi)容卓舵。
一會仔細總結(jié)：
文件模式 r w a x + b
r 讀
w 寫（不存在新建）
a 追寫 (w 是清空，append首字母記憶)

• (w+ 或 r+ a+ 表示可讀可寫咖驮，因為不存在 rw 或 wr,用 + 代替)
  b 二進制操作內(nèi)容 （默認為t 文本格式边器，可省略不寫）
  
  沒有rw 的用法
  
  其余知識 训枢，以后再增加

• ord(c)

chr() 逆函數(shù)，把字符轉(zhuǎn)化為他的unicode 碼

• pow(base, exp[, mod])

返回 base 的 exp 次冪 等價于 base ** exp
如果 mod 存在忘巧，則返回 base 的 exp 次冪對 mod 取余（比 pow(base, exp) % mod 更高效）

• print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

老朋友了
將 objects 打印到 file 指定的文本流恒界，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在砚嘴，它們必須以關鍵字參數(shù)的形式給出十酣。
非關鍵字參數(shù)都會被轉(zhuǎn)換為字符串，就像是執(zhí)行了 str() 如果沒有給出 objects际长，則 print() 將只寫入 end
file默認使用 sys.stdout 到控制臺 也可是 文件對象 比如 f = open(xxx) 的f ,但是只能是 文本二進制數(shù)據(jù)耸采，不能用 print() 而應該用 f.write()

• class property(fget=None, fset=None, fdel=None, doc=None)

一個典型的用法是定義一個托管屬性 x:

class C:
    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.")

上面的x 就是一個特殊屬性，他的值是 通過上面三個函數(shù)控制的工育。
如果 c 是 C 的實例虾宇，c.x 將調(diào)用getter，c.x = value 將調(diào)用setter如绸， del c.x 將調(diào)用deleter
用裝飾器等效

class C:
    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

@property 裝飾器會將 voltage() 方法轉(zhuǎn)化為一個具有相同名稱的只讀屬性的 "getter"嘱朽，并會生成setter deleter 這個兩個函數(shù) 并將 voltage 的文檔字符串設置為 "Get the current voltage."

• range(stop)

很熟悉

• repr(object)

• reversed(seq)

返回一個反向的 iterator seq 必須是一個具有 __reversed__() 方法的對象或者是支持該序列協(xié)議（具有從 0 開始的整數(shù)類型參數(shù)的 __len__()方法和 __getitem__()方法）。

• round(number[, ndigits])

四舍五入 測試了一下怔接，4.5 還是 4 4.51 就是5了
對于一般的 Python 對象 number, round 將委托給 number.round

image.png

image.png

• class set([iterable])

返回一個新的 set 對象搪泳，可以選擇帶有從 iterable 獲取的元素
set 是一個不重復的集合

image.png

• setattr(object, name, value)

setattr(x, 'foobar', 123) 等價于 x.foobar = 123

• class slice(stop) / slice(start, stop[, step]) 多態(tài)方法

創(chuàng)建切片對象
正常切片都是 [index,stop,step] 現(xiàn)在可以 xx（slice(..)） 等價于 xx[...]
主要是很多相同的切片，實現(xiàn)統(tǒng)一的切片定義扼脐，符合代碼的規(guī)范

>>>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]

• sorted(iterable, *, key=None, reverse=False)

key 指定帶有單個參數(shù)的函數(shù)岸军，用于從 iterable 的每個元素中提取用于比較的鍵 (例如 key=str.lower)。 默認值為 None (直接比較元素)瓦侮。
reverse 為一個布爾值艰赞。 如果設為 True，則每個列表元素將按反向順序比較進行排序
注意：字典默認按照key進行排序脏榆，返回key 列表猖毫，其他的都是對元素排序

sorted([5, 2, 3, 1, 4])
# [1, 2, 3, 4, 5]
sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
# [1, 2, 3, 4, 5]
sorted  比較的是 相當于 for i in iter  對i  進行排序，最后返回一個排序好的 i 列表须喂。  

指定排序key(來自迭代的元素)

student_tuples = [
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
]
sorted(student_tuples, key=lambda student: student[2])   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

• @staticmethod

靜態(tài)方法不會接收隱式的第一個參數(shù)吁断。要聲明一個靜態(tài)方法，請使用此語法

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

靜態(tài)方法的調(diào)用可以在類上進行 (例如 C.f()) 也可以在實例上進行 (例如 C().f())

像所有裝飾器一樣坞生，也可以像常規(guī)函數(shù)一樣調(diào)用 staticmethod

class C:
    builtin_open = staticmethod(open)

• class str(object=b'', encoding='utf-8', errors='strict')

文本化對象

• sum(iterable, /, start=0)

求和

• super([type[, object-or-type]])

這個是子類調(diào)用父類的方法仔役，python2 是super(當前obj,self).xx
Python3 是直接 super().xx

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)  py2傳的是 當前類，
并且 按照mro 順序查找 第一個有改方法名的父類的這個方法

詳細說明參見：
https://docs.python.org/zh-cn/3/library/functions.html#super

• tuple([iterable])

• class type(name, bases, dict)

通常與 object.__class__ 所返回的對象相同是己。
一般用 isinstance 比較好 又兵，因為他會判斷子類的情況

• vars([object])

返回模塊、類、實例或任何其它具有 __dict__屬性的對象的 __dict__ 屬性

• zip(*iterables)

也很熟悉
創(chuàng)建一個聚合了來自每個可迭代對象中的元素的迭代器沛厨。
他的長度是最短的元素長度
相當于:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

• import

此函數(shù)會由 import 語句發(fā)起調(diào)用
這個以后再說把