一、 數字
1 求絕對值
絕對值或複數的模
In［1］：abs（-6）
Out［1］：6
2 進位制轉化
十進位制轉換為二進位制：
In［2］：bin（10）
Out［2］：‘0b1010’
十進位制轉換為八進位制：
In［3］：oct（9）
Out［3］：‘0o11’
十進位制轉換為十六進位制：
In［4］：hex（15）
Out［4］：‘0xf’
3 整數和ASCII互轉
十進位制整數對應的
In［1］：chr（65）
Out［1］：‘A’
檢視某個對應的十進位制數
In［1］：ord（‘A’）
Out［1］：65
4 元素都為真檢查
所有元素都為真，返回 ，否則為
In［5］：all（［1，，3，6］）
Out［5］：False
In［6］：all（［1，2，3］）
Out［6］：True
5 元素至少一個為真檢查
至少有一個元素為真返回，否則
In［7］：any（［，，，［］］）
Out［7］：False
In［8］：any（［，，1］）
Out［8］：True
6 判斷是真是假
測試一個物件是True， 還是False
In［9］：bool（［，，］）
Out［9］：True
In［10］：bool（［］）
Out［10］：False
In［11］：bool（［1，，1］）
Out［11］：True
7 建立複數
建立一個複數
In［1］：complex（1，2）
Out［1］： （1+2j）
8 取商和餘數
分別取商和餘數
In［1］：divmod（10，3）
Out［1］： （3，1）
9 轉為浮點型別
In［1］：float（3）
Out［1］：3。0
如果不能轉化為浮點數，則會報：
In［2］：float（‘a’）
# ValueError： could not convert string to float： ‘a’
10 轉為整型
In［1］：int（‘12’，16）
Out［1］：18
11 次冪
base為底的exp次冪，如果mod給出，取餘
In［1］：pow（3，2，4）
Out［1］：1
12 四捨五入
四捨五入，代表小數點後保留幾位：
In［11］：round（10。0222222，3）
Out［11］：10。022
In［12］：round（10。05，1）
Out［12］：10。1
13 鏈式比較
i=3
print（1
print（1
二、 字串
14 字串轉位元組
字串轉換為位元組型別
In［12］： s=“apple”
In［13］：bytes（s，encoding=‘utf-8’）
Out［13］：b‘apple’
15 任意物件轉為字串
In［14］： i=100
In［15］：str（i）
Out［15］：‘100’
In［16］：str（［］）
Out［16］：‘［］’
In［17］：str（tuple（））
Out［17］：‘（）’
16 執行字串表示的程式碼
將字串編譯成python能識別或可執行的程式碼，也可以將文字讀成字串再編譯。
In［1］： s=“print（‘helloworld’）”
In［2］： r=compile（s，“”，“exec”）
In［3］： r
Out［3］：
In［4］：exec（r）
helloworld
17 計算表示式
將字串str 當成有效的表示式來求值並返回計算結果取出字串中內容
In［1］： s=“1 + 3 +5”
。。。：eval（s）
。。。：
Out［1］：9
18 字串格式化
三、 函式
19 拿來就用的排序函式
排序：
In［1］： a=［1，4，2，3，1］
In［2］：sorted（a，reverse=True）
Out［2］： ［4，3，2，1，1］
In［3］： a=［{‘name’：‘xiaoming’，‘age’：18，‘gender’：‘male’}，{‘name’：‘
。。。： xiaohong’，‘age’：20，‘gender’：‘female’}］
In［4］：sorted（a，key=lambdax： x［‘age’］，reverse=False）
Out［4］：
［{‘name’：‘xiaoming’，‘age’：18，‘gender’：‘male’}，
{‘name’：‘xiaohong’，‘age’：20，‘gender’：‘female’}］
20 求和函式
求和：
In［181］： a=［1，4，2，3，1］
In［182］：sum（a）
Out［182］：11
In［185］：sum（a，10）#求和的初始值為10
Out［185］：21
21 nonlocal用於內嵌函式中
關鍵詞常用於函式巢狀中，宣告變數i為非區域性變數；如果不宣告，表明i為函式內的區域性變數，因為在引用時，未被宣告，所以會報的錯誤。
defexcepter（f）：
i=
t1=time。time（）
defwrapper（）：
try：
f（）
exceptExceptionase：
nonlocali
i+=1
print（f‘：’）
t2=time。time（）
ifi==n：
print（f‘spending time：{round（t2-t1，2）}’）
returnwrapper
22 global 宣告全域性變數
先回答為什麼要有，一個變數被多個函式引用，想讓全域性變數被所有函式共享。有的夥伴可能會想這還不簡單，這樣寫：
i=5
deff（）：
print（i）
defg（）：
print（i）
pass
f（）
g（）
f和g兩個函式都能共享變數，程式沒有報錯，所以他們依然不明白為什麼要用。
但是，如果我想要有個函式對遞增，這樣：
defh（）：
i+=1
h（）
此時執行程式，bang， 出錯了！丟擲異常：，原來編譯器在解釋時會把i解析為函式內的區域性變數，很顯然在此函式內，編譯器找不到對變數i的定義，所以會報錯。
就是為解決此問題而被提出，在函式h內，顯式地告訴編譯器i為全域性變數，然後編譯器會在函式外面尋找i的定義，執行完後，i還為全域性變數，值加1：
i=
defh（）：
globali
i+=1
h（）
print（i）
23 交換兩元素
defswap（a， b）：
returnb， a
print（swap（1，））# （0，1）
24 操作函式物件
In［31］： deff（）：
。。。：print（‘i\’m f‘）
。。。：
In［32］：defg（）：
。。。：print（’i\‘m g’）
。。。：
In［33］： ［f，g］［1］（）
i‘m g
建立函式物件的list，根據想要呼叫的index，方便統一呼叫。
25 生成逆序序列
list（range（10，-1，-1））# ［10， 9， 8， 7， 6， 5， 4， 3， 2， 1， 0］
第三個引數為負時，表示從第一個引數開始遞減，終止到第二個引數（不包括此邊界）
26 函式的五類引數使用例子
python五類引數：位置引數，關鍵字引數，預設引數，可變位置或關鍵字引數的使用。
deff（a，*b，c=10，**d）：
print（f’a：，b：，c：，d：‘）
預設引數不能位於可變關鍵字引數後。
呼叫f：
In［10］：f（1，2，5，width=10，height=20）
a：1，b：（2，5），c：10，d：{’width‘：10，’height‘：20}
可變位置引數實參後被解析為元組；而c取得預設值10； d被解析為字典。
再次呼叫f：
In［11］：f（a=1，c=12）
a：1，b：（），c：12，d：{}
a=1傳入時a就是關鍵字引數，b，d都未傳值，c被傳入12，而非預設值。
注意觀察引數a， 既可以，也可以其可讀性比第一種更好，建議使用。如果要強制使用，需要在前面新增一個
星號
：
deff（*，a，**b）：
print（f’a：，b：‘）
此時f（1）呼叫，將會報錯：
只能才能OK。
說明前面的發揮作用，它變為只能傳入關鍵字引數，那麼如何檢視這個引數的型別呢？藉助python的模組：
In［22］： for name，valinsignature（f）。parameters。items（）：
。。。：print（name，val。kind）
。。。：
aKEYWORD_ONLY
bVAR_KEYWORD
可看到引數的型別為，也就是僅僅為關鍵字引數。
但是，如果f定義為：
deff（a，*b）：
print（f’a：，b：‘）
檢視引數型別：
In［24］： for name，valinsignature（f）。parameters。items（）：
。。。：print（name，val。kind）
。。。：
aPOSITIONAL_OR_KEYWORD
bVAR_POSITIONAL
可以看到引數a既可以是位置引數也可是關鍵字引數。
27 使用slice物件
生成關於蛋糕的序列cake1：
In［1］： cake1=list（range（5，，-1））
In［2］： b=cake1［1：10：2］
In［3］： b
Out［3］： ［4，2］
In［4］： cake1
Out［4］： ［5，4，3，2，1］
再生成一個序列：
In［5］： from randomimportrandint
。。。： cake2=［randint（1，100）for_inrange（100）］
。。。：# 同樣以間隔為2切前10個元素，得到切片d
。。。： d=cake2［1：10：2］
In［6］： d
Out［6］： ［75，33，63，93，15］
你看，我們使用同一種切法，分別切開兩個蛋糕cake1，cake2。 後來發現這種切法極為經典，又拿它去切更多的容器物件。
那麼，為什麼不把這種切法封裝為一個物件呢？於是就有了slice物件。
定義slice物件極為簡單，如把上面的切法定義成slice物件：
perfect_cake_slice_way=slice（1，10，2）
#去切cake1
cake1_slice=cake1［perfect_cake_slice_way］
cake2_slice=cake2［perfect_cake_slice_way］
In［11］： cake1_slice
Out［11］： ［4，2］
In［12］： cake2_slice
Out［12］： ［75，33，63，93，15］
與上面的結果一致。
對於逆向序列切片，slice物件一樣可行：
a=［1，3，5，7，9，，3，5，7］
a_=a［5：1：-1］
named_slice=slice（5，1，-1）
a_slice=a［named_slice］
In［14］： a_
Out［14］： ［，9，7，5］
In［15］： a_slice
Out［15］： ［，9，7，5］
頻繁使用同一切片的操作可使用slice物件抽出來，複用的同時還能提高程式碼可讀性。
28 lambda 函式的動畫演示
有些讀者反映，函式不太會用，問我能不能解釋一下。
比如，下面求這個 函式：
defmax_len（*lists）：
returnmax（*lists， key=lambdav：len（v））
有兩點疑惑：
引數的取值？
函式有返回值嗎？如果有，返回值是多少？
呼叫上面函式，求出以下三個最長的列表：
r=max_len（［1，2，3］， ［4，5，6，7］， ［8］）
print（f’更長的列表是‘）
程式完整執行過程，動畫演示如下：
結論：
引數v的可能取值為，也就是 的一個元素。
函式返回值，等於冒號後表示式的返回值。
四、 資料結構
29 轉為字典
建立資料字典
In［1］：dict（）
Out［1］： {}
In［2］：dict（a=’a‘，b=’b‘）
Out［2］： {’a‘：’a‘，’b‘：’b‘}
In［3］：dict（zip（［’a‘，’b‘］，［1，2］））
Out［3］： {’a‘：1，’b‘：2}
In［4］：dict（［（’a‘，1），（’b‘，2）］）
Out［4］： {’a‘：1，’b‘：2}
30 凍結集合
建立一個不可修改的集合。
In［1］：frozenset（［1，1，3，2，3］）
Out［1］：frozenset（{1，2，3}）
因為不可修改，所以沒有像那樣的和方法
31 轉為集合型別
返回一個set物件，集合內不允許有重複元素：
In［159］： a=［1，4，2，3，1］
In［160］：set（a）
Out［160］： {1，2，3，4}
32 轉為切片物件
classslice（start，stop［，step］）
返回一個表示由 range（start， stop， step） 所指定索引集的 slice物件，它讓程式碼可讀性、可維護性變好。
In［1］： a=［1，4，2，3，1］
In［2］： my_slice_meaning=slice（，5，2）
In［3］： a［my_slice_meaning］
Out［3］： ［1，2，1］
33 轉元組
將物件轉為一個不可變的序列型別
In［16］： i_am_list=［1，3，5］
In［17］： i_am_tuple=tuple（i_am_list）
In［18］： i_am_tuple
Out［18］： （1，3，5）
五、 類和物件
34 是否可呼叫
檢查物件是否可被呼叫
In［1］：callable（str）
Out［1］：True
In［2］：callable（int）
Out［2］：True
In［18］： classStudent（）：
。。。：def__init__（self，id，name）：
。。。： self。id=id
。。。： self。name=name
。。。： def__repr__（self）：
。。。：return’id = ‘+self。id+’， name = ‘+self。name
。。。
In［19］： xiaoming=Student（’001‘，’xiaoming‘）
In［20］：callable（xiaoming）
Out［20］：False
如果能呼叫， 需要重寫類的方法：
In［1］： classStudent（）：
。。。：def__init__（self，id，name）：
。。。： self。id=id
。。。： self。name=name
。。。： def__repr__（self）：
。。。：return’id = ‘+self。id+’， name = ‘+self。name
。。。： def__call__（self）：
。。。：print（’I can be called‘）
。。。：print（f’my name is‘）
。。。：
In［2］： t=Student（’001‘，’xiaoming‘）
In［3］：t（）
Ican be called
my nameisxiaoming
35 ascii 展示物件
呼叫物件的 方法，獲得該方法的返回值，如下例子返回值為字串
>>>classStudent（）：
def__init__（self，id，name）：
self。id=id
self。name=name
def__repr__（self）：
return’id = ‘+self。id+’， name = ‘+self。name
呼叫：
>>>xiaoming=Student（id=’1‘，name=’xiaoming‘）
>>>xiaoming
id=1， name=xiaoming
>>>ascii（xiaoming）
’id = 1， name = xiaoming‘
36 類方法
裝飾器對應的函式不需要例項化，不需要 引數，但第一個引數需要是表示自身類的 cls 引數，可以來呼叫類的屬性，類的方法，例項化物件等。
In［1］： classStudent（）：
。。。：def__init__（self，id，name）：
。。。： self。id=id
。。。： self。name=name
。。。： def__repr__（self）：
。。。：return’id = ‘+self。id+’， name = ‘+self。name
。。。： @classmethod
。。。： deff（cls）：
。。。：print（cls）
37 動態刪除屬性
刪除物件的屬性
In［1］：delattr（xiaoming，’id‘）
In［2］：hasattr（xiaoming，’id‘）
Out［2］：False
38 一鍵檢視物件所有方法
不帶引數時返回當前範圍內的變數、方法和定義的型別列表；帶引數時返回引數的屬性，方法列表。
In［96］：dir（xiaoming）
Out［96］：
［’__class__‘，
’__delattr__‘，
’__dict__‘，
’__dir__‘，
’__doc__‘，
’__eq__‘，
’__format__‘，
’__ge__‘，
’__getattribute__‘，
’__gt__‘，
’__hash__‘，
’__init__‘，
’__init_subclass__‘，
’__le__‘，
’__lt__‘，
’__module__‘，
’__ne__‘，
’__new__‘，
’__reduce__‘，
’__reduce_ex__‘，
’__repr__‘，
’__setattr__‘，
’__sizeof__‘，
’__str__‘，
’__subclasshook__‘，
’__weakref__‘，
’name‘］
39 動態獲取物件屬性
獲取物件的屬性
In［1］： classStudent（）：
。。。：def__init__（self，id，name）：
。。。： self。id=id
。。。： self。name=name
。。。： def__repr__（self）：
。。。：return’id = ‘+self。id+’， name = ‘+self。name
In［2］： xiaoming=Student（id=’001‘，name=’xiaoming‘）
In［3］：getattr（xiaoming，’name‘）# 獲取xiaoming這個例項的name屬性值
Out［3］：’xiaoming‘
40 物件是否有這個屬性
In［1］： classStudent（）：
。。。：def__init__（self，id，name）：
。。。： self。id=id
。。。： self。name=name
。。。： def__repr__（self）：
。。。：return’id = ‘+self。id+’， name = ‘+self。name
In［2］： xiaoming=Student（id=’001‘，name=’xiaoming‘）
In［3］：hasattr（xiaoming，’name‘）
Out［3］：True
In［4］：hasattr（xiaoming，’address‘）
Out［4］：False
41 物件門牌號
返回物件的記憶體地址
In［1］：id（xiaoming）
Out［1］：98234208
42 isinstance
判斷object是否為類classinfo的例項，是返回true
In［1］： classStudent（）：
。。。：def__init__（self，id，name）：
。。。： self。id=id
。。。： self。name=name
。。。： def__repr__（self）：
。。。：return’id = ‘+self。id+’， name = ‘+self。name
In［2］： xiaoming=Student（id=’001‘，name=’xiaoming‘）
In［3］：isinstance（xiaoming，Student）
Out［3］：True
43 父子關係鑑定
In［1］： classundergraduate（Student）：
。。。：defstudyClass（self）：
。。。： pass
。。。： defattendActivity（self）：
。。。： pass
In［2］：issubclass（undergraduate，Student）
Out［2］：True
In［3］：issubclass（object，Student）
Out［3］：False
In［4］：issubclass（Student，object）
Out［4］：True
如果class是classinfo元組中某個元素的子類，也會返回True
In［1］：issubclass（int，（int，float））
Out［1］：True
44 所有物件之根
object 是所有類的基類
In［1］： o=object（）
In［2］：type（o）
Out［2］： object
45 建立屬性的兩種方式
返回 property 屬性，典型的用法：
classC：
def__init__（self）：
self。_x=None
defgetx（self）：
returnself。_x
defsetx（self， value）：
self。_x=value
defdelx（self）：
delself。_x
# 使用property類建立 property 屬性
x=property（getx， setx， delx，“I’m the ‘x’ property。”）
使用python裝飾器，實現與上完全一樣的效果程式碼：
46 檢視物件型別
class type（name， bases， dict）
傳入一個引數時，返回 object 的型別：
In［1］： classStudent（）：
。。。：def__init__（self，id，name）：
。。。： self。id=id
。。。： self。name=name
。。。： def__repr__（self）：
。。。：return‘id = ’+self。id+‘， name = ’+self。name
。。。：
In［2］： xiaoming=Student（id=‘001’，name=‘xiaoming’）
In［3］：type（xiaoming）
Out［3］： __main__。Student
In［4］：type（tuple（））
Out［4］： tuple
47 元類
， ， 都是學生，這類群體叫做 。
Python 定義類的常見方法，使用關鍵字
In［36］： classStudent（object）：
。。。： pass
， ， 是類的例項，則：
xiaoming=Student（）
xiaohong=Student（）
xiaozhang=Student（）
建立後，xiaoming 的 屬性，返回的便是 類
In［38］： xiaoming。__class__
Out［38］： __main__。Student
問題在於， 類有 屬性，如果有，返回的又是什麼？
In［39］： xiaoming。__class__。__class__
Out［39］： type
哇，程式沒報錯，返回
那麼，我們不妨猜測： 類，型別就是
換句話說，類就是一個物件，它的型別就是
所以，Python 中一切皆物件，類也是物件
Python 中，將描述 類的類被稱為：元類。
按照此邏輯延伸，描述元類的類被稱為：元元類，開玩笑了~ 描述元類的類也被稱為元類。
聰明的朋友會問了，既然 類可建立例項，那麼 類可建立例項嗎？如果能，它建立的例項就叫：類 了。你們真聰明！
說對了， 類一定能建立例項，比如 類了。
In［40］：Student=type（‘Student’，（），{}）
In［41］：Student
Out［41］： __main__。Student
它與使用 關鍵字建立的 類一模一樣。
Python 的類，因為又是物件，所以和 ， 物件操作相似。支援：
賦值
複製
新增屬性
作為函式引數
In［43］：StudentMirror=Student# 類直接賦值 # 類直接賦值
In［44］：Student。class_property=‘class_property’# 新增類屬性
In［46］：hasattr（Student，‘class_property’）
Out［46］：True
元類，確實使用不是那麼多，也許先了解這些，就能應付一些場合。就連 Python 界的領袖 都說：
“元類就是深度的魔法，99%的使用者應該根本不必為此操心。
六、工具
48 列舉物件
返回一個可以列舉的物件，該物件的方法將返回一個元組。
In［1］： s=［“a”，“b”，“c”］
。。。： for i ，vinenumerate（s，1）：
。。。：print（i，v）
。。。：
1a
2b
3c
49 檢視變數所佔位元組數
In［1］： import sys
In［2］： a={‘a’：1，‘b’：2。0}
In［3］： sys。getsizeof（a）# 佔用240個位元組
Out［3］：240
50 過濾器
在函式中設定過濾條件，迭代元素，保留返回值為的元素：
In［1］： fil=filter（lambdax： x>10，［1，11，2，45，7，6，13］）
In［2］：list（fil）
Out［2］： ［11，45，13］
51 返回物件的雜湊值
返回物件的雜湊值，值得注意的是自定義的例項都是可雜湊的，， ， 等可變物件都是不可雜湊的（unhashable）
In［1］：hash（xiaoming）
Out［1］：6139638
In［2］：hash（［1，2，3］）
# TypeError： unhashable type： ‘list’
52 一鍵幫助
返回物件的幫助文件
In［1］：help（xiaoming）
HelponStudentinmodule __main__ object：
classStudent（builtins。object）
|Methodsdefined here：
|
|__init__（self， id， name）
|
|__repr__（self）
|
|Datadescriptors defined here：
|
|__dict__
|dictionaryforinstancevariables（if defined）
|
|__weakref__
|list of weak references to theobject（if defined）
53 獲取使用者輸入
獲取使用者輸入內容
In［1］：input（）
aa
Out［1］：‘aa’
54 建立迭代器型別
使用， 返回一個可迭代物件， sentinel可省略（一旦迭代到此元素，立即終止）
In［1］： lst=［1，3，5］
In［2］： for iiniter（lst）：
。。。：print（i）
。。。：
1
3
5
In［1］： classTestIter（object）：
。。。：def__init__（self）：
。。。： self。l=［1，3，2，3，4，5］
。。。： self。i=iter（self。l）
。。。： def__call__（self）：#定義了__call__方法的類的例項是可呼叫的
。。。： item=next（self。i）
。。。：print（“__call__ is called，fowhich would return”，item）
。。。： return item
。。。： def__iter__（self）：#支援迭代協議（即定義有__iter__（）函式）
。。。：print（“__iter__ is called！！”）
。。。：returniter（self。l）
In［2］： t=TestIter（）
In［3］：t（）# 因為實現了__call__，所以t例項能被呼叫
__call__iscalled，which wouldreturn1
Out［3］：1
In［4］： for einTestIter（）：# 因為實現了__iter__方法，所以t能被迭代
。。。：print（e）
。。。：
__iter__iscalled！！
1
3
2
3
4
5
55 開啟檔案
返回檔案物件
In［1］： fo=open（‘D：/a。txt’，mode=‘r’， encoding=‘utf-8’）
In［2］： fo。read（）
Out［2］：‘\ufefflife is not so long，\nI use Python to play。’
mode取值表：
56 建立range序列
range（stop）
range（start， stop［，step］）
生成一個不可變序列：
In［1］：range（11）
Out［1］：range（，11）
In［2］：range（，11，1）
Out［2］：range（，11）
57 反向迭代器
In［1］： rev=reversed（［1，4，2，3，1］）
In［2］： for iinrev：
。。。：print（i）
。。。：
1
3
2
4
1
58 聚合迭代器
建立一個聚合了來自每個可迭代物件中的元素的迭代器：
In［1］： x=［3，2，1］
In［2］： y=［4，5，6］
In［3］：list（zip（y，x））
Out［3］： ［（4，3）， （5，2）， （6，1）］
In［4］： a=range（5）
In［5］： b=list（‘abcde’）
In［6］： b
Out［6］： ［‘a’，‘b’，‘c’，‘d’，‘e’］
In［7］： ［str（y）+str（x）forx，yinzip（a，b）］
Out［7］： ［‘a0’，‘b1’，‘c2’，‘d3’，‘e4’］
59 鏈式操作
fromoperatorimport（add， sub）
defadd_or_sub（a， b， oper）：
return（addifoper==‘+’elsesub）（a， b）
add_or_sub（1，2，‘-’）# -1
60 物件序列化
物件序列化，是指將記憶體中的物件轉化為可儲存或傳輸的過程。很多場景，直接一個類物件，傳輸不方便。
但是，當物件序列化後，就會更加方便，因為約定俗成的，介面間的呼叫或者發起的 web 請求，一般使用 json 串傳輸。
實際使用中，一般對類物件序列化。先建立一個 Student 型別，並建立兩個例項。
classStudent（）：
def__init__（self，**args）：
self。ids=args［‘ids’］
self。name=args［‘name’］
self。address=args［‘address’］
xiaoming=Student（ids=1，name=‘xiaoming’，address=‘北京’）
xiaohong=Student（ids=2，name=‘xiaohong’，address=‘南京’）
匯入 json 模組，呼叫 dump 方法，就會將列表物件 ［xiaoming，xiaohong］，序列化到檔案 json。txt 中。
importjson
withopen（‘json。txt’，‘w’）asf：
json。dump（［xiaoming，xiaohong］， f， default=lambdaobj： obj。__dict__， ensure_ascii=False， indent=2， sort_keys=True）
生成的檔案內容，如下：
加入知識星球
【我們談論資料科學】
400+
小夥伴一起學習！
