Python標準庫(3.x): 內建函數掃盲

abs(x) 求一個數的絕對值。 all(iterable) 如果迭代器中的所有值都為“真”則返回 True, 否則返回 False 註意: 如果迭代器為空，返回 True any(iterable) 如果迭代器中的任意一個值為“真”則返回 True, 否則返回 False 註意: 如果迭代器為空， ...

**Built-in Functions**
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

abs(x)

　　求一個數的絕對值。

>>> abs(13)
13
>>> abs(-15)
15

all(iterable)

　　如果迭代器中的所有值都為“真”則返回 True, 否則返回 False

　　註意: 如果迭代器為空，返回 True

>>> all([1,1,1])
True
>>> all([1,0,1])
False
>>> all([])
True

any(iterable)

　　如果迭代器中的任意一個值為“真”則返回 True, 否則返回 False

　　註意: 如果迭代器為空，返回 False

>>> any([1,0,0])
True
>>> any([0,0,0])
False
>>> any([])
False

ascii(object)

　　該函數返回表示對象的可列印ascii字元串，如果字元串中含有非ascii字元，則以\x, \u 或者 \U 編碼來表示

　　函數其實是返回了對象的 __repr__() 方法的值

>>> a = 123
>>> a.__repr__()
'123'
>>> ascii(a)
'123'
>>> 
>>> b = 'test'
>>> b.__repr__()
"'test'"
>>> ascii(b)
"'test'"
>>>
>>> class MyTest:
...     def __repr__(self):
...         return 'Hello, world.'
... 
>>> t = MyTest()
>>> t.__repr__()
'Hello, world.'
>>> ascii(t)
'Hello, world.'

bin(x)

　　將整型轉換為二進位的字元串，字元串以'0b' 開頭.

　　不過說是將整型轉換為二進位，其實是將對象的__index__() 方法返回的值轉換為二進位字元串

　　註意: 如果對象沒有__index__() 方法，將會產生異常

>>> bin(11)
'0b1011'
>>> class MyTest():
...     def __index__(self):
...         return 5
... 
>>> t = MyTest()
>>> bin(t)
'0b101'

bool(x)

　　如果對象為“真”則返回 True, 否則返回 False

>>> bool(0)
False
>>> bool(1)
True

`bytearray`([source[, encoding[, errors]]])

　　創建一個 “可變的” byte數組，可以使用整型，字元串和迭代器來初始化

　　參數為字元串時，字元串中的每一個字元將轉換為數組的元素，因此需要提供編碼類型，類似utf-8, ascii等

　　參數為整型時，整形值將作為數組的初始化大小，數組的元素則初始化為0

　　參數為迭代器時，迭代器的每一個元素將作為數組的元素，因此迭代器的值必須為0-255的整型，否則將產生異常。

>>> a = bytearray(10)
>>> a
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> a[0]
0
>>> len(a)
10
>>> 
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>> 
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'\x01\x02\x03\x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'\x01\x02\x03')
>>> d[1] = 20
>>> d
bytearray(b'\x01\x14\x03')

`bytes`([source[, encoding[, errors]]])

　　bytes是bytearray的一個不可變的版本，其他的可以參考bytearray

>>> d = bytes([1,2,3])
>>> d
b'\x01\x02\x03'
>>> d[1] = 20
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment

callable(object)

　　判斷對象是否可以調用，如果可以則返回 True, 否則返回 False

　　類是可調用的，調用後返回一個類的實例。對象如果包含了__call__() 方法也是可調用的。

　　其實，只要可以寫成 object() 的，都是callable的

>>> def foo():
...     pass
... 
>>> callable(foo)
True
>>> 
>>> class MyTest:
...     def __call__(self):
...         pass
... 
>>> callable(MyTest)
True
>>> a = MyTest()
>>> callable(a)
True
>>> 
>>> b = 1
>>> callable(b)
False

chr(i)

　　返回Unicode對應的字元。

　　參數範圍為 0 -- 1114111, 超過此範圍將產生異常

>>> chr(97)
'a'
>>> chr(1666)
'ڂ'
>>> chr(1200000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)

classmethod(function)

　　一般作為函數裝飾器 @classmethod

　　將類中的一個方法指定為類方法。被指定的類方法第一個參數必須為cls(方法所在的類)

　　類方法的調用可以直接通過類調用，即C.f(); 也可以通過實例調用，即C().f()

　　類方法有一個比較方便的用處就是作為類似C++中的初始化函數重載

class MyTest():
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day 

    @classmethod
    def from_string(cls, date_string):
        year, month, day = map(int, date_string.split('-'))
        return cls(year, month, day)
    
    def output(self):
        print('Birthday: {}-{}-{}'.format(self.year, self.month, self.day))



>>> a = MyTest(1989, 12, 26)
>>> a.output()
Birthday: 1989-12-26
>>> 
>>> b = MyTest.from_string('1990-1-1')
>>> b.output()
Birthday: 1990-1-1

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

　　該函數將含有python語句的字元串編譯成可執行的位元組碼，編譯的結果配合 eval, 或 exec 使用。

　　source -- 需要編譯的字元串

　　filename -- 存儲字元串的文件

　　mode -- 'eval' 配合 eval 使用, 'exec' 配合多語句的 exec 使用，'single' 配合單語句的 exec 使用

　　註：實測中，編譯的時候會判斷mode, 但是執行的時候使用 exec 或者 eval，結果一樣

>>> a = compile('1+2', filename='',  mode='eval')
>>> eval(a)
3
>>> 
>>> b = compile('for i in range(3): print(i)', filename='', mode='exec')
>>> exec(b)
0
1
2
>>> 
>>> c = compile('print("Hello, world.")', filename='', mode='exec')
>>> exec(c)
Hello, world.

