一、變量賦值及命名規則
① 聲明一個變量及賦值

            1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 # _author_soloLi
4 name1="solo"
5 name2=name1
6 print(name1,name2)
7 name1 = "hehe"
8 print(name1,name2)
          

#name1的值為hehe，name2的值為solo

②?變量命名的規則

            1 1、變量名只能是 字母、數字或下劃線的任意組合
2 2、變量名的第一個字符不能是數字
3 3、以下關鍵字不能聲明為變量名['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global','if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
          

?

二、字符編碼
python解釋器在加載 .py 文件中的代碼時，會對內容進行編碼（默認ascill）

ASCII： 最多只能用 8位來表示（一個字節），即：2**8 = 256，所以，ASCII碼最多只能表示 256 個符號。顯然ASCII碼無法將世界上的各種文字和符號全部表示。

Unicode： 它為每種語言中的每個字符設定了統一并且唯一的二進制編碼，規定雖有的字符和符號最少由 16 位來表示（2個字節），即：2 **16 = 65536，注：此處說的的是最少2個字節，可能更多。

UTF-8： 是對Unicode編碼的壓縮和優化，他不再使用最少使用2個字節，而是將所有的字符和符號進行分類：ascii碼中的內容用1個字節保存、歐洲的字符用2個字節保存，東亞的字符用3個字節保存...
注：python2.x版本，默認支持的字符編碼為ASCll python3.x版本，默認支持的是Unicode，不用聲明字符編碼可以直接顯示中文。

?擴展：字符編碼和轉碼，bytes和str區別

? ? Python?3最重要的新特性大概要算是對文本和二進制數據作了更為清晰的區分。文本總是Unicode，由str類型表示，二進制數據則由bytes類型表示。Python?3不會以任意隱式的方式混用str和bytes（類似int和long之間自動轉換），正是這使得兩者的區分特別清晰。你不能拼接字符串和字節包，也無法在字節包里搜索字符串（反之亦然），也不能將字符串傳入參數為字節包的函數（反之亦然）。這是件好事。不管怎樣，字符串和字節包之間的界線是必然的，下面的圖解非常重要，務請牢記于心：

字符串可以編碼成字節包，而字節包可以解碼成字符串：

?View Code

為什么要進行編碼和轉碼？
　　由于每個國家電腦的字符編碼格式不統一（列中國：GBK），同一款軟件放到不同國家的電腦上會出現亂碼的情況，出現這種情況如何解決呢？！ 當然由于所有國家的電腦都支持Unicode萬國碼，那么我們可以把Unicode為跳板，先把字符編碼轉換為Unicode，在把Unicode轉換為另一個國家的字符編碼（例韓國），則不會出現亂碼的情況。當然這里只是轉編碼集并不是翻譯成韓文不要弄混了。

① Python3.0進行編碼轉換（默認Unicode編碼）

?View Code

② Python2.0中的編碼轉換（默認ascii編碼）

?View Code

?

三、用戶交互及字符串拼接

?View Code

對比分析：
1、% ：無法同時傳遞一個變量和元組，又是要加（）來保證不拋出typeerror異常
2、+ ：每增加一個一個+就會開辟一塊新的內存空間
3、.fomat ：不會出現上述問題，有時使用為了兼容Python2版本。如使用logging庫

?

四、循環語句（if、while、for、三元運算）

?View Code

?

五、基本數據類型

?【總結】常見的數據類型有哪些？主要操作方法有哪些？

一、整型
如： 18、73、84
類型常用功能：

?View Code

更多功能：

?View Code

二、長整型
如：2147483649、9223372036854775807
類型常用功能：

?View Code

更多功能：

?View Code

注：跟C語言不同，Python的長整數沒有指定位寬，即：Python沒有限制長整數數值的大小，但實際上由于機器內存有限，我們使用的長整數數值不可能無限大。自從Python2.2起，如果整數發生溢出，Python會自動將整數數據轉換為長整數，所以如今在長整數數據后面不加字母L也不會導致嚴重后果

三、浮點型
如：3.14、2.88

類型常用功能：

?View Code

更多功能：

?View Code

四、字符串
如：'wupeiqi'、'alex'、'solo'

類型常用功能：

?View Code

更多功能：

?View Code

五、列表
如：[11,22,33,44,55]、['wupeiqi', 'alex','solo']
1、創建列表：

?View Code

2、列表類常用功能：
①?切片?

?View Code

② 追加

?View Code

③ 插入

?View Code

④ 修改

?View Code

⑤ 刪除

?View Code

⑥ 擴展

?View Code

⑦ 拷貝

?View Code

⑧ 統計

?View Code

⑨ 排序和翻轉

?View Code

⑩ 獲取下標

?View Code

六、元組

如：(11,22,33,44,55)、('wupeiqi',?'alex','lzl')

1、創建元組：

?View Code

2、元組類常用功能：

?View Code

七、字典 無序
如：{'name': 'wupeiqi', 'age': 18} 、{'host': 'solo.solo.solo.solo', 'port': 80}
注：字典一種key：value 的數據類型，也稱鍵值對。字典dict是無序的，key值必須是唯一的，不能有重復。循環時，默認循環的是key
?1、創建字典

?View Code

2、字典類常用功能：

① 增加

?View Code

② 修改

?View Code

③ 刪除

?View Code

④ 查找value值

?View Code

⑤ 字典多級嵌套

?View Code

⑥ 循環

?View Code

八、集合?
如：{'solo', 33, 'alex', 22, 'eric', 'wupeiqi', 11}
注：集合是一個無序的，不重復的數據組合。去重性，把一個列表變成集合，就自動去重了。關系測試，測試兩組數據之前的交集、差集、并集
1、創建集合

?View Code

2、集合類常用功能
①?添加

?View Code

② 刪除

?View Code

3、集合關系測試
①?交集

?View Code

② 并集

?View Code

③ 差集

?View Code

④ 子集、父集

?View Code

⑤ 對稱差集

?View Code

⑥ 運算符做關系測試

?View Code

?

六、模塊初識

Python有大量的模塊，從而使得開發Python程序非常簡潔。類庫有包括三中：
① 、Python內部提供的模塊
②、業內開源的模塊
③、程序員自己開發的模塊：Python腳本的名字不要與模塊名相同

1、sys模塊（系統內置）
① sys.argv 用來捕獲執行python腳本時傳入的參數
② sys.stdin 標準信息輸入
③ sys.stdout 標準定向輸出
④ sys.stdout.flush 強制刷新標準輸出緩存

?View Code

2、os模塊（與系統進行交互）
① os.dir、os.popen調用當前系統命令

3、platform模塊（識別當前運行的系統）

?

七、運算符
1、算數運算：

2、比較運算：

3、賦值運算：

4、邏輯運算：

5、成員運算：

6、身份運算：

7、位運算：

8、運算符優先級：

?

八、深淺拷貝剖析
1、對象賦值 （創建列表變量Alex，變量包含子列表，通過變量Alex給變量solo賦值，然后對變量Alex的元素進行修改，此時solo會有什么變化呢？）

?View Code

初始條件：? Alex ?= ["Alex", 28, ["Python", "C#", "JavaScript"]]
對象賦值： solo = Alex ? ? ? ? ? #直接賦值
對象賦值結果： solo ?= [ "Alex" , 28, ["Python", "C#", "JavaScript"]]
對象賦值時是進行對象引用（內存地址）的傳遞，被賦值的變量并沒有開辟新內存，兩個變量共用一個內存地址

修改對象賦值：solo = [ 'Mr.Wu' , 28, ['Python', 'C#', 'JavaScript',? 'CSS' ]]
str是不可變類型，所以當修改元素Alex為Mr.Wu時，內存地址發生改變；list是可變類型，元素['Python', 'C#', 'JavaScript', 'CSS']修改完后，內存地址沒有改變

2、淺拷貝 （創建列表變量Alex，變量包含子列表，通過copy模塊的淺拷貝函數copy()對變量Alex進行拷貝，當對Alex進行操作時，此時solo會如何變化？）

?View Code

初始條件： ?Alex ?= ["Alex", 28, ["Python", "C#", "JavaScript"]]
淺拷貝： solo = copy.copy(Alex) ? ? ? ? #通過copy模塊里面的淺拷貝函數copy()
淺拷貝結果：? solo ?= [ "Alex" , 28, ["Python", "C#", "JavaScript"]]
淺拷貝時變量solo新建了一塊內存(10201848),此內存記錄了list中元素的地址；對于list中的元素，淺拷貝會使用原始元素的引用（內存地址）

修改淺拷貝： solo = [ 'Mr.Wu' , 28, ['Python', 'C#', 'JavaScript',? 'CSS' ]]
str是不可變類型，所以當修改元素Alex為Mr.Wu時，內存地址發生改變；list是可變類型，元素['Python', 'C#', 'JavaScript', 'CSS']修改完后，內存地址沒有改變

3、深拷貝 （創建列表變量Alex，變量包含子列表，通過copy模塊的深拷貝函數deepcopy()對變量Alex進行拷貝，當對Alex進行操作時，此時solo會如何變化？）

?View Code

初始條件： ?Alex ?= ["Alex", 28, ["Python", "C#", "JavaScript"]]
深拷貝： solo = copy.deepcopy(Alex) #通過copy模塊里面的深拷貝函數deepcopy()
深拷貝結果：? solo ?= [ "Alex" , 28, ["Python", "C#", "JavaScript"]]
深拷貝時變量solo新建了一塊內存(10201848),此內存記錄了list中元素的地址；但是，對于list中第三個元素（['Python', 'C#', 'JavaScript']）重新生成了一個地址（6203512），此時兩個變量的第三個元素的內存引用地址不同

修改深拷貝： solo = [ 'Mr.Wu' , 28, ['Python', 'C#', 'JavaScript', ?'CSS' ]]
str是不可變類型，所以當修改元素Alex為Mr.Wu時，內存地址發生改變；list是可變類型，元素['Python', 'C#', 'JavaScript', 'CSS']修改完后，內存地址沒有改變，但是Alex和solo在第三個元素引用的本就不同

4、對于拷貝有一些特殊情況
（1）對于非容器類型（如數字、字符串、和其他'原子'類型的對象）沒有拷貝這一說
（2）也就是說，對于這些類型，"obj is copy.copy(obj)" 、"obj is copy.deepcopy(obj)"
（3）如果元祖變量只包含原子類型對象，則不能深拷貝
①為什么要拷貝？
答：當進行修改時，想要保留原來的數據和修改后的數據
②數字字符串 和 集合 在修改時的差異？ （深淺拷貝不同的終極原因）
答：在修改數據時：
? ? ? ? ? ? ? ?數字字符串：在內存中新建一份數據
? ? ? ? ? ? ? ?集合：修改內存中的同一份數據
③對于集合，如何保留其修改前和修改后的數據？
答：在內存中拷貝一份
④對于集合，如何拷貝其n層元素同時拷貝？
答：深拷貝

?

九、文件操作

（1）打開文件： ?文件句柄 = file('文件路徑', '模式')
python中打開文件有兩種方式，即：open(...) 和 file(...) ，本質上前者在內部會調用后者來進行文件操作，推薦使用 open。
1、打開文件的模式：
　　r， 只讀模式【默認】
　　w，只寫模式【不可讀；不存在則創建；存在則刪除內容；】
　　a， 追加模式【不可讀；不存在則創建；存在則只追加內容；】
2、"+" 同時讀寫某個文件：
　　r+，可讀寫文件。【可讀；可寫；可追加】
　　w+，寫讀
　　a+，追加讀

?小結　

3、"U"表示在讀取時，可以將 \r \n \r\n自動轉換成 \n （與 r 或 r+ 模式同使用）
　　rU
　　r+U
4、"b"表示處理二進制文件（如：FTP發送上傳ISO鏡像文件，linux可忽略，windows處理二進制文件時需標注）
　　rb 二進制讀
　　wb 二進制寫(ab也一樣)
　　ab
（2）文件操作常用功能：
1、read()、readline()、readlines()的區別
　　print(info_file.read()) #read參數，讀取文件所有內容
　　print(info_file.readline()) #readline，只讀取文章中的一行內容
　　print(info_file.readlines()) #readlines，把文章內容以換行符分割，并生成list格式，數據量大的話不建議使用
2、seek、tell光標
　　data = info_file.read() #默認光標在起始位置，.read（）讀取完后，光標停留到文件末尾
　　print(info_file.tell()) #tell 獲取當前的光標位
　　info_file.seek(0) #seek 移動光標到文件首部
3、文件循環
　　for index,line in enumerate(info_file.readlines()): #先把文件內容以行為分割生成列表，數據量大不能用
　　for line in info_file: #建議使用方法，每讀取一行，內存會把之前的空間清空，不會占用太多內存
4、flush 刷新
　　sys.stdout.flush() #flush 強制刷新緩存到內存的數據寫入硬盤
5、truncate 截斷
　　truncate跟光標位置無關，從文件首部開始截取字符；如果是truncate(0)會把文件清空
6、with 語句
　　為了避免打開文件后忘記關閉，可以通過管理上下文，即：
　　　　with open('log','r') as f:
　　　　...
如此方式，當with代碼塊執行完畢時，內部會自動關閉并釋放文件資源。在Python 2.7 后，with又支持同時對多個文件的上下文進行管理，即：
　　　　with open('log1') as obj1, open('log2') as obj2:
　　　　pass　
（3）文件修改方式：
1、把文件讀取到內存當中，對內存進行修改，把修改后的內容寫入到原文件(舊內容被清空)
2、如果在硬盤上直接寫，會進行覆蓋，硬盤上不能進行插入，原來的內容不會整體后移，而是直接覆蓋掉
3、把文件讀取到內存當中，對內存進行修改，把修改的內容另存為新的文件(舊文件保留)
　　①?另存方式
　　②?r+模式
　　③?a+模式

?

十、函數

①格式

            1     def 函數名(參數):
2             ....
3             函數體
4             ....
5             return 返回值
6     函數名()
          

②形參：? ?def func(name): // name 叫做函數func的形式參數，簡稱：形參
③實參： ??func("solo") // 'solo' 叫做函數func的實際參數，簡稱：實參
④默認參數：? def stu_register(name,age,course,country="CN") // 位置參數
⑤關鍵參數： ?stu_register(age=22,name='lzl',course="python")　 // 關鍵參數必須放在位置參數之后

?參數另一種較好的講解！

⑥動態參數/非固定參數（*args 和 **kwargs）：

            1 （1）*args：*args會把多傳入的實參變成一個元組的類型；即使傳入的是list類型也會變成元組，成為元組中的一個元素；另函數中有*args與其他形參的時候，*args一定要寫到其 他形參的后面，否則傳入的實參都會被傳入到*args當中打印成元組；還有如果沒有多出傳入的實參即*args沒有值的時候，*args為空，不會報錯。
2 （2）**kwargs：**kwargs會把多出的a=b這種類型的實參打印成字典的類型（要區分開與關鍵參數的區別，關鍵參數的實參有對應的形參），被當成多余的實參傳入到了*args里面，所以**kwargs的值才為空，分別用*inf_list和**info_dict的方式傳入到*args、**kwargs當中（stu_register("lzl",*info_list,**info_dict) //傳入列表和字典）
3 總結：*args必須放到**kwargs前面（規定）；位置參數一定要放到關鍵參數之前（規定）；默認參數不能跟*args、**kwargs一塊存在（會報錯）。
          

⑦return 返回值：? 如果不執行return，函數的默認返回值為None；當函數執行到return時，函數結束執行
⑧局部變量：? name = "Alex Li" #定義變量name

            1 def change_name(name):
2               name = "金角大王,一個有Tesla的男人"   #函數內部更改變量
3              函數內部對變量進行更改后，生效范圍僅限于函數內部，對外部變量沒有影響，這種變量稱為局部變量；函數內部也可以讓變量全局生效，需要加參數global，這種情況很少用。
          

⑨遞歸函數：? 如果一個函數在內部調用自身本身，這個函數就是遞歸函數
? ? ? ? ? ?條件：?有結束條件、更深一層遞歸規模比上次遞歸有所減少、效率不高，遞歸層次過多會導致棧溢出

            1 寫一個遞歸：
2              def func(n1,n2):        #獲取斐波那契數列100之前的數字
3                  if n1 > 100:
4                      return
5                  print(n1)
6                  n3 = n1 + n2
7                  func(n2,n3)
8              func(0,1)
          

⑩ 匿名函數： 不需要顯式的指定函數

            1 #普通函數               #換成匿名函數
2 def calc(n):            calc = lambda n:n**n
3     return n**n         print(calc(10)
4 print(calc(10))
          

?高階函數: ?變量可以指向函數，函數的參數能接收變量，那么一個函數就可以接收另一個函數作為參數，這種函數就稱之為高階函數。

            1 def?add(x,y,f):
2 ????return?f(x)?+?f(y)
3 res?=?add(3,-6,abs)
4 print(res)
          

?內置函數

?函數的調用順序： 被調用函數要在執行之前被定義

             1 #函數錯誤的調用方式
 2 def?func():?????????????????????#定義函數func()
 3 ????print("in the func")
 4 ????foo()???????????????????????#調用函數foo()
 5 func()??????????????????????????#執行函數func()
 6 def?foo():??????????????????????#定義函數foo()
 7 ????print("in the foo")
 8 
 9 #函數正確的調用方式
10 def?func():?????????????????????#定義函數func()
11 ????print("in the func")
12 ????foo()???????????????????????#調用函數foo()
13 def?foo():??????????????????????#定義函數foo()
14 ????print("in the foo")
15 func()??????????????????????????#執行函數func()
          

?高階函數： 1、某一函數當做參數傳入另一個函數中。2、函數的返回值包含一個或多個函數

?內嵌函數： 在一個函數體內創建另外一個函數（內嵌函數中定義的函數在全局中是無法直接執行的）

?裝飾器： 本質是函數（裝飾其他函數），為其他函數添加附加功能的。
? ? ? ? ? ? ? ?遵循原則: 1.不能修改被裝飾函數的源代碼 2.不能修改被裝飾函數的調用方式
? ? ? ? ? ? ? ?組成：裝飾器由高階函數+內嵌函數組成

? ?生成器： 調用時才會生成相應數據的機制，稱為生成器：generator

應用：可通過yield實現在單線程的情況下實現并發運算的效果(協程)

?協程

??迭代器

可迭代對象：可以直接作用于for循環的對象：Iterable?
可以直接作用于for循環的數據類型有：1、集合數據類型，如list、tuple、dict、set、str等；2、生成器，包括generator和帶yield的generator function；
可以用isinstance()去判斷一個對象是否是Iterable對象

1 2 3

from ? collections? import ? Iterable print ( isinstance ([], Iterable)) # True

迭代器： 可以被next()函數調用并不斷返回下一個值的對象稱為迭代器：Iterator。
用isinstance()判斷一個對象是否是Iterator對象

1 2 3

from ? collections? import ? Iterator print ( isinstance ([], Iterator)) # True

小結：
1、凡是可作用于for循環的對象都是Iterable類型；
2、凡是可作用于next()函數的對象都是Iterator類型，它們表示一個惰性計算的序列；
3、集合數據類型如list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函數獲得一個Iterator對象；
4、Python的for循環本質上就是通過不斷調用next()函數實現的

?for循環

?等價效果（迭代器）

?

十一、常用模塊

（一）、導入模塊： 導入模塊的本質就是把python文件解釋一遍；導入包的本質就是把包文件下面的init.py文件運行一遍

（二）、常用模塊：

（1）time和datatime模塊
　　時間相關的操作，時間有三種表示方式：1、時間戳 1970年1月1日之后的秒，即：time.time()
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 2、格式化的字符串 2014-11-11 11:11， 即：time.strftime('%Y-%m-%d')
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 3、結構化時間 元組包含了：年、日、星期等... time.struct_time 即：time.localtime()

             1 import?time
 2 print(time.time())??????????????#時間戳
 3 #1472037866.0750718
 4 print(time.localtime())????????#結構化時間
 5 #time.struct_time(tm_year=2016, tm_mon=8, tm_mday=25, tm_hour=8, tm_min=44, tm_sec=46, tm_wday=3, tm_yday=238, tm_isdst=0)
 6 print(time.strftime('%Y-%m-%d'))????#格式化的字符串
 7 #2016-08-25
 8 print(time.strftime('%Y-%m-%d',time.localtime()))
 9 #2016-08-25
10 print(time.gmtime())????????????#結構化時間
11 #time.struct_time(tm_year=2016, tm_mon=8, tm_mday=25, tm_hour=3, tm_min=8, tm_sec=48, tm_wday=3, tm_yday=238, tm_isdst=0)
12 print(time.strptime('2014-11-11',?'%Y-%m-%d'))??#結構化時間
13 #time.struct_time(tm_year=2014, tm_mon=11, tm_mday=11, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=315, tm_isdst=-1)
14 print(time.asctime())
15 #Thu Aug 25 11:15:10 2016
16 print(time.asctime(time.localtime()))
17 #Thu Aug 25 11:15:10 2016
18 print(time.ctime(time.time()))
19 #Thu Aug 25 11:15:10 2016
          

             1 import?datetime
 2 print(datetime.date)????#表示日期的類。常用的屬性有year, month, day
 3 #
            
              
 4 print(datetime.time)????#表示時間的類。常用的屬性有hour, minute, second, microsecond
 5 #
              
                
 6 print(datetime.datetime)????????#表示日期時間
 7 #
                
                  
 8 print(datetime.timedelta)???????#表示時間間隔，即兩個時間點之間的長度
 9 #
                  
                    
10 print(datetime.datetime.now())
11 #2016-08-25 14:21:07.722285
12 print(datetime.datetime.now()?-?datetime.timedelta(days=5))
13 #2016-08-20 14:21:28.275460
                  
                
              
            
          

?時間比較

（2）random模塊： 生成隨機數（驗證碼）

?生成隨機數

?驗證碼

（3）os模塊： 用于提供系統級別的操作（比如目錄、路徑等的操作）

?os模塊

（4）sys模塊： 用于提供對解釋器相關的操作（比如退出程序、版本信息等）

?sys模塊

（5）shutil模塊： 高級的（文件、文件夾、壓縮包）處理模塊 （比如文件的拷貝、壓縮等）

① shutil.copyfileobj 將文件內容拷貝到另一個文件中，可以部分內容

?shutil.copyfileobj

?把文件f1里的內容拷貝到f2當中

② shutil.copyfile 文件拷貝

?shutil.copyfile

?把文件f1里的內容拷貝到f2當中

③ shutil.copymode(src, dst) 僅拷貝權限。內容、組、用戶均不變

?shutil.copymode

④ shutil.copystat(src, dst) 拷貝狀態的信息，包括：mode bits, atime, mtime, flags

?shutil.copystat

⑤ shutil.copy(src, dst) 拷貝文件和權限

?shutil.copy

⑥ shutil.copy2(src, dst) 拷貝文件和狀態信息

?shutil.copy2

⑦ shutil.copytree(src, dst, symlinks=False, ignore=None) 遞歸的去拷貝文件 拷貝多層目錄

?shutil.copytree

⑧ shutil.rmtree(path[, ignore_errors[, onerror]]) 遞歸的去刪除文件

?shutil.rmtree

⑨ shutil.move(src, dst) 遞歸的去移動文件

?shutil.move

⑩?shutil.make_archive(base_name, format,...)?創建壓縮包并返回文件路徑，例如：zip、tar
?base_name： 壓縮包的文件名，也可以是壓縮包的路徑。只是文件名時，則保存至當前目錄，否則保存至指定路徑，
　　　　　　　　如：www ? ? ? ? ? ? ? ? ? ? ? ?=>保存至當前路徑
　　　　　　　　如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
?format： 壓縮包種類，“zip”, “tar”, “bztar”，“gztar”
?root_dir： 要壓縮的文件夾路徑（默認當前目錄）
?owner： 用戶，默認當前用戶
?group： 組，默認當前組
?logger： 用于記錄日志，通常是logging.Logger對象

?源碼

shutil 對壓縮包的處理是調用 ZipFile 和 TarFile 兩個模塊來進行的，詳細：

?zipfile 壓縮解壓

?tarfile 壓縮解壓

?ZipFile 源碼

?TarFile 源碼

（6）json 和 pickle模塊： 文件只能存二進制或字符串，不能存其他類型，所以用到了用于序列化的兩個模塊

?

（7）shelve模塊： shelve模塊內部對pickle進行了封裝，shelve模塊是一個簡單的k,v將內存數據通過文件持久化的模塊，可以持久化任何pickle可支持的python數據格式 （可以存儲數據、獲取數據、給數據重新賦值）

?View Code

（8）xml模塊： xml是實現不同語言或程序之間進行數據交換的協議，跟json差不多，但json使用起來更簡單（通過<>節點來區別數據結構）

?文件

?操作

（9）configparser模塊： 用于生成和修改配置文檔（很少在程序中修改配置文件）

（10）hashlib模塊： 用于加密相關的操作，3.x里代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

?hashlib

?hmac 模塊

（11）re模塊： 用于對python的正則表達式的操作；匹配（動態模糊的匹配）；關鍵是匹配條件

?正則表達式

①、match：從起始位置開始去匹配

?View Code

②、search：最前面去匹配（不一定是最開始位置），匹配最前

?View Code

③、group與groups的區別

?View Code

④、findall上述兩中方式均用于匹配單值，即：只能匹配字符串中的一個，如果想要匹配到字符串中所有符合條件的元素，則需要使用 findall；findall沒有group 用法

?View Code

⑤、sub：用于替換匹配的字符串

?View Code

⑥、split：根據指定匹配進行分組(分割)

?View Code

（12）urllib模塊： 提供了一系列用于操作URL的功能（利用程序去執行各種HTTP請求。如果要模擬瀏覽器完成特定功能，需要把請求偽裝成瀏覽器。偽裝的方法是先監控瀏覽器發出的請求，再根據瀏覽器的請求頭來偽裝，User-Agent頭就是用來標識瀏覽器的。）

?View Code

?

十二、面向對象

面向過程編程： 通過代碼的層層堆積來實現功能。不易迭代和維護。
函數式編程： 將某功能代碼封裝到函數中，僅調用函數即可
面向對象編程： 利用“類”和“對象”來創建各種模型來實現對真實世界的描述；使用面向對象編程的原因一方面是因為它可以使程序的維護和擴展變得更簡單，并且可以大大提高程序開發效率 ，另外，基于面向對象的程序可以使它人更加容易理解你的代碼邏輯，從而使團隊開發變得更從容。

?經典類、新式類

?航班查詢

類的特殊成員方法：
① __doc__　　表示類的描述信息

?View Code

② __module__ 和 __class__
__module__ 表示當前操作的對象在哪個模塊?
__class__ 表示當前操作的對象的類是什么

?View Code

③ __init__ 構造方法，通過類創建對象時，自動觸發執行

④ __del__析構方法，當對象在內存中被釋放時，自動觸發執行

⑤ __call__ 對象后面加括號，觸發執行
注：__init__的執行是由創建對象觸發的，即：對象 = 類名() ；而對于 __call__ 方法的執行是由對象后加括號觸發的，即：對象() 或者 類()()

?View Code

⑥ __dict__ 查看類或對象中的所有成員

?View Code

⑦ __str__ 如果一個類中定義了__str__方法，那么在打印 對象 時，默認輸出該方法的返回值

?View Code

⑧ __getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分別表示獲取、設置、刪除數據

?View Code

⑨ __new__ \ __metaclass__

            1 print?type(f)?# 輸出：
            
              ????   表示，obj 對象由Foo類創建
2 print?type(Foo)?# 輸出：
              
                ????????????? 表示，Foo類對象由 type 類創建
              
            
          

f對象是Foo類的一個實例，Foo類對象是 type 類的一個實例，即：Foo類對象 是通過type類的構造方法創建

是由 type 類實例化產生那么問題來了，類默認是由 type 類實例化產生，type類中如何實現的創建類？類又是如何創建對象？
答：類中有一個屬性?__metaclass__，其用來表示該類由 誰 來實例化創建，所以，我們可以為?__metaclass__ 設置一個type類的派生類，從而查看 類 創建的過程

?View Code

反射： 通過字符串映射或修改程序運行時的狀態、屬性、方法。 有以下4個方法
① hasattr(obj,str) 判斷一個對象obj里是否有對應的str字符串的方法
② getattr(obj,str) 根據字符串去獲取obj對象里的對應的方法的內存地址

?View Code

③ setattr(obj,'y','z') obj.y = z 通過字符串添加屬性

?View Code

④ delattr(obj,str) 刪除obj.str 通過字符串刪除屬性

?View Code

十三、Python垃圾回收機制?

概述： 和許多其它的高級語言一樣，Python使用了垃圾回收器來自動銷毀那些不再使用的對象。每個對象都有一個引用計數，當這個引用計數為0時Python能夠安全地銷毀這個對象

問題點： 由于一次僅能有一個對象被回收，引用計數無法回收循環引用的對象。

解決方案： 弱引用：減少循環引用，減少內存中不必要的對象存在的數量。對象可能在任何時刻被回收。

詳細內容