Python內置的函數及其用法。為了方便記憶，已經有很多開發者將這些內置函數進行了如下分類：
數學運算(7個)
類型轉換(24個)
序列操作(8個)
對象操作(7個)
反射操作(8個)
變量操作(2個)
交互操作(2個)
文件操作(1個)
編譯執行(4個)
裝飾器(3個)
接下來看看具體每個類別里包含了那些內置函數
一、數學運算類
abs(x) 求絕對值
1、參數可以是整型，也可以是復數
2、若參數是復數，則返回復數的模
complex([real[, imag]]) 創建一個復數
divmod(a, b) 分別取商和余數
注意：整型、浮點型都可以
float([x]) 將一個字符串或數轉換為浮點數。如果無參數將返回0.0
int([x[, base]]) 將一個字符轉換為int類型，base表示進制
long([x[, base]]) 將一個字符轉換為long類型
pow(x, y[, z]) 返回x的y次冪
range([start], stop[, step]) 產生一個序列，默認從0開始
round(x[, n]) 四舍五入
sum(iterable[, start]) 對集合求和
oct(x) 將一個數字轉化為8進制
hex(x) 將整數x轉換為16進制字符串
chr(i) 返回整數i對應的ASCII字符
bin(x) 將整數x轉換為二進制字符串
bool([x]) 將x轉換為Boolean類型
二、集合類操作
basestring() str和unicode的超類
不能直接調用，可以用作isinstance判斷
format(value [, format_spec]) 格式化輸出字符串
格式化的參數順序從0開始，如“I am {0},I like {1}”
unichr(i) 返回給定int類型的unicode
enumerate(sequence [, start = 0]) 返回一個可枚舉的對象,該對象的next()方法將返回一個tuple
iter(o[, sentinel]) 生成一個對象的迭代器，第二個參數表示分隔符
max(iterable[, args...][key]) 返回集合中的最大值
min(iterable[, args...][key]) 返回集合中的最小值
dict([arg]) 創建數據字典
list([iterable]) 將一個集合類轉換為另外一個集合類
set() set對象實例化
frozenset([iterable]) 產生一個不可變的set
str([object]) 轉換為string類型
sorted(iterable[, cmp[, key[, reverse]]]) 隊集合排序
tuple([iterable]) 生成一個tuple類型
xrange([start], stop[, step]) xrange()函數與range()類似，但xrnage()並不創建列表，而是返回一個xrange對象，它的行為與列表相似，但是只在需要時才計算列表值，當列表很大時，這個特性能為我們節省內存
三、邏輯判斷
all(iterable) 1、集合中的元素都為真的時候為真
2、特別的，若為空串返回為True
any(iterable) 1、集合中的元素有一個為真的時候為真
2、特別的，若為空串返回為False
cmp(x, y) 如果x < y ,返回負數；x == y, 返回0；x > y,返回正數
四、反射
callable(object) 檢查對象object是否可調用
1、類是可以被調用的
2、實例是不可以被調用的，除非類中聲明了__call__方法
classmethod() 1、注解，用來說明這個方式是個類方法
2、類方法即可被類調用，也可以被實例調用
3、類方法類似於Java中的static方法
4、類方法中不需要有self參數
compile(source, filename,
mode[, flags[, dont_inherit]])
將source編譯為代碼或者AST對象。代碼對象能夠通過exec語句來執行或者eval()進行求值。
1、參數source：字符串或者AST（Abstract Syntax Trees）對象。
2、參數 filename：代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。
3、參數model：指定編譯代碼的種類。可以指定為 ‘exec’,’eval’,’single’。
4、參數flag和dont_inherit：這兩個參數暫不介紹
dir([object]) 1、不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；
2、帶參數時，返回參數的屬性、方法列表。
3、如果參數包含方法__dir__()，該方法將被調用。當參數為實例時。
4、如果參數不包含__dir__()，該方法將最大限度地收集參數信息
delattr(object, name) 刪除object對象名為name的屬性
eval(expression [, globals [, locals]]) 計算表達式expression的值
execfile(filename [, globals [, locals]]) 用法類似exec()，不同的是execfile的參數filename為文件名，而exec的參數為字符串。
filter(function, iterable) 構造一個序列，等價於[ item for item in iterable if function(item)]
1、參數function：返回值為True或False的函數，可以為None
2、參數iterable：序列或可迭代對象
getattr(object, name [, defalut]) 獲取一個類的屬性
globals() 返回一個描述當前全局符號表的字典
hasattr(object, name) 判斷對象object是否包含名為name的特性
hash(object) 如果對象object為哈希表類型，返回對象object的哈希值
id(object) 返回對象的唯一標識
isinstance(object, classinfo) 判斷object是否是class的實例
issubclass(class, classinfo) 判斷是否是子類
len(s) 返回集合長度
locals() 返回當前的變量列表
map(function, iterable, ...) 遍歷每個元素，執行function操作
memoryview(obj) 返回一個內存鏡像類型的對象
next(iterator[, default]) 類似於iterator.next()
object() 基類
property([fget[, fset[, fdel[, doc]]]]) 屬性訪問的包裝類，設置后可以通過c.x=value等來訪問setter和getter
reduce(function, iterable[, initializer]) 合並操作，從第一個開始是前兩個參數，然后是前兩個的結果與第三個合並進行處理，以此類推
reload(module) 重新加載模塊
setattr(object, name, value) 設置屬性值
repr(object) 將一個對象變幻為可打印的格式
slice（）
staticmethod 聲明靜態方法，是個注解
super(type[, object-or-type]) 引用父類
type(object) 返回該object的類型
vars([object]) 返回對象的變量，若無參數與dict()方法類似
bytearray([source [, encoding [, errors]]]) 返回一個byte數組
1、如果source為整數，則返回一個長度為source的初始化數組；
2、如果source為字符串，則按照指定的encoding將字符串轉換為字節序列；
3、如果source為可迭代類型，則元素必須為[0 ,255]中的整數；
4、如果source為與buffer接口一致的對象，則此對象也可以被用於初始化bytearray.
zip([iterable, ...]) 實在是沒有看懂，只是看到了矩陣的變幻方面
五、IO操作
file(filename [, mode [, bufsize]]) file類型的構造函數，作用為打開一個文件，如果文件不存在且mode為寫或追加時，文件將被創建。添加‘b’到mode參數中，將對文件以二進制形式操作。添加‘+’到mode參數中，將允許對文件同時進行讀寫操作
1、參數filename：文件名稱。
2、參數mode：'r'（讀）、'w'（寫）、'a'（追加）。
3、參數bufsize：如果為0表示不進行緩沖，如果為1表示進行行緩沖，如果是一個大於1的數表示緩沖區的大小 。
input([prompt]) 獲取用戶輸入
推薦使用raw_input，因為該函數將不會捕獲用戶的錯誤輸入
open(name[, mode[, buffering]]) 打開文件
與file有什么不同？推薦使用open
print 打印函數
raw_input([prompt]) 設置輸入，輸入都是作為字符串處理
具體每個函數的解析如下：
數學運算
abs：求數值的絕對值
>>> abs(-2)
2
divmod：返回兩個數值的商和余數
>>> divmod(5,2)
(2, 1)
>> divmod(5.5,2)
(2.0, 1.5)
max：返回可迭代對象中的元素中的最大值或者所有參數的最大值
>>> max(1,2,3) # 傳入3個參數 取3個中較大者
3
>>> max('1234') # 傳入1個可迭代對象，取其最大元素值
'4'
>>> max(-1,0) # 數值默認取數值較大者
0
>>> max(-1,0,key = abs) # 傳入了求絕對值函數，則參數都會進行求絕對值后再取較大者
-1
min：返回可迭代對象中的元素中的最小值或者所有參數的最小值
>>> min(1,2,3) # 傳入3個參數 取3個中較小者
1
>>> min('1234') # 傳入1個可迭代對象，取其最小元素值
'1'
>>> min(-1,-2) # 數值默認去數值較小者
-2
>>> min(-1,-2,key = abs) # 傳入了求絕對值函數，則參數都會進行求絕對值后再取較小者
-1
pow：返回兩個數值的冪運算值或其與指定整數的模值
>>> pow(2,3)
>>> 2**3
>>> pow(2,3,5)
>>> pow(2,3)%5
round：對浮點數進行四舍五入求值
>>> round(1.1314926,1)
1.1
>>> round(1.1314926,5)
1.13149
sum：對元素類型是數值的可迭代對象中的每個元素求和
# 傳入可迭代對象
>>> sum((1,2,3,4))
10
# 元素類型必須是數值型
>>> sum((1.5,2.5,3.5,4.5))
12.0
>>> sum((1,2,3,4),-10)
0
類型轉換
bool：根據傳入的參數的邏輯值創建一個新的布爾值
>>> bool() #未傳入參數
False
>>> bool(0) #數值0、空序列等值為False
False
>>> bool(1)
True
int：根據傳入的參數創建一個新的整數
>>> int() #不傳入參數時，得到結果0。
0
>>> int(3)
3
>>> int(3.6)
3
float：根據傳入的參數創建一個新的浮點數
>>> float() #不提供參數的時候，返回0.0
0.0
>>> float(3)
3.0
>>> float('3')
3.0
complex：根據傳入參數創建一個新的復數
>>> complex() #當兩個參數都不提供時，返回復數 0j。
0j
>>> complex('1+2j') #傳入字符串創建復數
(1+2j)
>>> complex(1,2) #傳入數值創建復數
(1+2j)
str：返回一個對象的字符串表現形式(給用戶)
>>> str()
''
>>> str(None)
'None'
>>> str('abc')
'abc'
>>> str(123)
'123'
bytearray：根據傳入的參數創建一個新的字節數組
>>> bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
bytes：根據傳入的參數創建一個新的不可變字節數組
>>> bytes('中文','utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
memoryview：根據傳入的參數創建一個新的內存查看對象
>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
ord：返回Unicode字符對應的整數
>>> ord('a')
97
chr：返回整數所對應的Unicode字符
>>> chr(97) #參數類型為整數
'a'
bin：將整數轉換成2進制字符串
>>> bin(3)
'0b11'
oct：將整數轉化成8進制數字符串
>>> oct(10)
'0o12'
hex：將整數轉換成16進制字符串
>>> hex(15)
'0xf'
tuple：根據傳入的參數創建一個新的元組
>>> tuple() #不傳入參數，創建空元組
()
>>> tuple('121') #傳入可迭代對象。使用其元素創建新的元組
('1', '2', '1')
list：根據傳入的參數創建一個新的列表
>>>list() # 不傳入參數，創建空列表
[]
>>> list('abcd') # 傳入可迭代對象，使用其元素創建新的列表
['a', 'b', 'c', 'd']
dict：根據傳入的參數創建一個新的字典
>>> dict() # 不傳入任何參數時，返回空字典。
{}
>>> dict(a = 1,b = 2) # 可以傳入鍵值對創建字典。
{'b': 2, 'a': 1}
>>> dict(zip(['a','b'],[1,2])) # 可以傳入映射函數創建字典。
{'b': 2, 'a': 1}
>>> dict((('a',1),('b',2))) # 可以傳入可迭代對象創建字典。
{'b': 2, 'a': 1}
set：根據傳入的參數創建一個新的集合
>>>set() # 不傳入參數，創建空集合
set()
>>> a = set(range(10)) # 傳入可迭代對象，創建集合
>>> a
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
frozenset：根據傳入的參數創建一個新的不可變集合
>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
enumerate：根據可迭代對象創建枚舉對象
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) #指定起始值
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
range：根據傳入的參數創建一個新的range對象
>>> a = range(10)
>>> b = range(1,10)
>>> c = range(1,10,3)
>>> a,b,c # 分別輸出a,b,c
(range(0, 10), range(1, 10), range(1, 10, 3))
>>> list(a),list(b),list(c) # 分別輸出a,b,c的元素
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])
>>>
iter：根據傳入的參數創建一個新的可迭代對象
>>> 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
slice：根據傳入的參數創建一個新的切片對象
>>> c1 = slice(5) # 定義c1
>>> c1
slice(None, 5, None)
>>> c2 = slice(2,5) # 定義c2
>>> c2
slice(2, 5, None)
>>> c3 = slice(1,10,3) # 定義c3
>>> c3
slice(1, 10, 3)
super：根據傳入的參數創建一個新的子類和父類關系的代理對象
#定義父類A
>>> class A(object):
def __init__(self):
print('A.__init__')
#定義子類B，繼承A
>>> class B(A):
def __init__(self):
print('B.__init__')
super().__init__()
#super調用父類方法
>>> b = B()
B.__init__
A.__init__
object：創建一個新的object對象
>>> a = object()
>>> a.name = 'kim' # 不能設置屬性
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
a.name = 'kim'
AttributeError: 'object' object has no attribute 'name'
序列操作
all：判斷可迭代對象的每個元素是否都為True值
>>> all([1,2]) #列表中每個元素邏輯值均為True，返回True
True
>>> all([0,1,2]) #列表中0的邏輯值為False，返回False
False
>>> all(()) #空元組
True
>>> all({}) #空字典
True
any：判斷可迭代對象的元素是否有為True值的元素
>>> any([0,1,2]) #列表元素有一個為True，則返回True
True
>>> any([0,0]) #列表元素全部為False，則返回False
False
>>> any([]) #空列表
False
>>> any({}) #空字典
False
filter：使用指定方法過濾可迭代對象的元素
>>> a = list(range(1,10)) #定義序列
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> def if_odd(x): #定義奇數判斷函數
return x%2==1
>>> list(filter(if_odd,a)) #篩選序列中的奇數
[1, 3, 5, 7, 9]
map：使用指定方法去作用傳入的每個可迭代對象的元素，生成新的可迭代對象
>>> a = map(ord,'abcd')
>>> a
<map object at 0x03994E50>
>>> list(a)
[97, 98, 99, 100]
next：返回可迭代對象中的下一個元素值
>>> 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
#傳入default參數后，如果可迭代對象還有元素沒有返回，則依次返回其元素值，如果所有元素已經返回，則返回default指定的默認值而不拋出StopIteration 異常
>>> next(a,'e')
'e'
>>> next(a,'e')
'e'
reversed：反轉序列生成新的可迭代對象
>>> a = reversed(range(10)) # 傳入range對象
>>> a # 類型變成迭代器
<range_iterator object at 0x035634E8>
>>> list(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
sorted：對可迭代對象進行排序，返回一個新的列表
>>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']
>>> sorted(a) # 默認按字符ascii碼排序
['A', 'B', 'a', 'b', 'c', 'd']
>>> sorted(a,key = str.lower) # 轉換成小寫后再排序，'a'和'A'值一樣，'b'和'B'值一樣
['a', 'A', 'b', 'B', 'c', 'd']
zip：聚合傳入的每個迭代器中相同位置的元素，返回一個新的元組類型迭代器
>>> x = [1,2,3] #長度3
>>> y = [4,5,6,7,8] #長度5
>>> list(zip(x,y)) # 取最小長度3
[(1, 4), (2, 5), (3, 6)]
對象操作
help：返回對象的幫助信息
>>> help(str)
Help on class str in module builtins:
class str(object)
| str(object='') -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
|
| Create a new string object from the given object. If encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error handler.
| Otherwise, returns the result of object.__str__() (if defined)
| or repr(object).
| encoding defaults to sys.getdefaultencoding().
| errors defaults to 'strict'.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
***************************
dir：返回對象或者當前作用域內的屬性列表
>>> 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']
id：返回對象的唯一標識符
>>> a = 'some text'
>>> id(a)
69228568
hash：獲取對象的哈希值
>>> hash('good good study')
1032709256
type：返回對象的類型，或者根據傳入的參數創建一個新的類型
>>> type(1) # 返回對象的類型
<class 'int'>
#使用type函數創建類型D，含有屬性InfoD
>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))
>>> d = D()
>>> d.InfoD
'some thing defined in D'
len：返回對象的長度
>>> len('abcd') # 字符串
>>> len(bytes('abcd','utf-8')) # 字節數組
>>> len((1,2,3,4)) # 元組
>>> len([1,2,3,4]) # 列表
>>> len(range(1,5)) # range對象
>>> len({'a':1,'b':2,'c':3,'d':4}) # 字典
>>> len({'a','b','c','d'}) # 集合
>>> len(frozenset('abcd')) #不可變集合
ascii：返回對象的可打印表字符串表現方式
>>> ascii(1)
'1'
>>> ascii('&')
"'&'"
>>> ascii(9000000)
'9000000'
>>> ascii('中文') #非ascii字符
"'\\u4e2d\\u6587'"
format：格式化顯示值
#字符串可以提供的參數 's' None
>>> format('some string','s')
'some string'
>>> format('some string')
'some string'
#整形數值可以提供的參數有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #轉換成二進制
'11'
>>> format(97,'c') #轉換unicode成字符
'a'
>>> format(11,'d') #轉換成10進制
'11'
>>> format(11,'o') #轉換成8進制
'13'
>>> format(11,'x') #轉換成16進制 小寫字母表示
'b'
>>> format(11,'X') #轉換成16進制 大寫字母表示
'B'
>>> format(11,'n') #和d一樣
'11'
>>> format(11) #默認和d一樣
'11'
#浮點數可以提供的參數有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科學計數法，默認保留6位小數
'3.141593e+08'
>>> format(314159267,'0.2e') #科學計數法，指定保留2位小數
'3.14e+08'
>>> format(314159267,'0.2E') #科學計數法，指定保留2位小數，采用大寫E表示
'3.14E+08'
>>> format(314159267,'f') #小數點計數法，默認保留6位小數
'314159267.000000'
>>> format(3.14159267000,'f') #小數點計數法，默認保留6位小數
'3.141593'
>>> format(3.14159267000,'0.8f') #小數點計數法，指定保留8位小數
'3.14159267'
>>> format(3.14159267000,'0.10f') #小數點計數法，指定保留10位小數
'3.1415926700'
>>> format(3.14e+1000000,'F') #小數點計數法，無窮大轉換成大小字母
'INF'
#g的格式化比較特殊，假設p為格式中指定的保留小數位數，先嘗試采用科學計數法格式化，得到冪指數exp，如果-4<=exp<p，則采用小數計數法，並保留p-1-exp位小數，否則按小數計數法計數，並按p-1保留小數位數
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留1位小數點
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留2位小數點
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，E使用大寫
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留0位小數點
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留1位小數點
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留2位小數點
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'
vars：返回當前作用域內的局部變量和其值組成的字典，或者返回對象的屬性列表
#作用於類實例
>>> class A(object):
pass
>>> a.__dict__
{}
>>> vars(a)
{}
>>> a.name = 'Kim'
>>> a.__dict__
{'name': 'Kim'}
>>> vars(a)
{'name': 'Kim'}
反射操作
__import__：動態導入模塊
index = __import__('index')
index.sayHello()
isinstance：判斷對象是否是類或者類型元組中任意類元素的實例
>>> isinstance(1,int)
True
>>> isinstance(1,str)
False
>>> isinstance(1,(int,str))
True
issubclass：判斷類是否是另外一個類或者類型元組中任意類元素的子類
>>> issubclass(bool,int)
True
>>> issubclass(bool,str)
False
>>> issubclass(bool,(str,int))
True
hasattr：檢查對象是否含有屬性
#定義類A
>>> class Student:
def __init__(self,name):
self.name = name
>>> s = Student('Aim')
>>> hasattr(s,'name') #a含有name屬性
True
>>> hasattr(s,'age') #a不含有age屬性
False
getattr：獲取對象的屬性值
#定義類Student
>>> class Student:
def __init__(self,name):
self.name = name
>>> getattr(s,'name') #存在屬性name
'Aim'
>>> getattr(s,'age',6) #不存在屬性age，但提供了默認值，返回默認值
>>> getattr(s,'age') #不存在屬性age，未提供默認值，調用報錯
Traceback (most recent call last):
File "<pyshell#17>", line 1, in <module>
getattr(s,'age')
AttributeError: 'Stduent' object has no attribute 'age'
setattr：設置對象的屬性值
>>> class Student:
def __init__(self,name):
self.name = name
>>> a = Student('Kim')
>>> a.name
'Kim'
>>> setattr(a,'name','Bob')
>>> a.name
'Bob'
delattr：刪除對象的屬性
#定義類A
>>> class A:
def __init__(self,name):
self.name = name
def sayHello(self):
print('hello',self.name)
#測試屬性和方法
>>> a.name
'小麥'
>>> a.sayHello()
hello 小麥
#刪除屬性
>>> delattr(a,'name')
>>> a.name
Traceback (most recent call last):
File "<pyshell#47>", line 1, in <module>
a.name
AttributeError: 'A' object has no attribute 'name'
callable：檢測對象是否可被調用
>>> class B: #定義類B
def __call__(self):
print('instances are callable now.')
>>> callable(B) #類B是可調用對象
True
>>> b = B() #調用類B
>>> callable(b) #實例b是可調用對象
True
>>> b() #調用實例b成功
instances are callable now.
變量操作
globals：返回當前作用域內的全局變量和其值組成的字典
>>> globals()
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
>>> a = 1
>>> globals() #多了一個a
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
locals：返回當前作用域內的局部變量和其值組成的字典
>>> def f():
print('before define a ')
print(locals()) #作用域內無變量
a = 1
print('after define a')
print(locals()) #作用域內有一個a變量，值為1
>>> f
<function f at 0x03D40588>
>>> f()
before define a
{}
after define a
{'a': 1}
交互操作
print：向標准輸出對象打印輸出
>>> print(1,2,3)
1 2 3
>>> print(1,2,3,sep = '+')
1+2+3
>>> print(1,2,3,sep = '+',end = '=?')
1+2+3=?
input：讀取用戶輸入值
>>> s = input('please input your name:')
please input your name:Ain
>>> s
'Ain'
文件操作
open：使用指定的模式和編碼打開文件，返回文件讀寫對象
# t為文本讀寫，b為二進制讀寫
>>> a = open('test.txt','rt')
>>> a.read()
'some text'
>>> a.close()
編譯執行
compile：將字符串編譯為代碼或者AST對象，使之能夠通過exec語句來執行或者eval進行求值
>>> #流程語句使用exec
>>> code1 = 'for i in range(0,10): print (i)'
>>> compile1 = compile(code1,'','exec')
>>> exec (compile1)
0
1
2
3
4
5
6
7
8
9
>>> #簡單求值表達式用eval
>>> code2 = '1 + 2 + 3 + 4'
>>> compile2 = compile(code2,'','eval')
>>> eval(compile2)
10
eval：執行動態表達式求值
>>> eval('1+2+3+4')
10
exec：執行動態語句塊
>>> exec('a=1+2') #執行語句
>>> a
3
repr：返回一個對象的字符串表現形式(給解釋器)
>>> a = 'some text'
>>> str(a)
'some text'
>>> repr(a)
"'some text'"
裝飾器
property：標示屬性的裝飾器
>>> 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'
classmethod：標示方法為類方法的裝飾器
>>> class C:
@classmethod
def f(cls,arg1):
print(cls)
print(arg1)
>>> C.f('類對象調用類方法')
<class '__main__.C'>
類對象調用類方法
>>> c = C()
>>> c.f('類實例對象調用類方法')
<class '__main__.C'>
類實例對象調用類方法
staticmethod：標示方法為靜態方法的裝飾器
# 使用裝飾器定義靜態方法
>>> 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
本文轉