complex([real[, imag]])

　　返回一個複數。複數值為 real + imag*1j

　　參數也可以為一個表示覆數的字元串，但是字元串中不能有空格。使用字元串作為參數時，沒有第二個參數。

　　註1: 兩個參數的預設值均為0

　　註2: 直接用複數表達式 a+bj 創建的對象也是 complex 類型

>>> a = complex(1, 2)
>>> a
(1+2j)
>>> 
>>> b = 2+3j
>>> type(b)
<class 'complex'>
>>> 
>>> c = complex('5+6j')
>>> c
(5+6j)
>>> 
>>> d = complex(1+2j, 1+2j)
>>> d
(-1+3j)

delattr(object, name)

　　刪除對象的一個屬性（不能是對象的方法），但是不會影響該類的其他對象。同 del object.name

　　註: 參數 name 是一個字元串

>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> a.test
'test'
>>> b = MyTest()
>>> b.test
'test'
>>> delattr(a, 'test')
>>> a.test
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'test'
>>> 
>>> b.test
'test'

dict(**kwarg) dict(*mapping, **kwarg) dict(iterable, **kwarg*)

　　創建並返回一個字典對象。初始化參數可以有三種傳入方式。

　　關鍵字方式，將直接根據關鍵字生成字典

　　迭代器方式，迭代器中的對象必須只有兩個元素，第一個元素將作為key，第二個作為值

　　映射方式，其實也是一種迭代器方式

　　註: 當然也可以直接使用字典作為參數來初始化

>>> dict(one=1, two=2, three=3)
{'two': 2, 'one': 1, 'three': 3}
>>> 
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict([('one', 1), ('two', 2), ('three', 3)])
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict({'one':1, 'two':2, 'three':3})
{'one': 1, 'two': 2, 'three': 3}

dir([object])

　　很有用的幫助函數。顯示當前命名空間，對象或者類的所有屬性和方法。

　　object 可以為對象或者類，如果省略表示當前的命名空間

>>> class MyTest():
...     pass
... 
>>> def foo():
...     pass
... 
>>> a = 1
>>> 
>>> dir()
['MyTest', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'foo']
>>> 
>>> import math
>>> 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']
>>> 
>>> d = dict()
>>> dir(d)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

divmod(a, b)

　　返回 (a // b, a % b) 的元組

　　註：a，b可以為整型或者浮點型，但是不能是複數

>>> divmod(7, 3)
(2, 1)
>>> 
>>> divmod(4.3, 1.5)
(2.0, 1.2999999999999998)
>>> 
>>> (4.3 // 1.5, 4.3 % 1.5)
(2.0, 1.2999999999999998)

enumerate(iterable, start=0)

　　返回一個可迭代的枚舉類型。

　　迭代器中的對象，第一個元素為序號（預設從start=0開始），第二個元素為傳入迭代器中的對象。

　　註: 多用於for遍歷過程中，需要同時得到序號的情況。

>>> names = ['Tom', 'Jack', 'Lily']
>>> for i, name in enumerate(names, start=1):
...     print(i ,name)
... 
1 Tom
2 Jack
3 Lily

eval(expression, globals=None, locals=None)

　　將一個表示python表達式的字元串編譯成python語句並執行（慎用！）

　　返回值，如果傳入參數是字元串或者mode='eval'編譯的位元組碼，則返回互動式運行結果，否則返回None

　　globals和locals為高級用法，此處不展開。預設使用當前命名空間。

　　註1: 語句必須是單條語句

　　註2: 字元串中可以帶入變數，但變數必須在命令空間中定義。

　　註3: 可以配合compile()使用

>>> eval('2+5')
7
>>> x = 3
>>> eval('x**2 + 3*x + 5')
23

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

　　將一個表示python表達式的字元串編譯成python語句並執行（慎用！）

　　返回值為None

　　globals和locals為高級用法，此處不展開。預設使用當前命名空間。

　　註1: 語句可以是多條

　　註2: 字元串中可以帶入變數，但變數必須在命令空間中定義。

　　註3: 可以配合compile()使用

>>> exec('for i in range(5): print(i)')
0
1
2
3
4

filter(function, iterable)

　　將一個可迭代的對象按傳入的函數進行過濾。函數返回 True 的元素將保留，其它將被過濾掉。

>>> a = [1,2,3,4,5,6,7,8,9]
>>> list(filter(lambda x: x % 2, a))
[1, 3, 5, 7, 9]

float([x])

　　創建並返回一個浮點型的對象。

　　x可以為一個數或者一個表示浮點數的字元串，預設值為0

>>> float(3)
3.0
>>> float('1.23')
1.23

format(value [, format_spec])

　　將value按格式化轉化為字元串，並返回。

　　目前較多的用法是調用字元串的format方法。

　　format_spec 指定格式化方式，此處不展開（將會有專題博文）。

>>> format(10, 'b')
'1010'
>>> format('555', '0>5')
'00555'

frozenset([iterable])

　　傳入一個可迭代的對象，創建一個不可變的集合。除了元素不能添加刪除外，其他和可變集合類似。

　　如果沒有參數，則創建一個空集合。

>>> a = frozenset([1,2,2,3,4,5])
>>> a
frozenset({1, 2, 3, 4, 5})
>>> 2 in a
True

getattr(object, name [, default])

　　獲取對象的一個屬性的值。

　　如果對象存在該屬性則返回屬性值。

　　如果屬性不存在，當傳了default時返回default的值，否則產生異常。

　　註:參數 name 是一個字元串

>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> getattr(a, 'test')
'test'
>>> getattr(a, 'foo', 'attr not exist')
'attr not exist'
>>> 
>>> getattr(a, 'foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'foo'

globals()

　　返回當前全局域的{對象: 值} 字典

>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__',