python基礎_review

• 編程語言：編程語言是控制可以直接或者間接控制計算機來執行任務的字碼。
  
  • c /c#/c++/java/lua/python/Shell/go…

python簡介：

• python是最近比較受歡迎的編程語言
• 是一種解釋性的語言，一邊編譯，一遍執行。解釋器有CPython（官方），Jpython（可以運行在java 平臺上），IronPython(可以運行在.NET和Mono平臺)，PyPy(Python實現的，支持JIT即時編譯)
• 優點：簡單，易學，免費，開源，高層語言(不需要關注底層語言)，可移植性，面向對象，可擴展性，豐富的庫，規範的代碼（優雅）
• 缺點：運行效率慢，解釋性語言共有的

• 可以做很多事情：web應用開發，桌面軟件，科學計算，爬蟲，遊戲，出產品原型。。。

• 編輯工具：Pycharm

• python2和python3的區別

  • 編碼環境不一樣，python2：ascii, python:utf-8
  • import方式不一樣，python2：絕對路徑和相對路徑；python3：絕對
  • 類的定義：python2：老式類和新式類；python3：新式類
  • 浮點數除法操作符：python2：/整數除法，//小數除法；python3，相反
  • print
  • …

註釋

• ”,”“,”’ ”’,”“”“”“

變量

• 存儲數據的籃子，實際上是一個地址引用，Python中一切皆對象，而對象名實際上都是對真實存儲地址的引用
• python的常規變量類型：數字（int,float,long,complix）,string,bool,列表，字典，元組
• type(),查看變量的類型

標示符

• 自定義的有意義的字碼/字碼串，如變量名，類名，方法名等
• 規則：1.字母數字下劃線 2.首個字符不能是數字 3.不能是關鍵字（內置標示符）4.見名知義 5.駝峯法：類名：ClassName 變量名和方法名：var_1 fun_1

print

• 輸出內容到控制檯
• print (“內容”)

• print（”%格式符號”%內容）

  • %c
  • %s
  • %d
  • %u無符號10進制數
  • %o:八進制整數
  • %x:16進制整數（小寫字母0x）
  • %X:16進制整數（大寫字母0X)
  • %f:浮點
  • %e/%E：科學計數法

• \n :換行輸出

輸入

• 程序停止，等待輸入內容並且按下enter鍵後，將輸出的內容記錄下來，字符串類型
• python2:raw_input(“提示的內容”)
• python3:input(“提示語句”)

運算符

• 變量間相互作用的符號
• / :python2:整數除 ；python3:小數除
• //: 地板除，獲取<=當前實際值的最近的整數值
• **: 指數，2**2 == 4；2**3=8

數據類型轉換

• 將一種數據類型的數據轉換爲另外一種類型的數據
• complex(real,[,imag]): 創建一個複數，實部爲real，虛部爲imag
• str():將對象轉換爲字符串，給人看的
• repr():將對象轉化爲字符串，給程序員看的，更強大
• chr():將一個整數轉換爲unicode字符
• ord():顯示一個字符的ASCII排序數字
• hex():將一個整數轉換爲16進制
• oct():將一個整數轉換爲8進制
• bin():將一個整數轉化爲2進制

判斷

• yes/no ,yes怎樣，no 怎樣。。。

• if :
  if 條件：
  代碼

  • 一個條件，滿足條件，執行；鑰匙開門，能打開進入

  if 條件：
  代碼
  else：
  代碼

  • 一個條件，兩個結果；鑰匙開門，能打開，進入，不能打開，去姥姥家

    if 條件：
    代碼
    elif 條件：
    代碼
    elif 條件：
    代碼
    else：
    代碼

  • n條件，n+1個結果；如果能打開門，進入，如果身上有錢，去吃外賣，如果心情好，去跳舞，否則，就在門口等着老媽回來

• 用於條件判斷的運算符：用於判斷，返回True/False的結果

  • 關係運算符：==，！=。。。
  • 邏輯運算符：and, or, not

• 循環：重複執行

• while ，for

while 條件：
  代碼
判斷條件是否滿足，滿足就執行代碼，執行完一輪，再次判斷條件，滿足繼續執行，執行完再判斷。直到判斷不滿足，跳出循環，執行下面的語句

• 例子：給女朋友說10000遍對不起

i=0
while i < 10000:
 print("對不起")
 i+=1

• 好處，精煉代碼，提高代碼的複用型。美觀。需要多次重複的代碼都可以使用循環語句

for 循環

• 用來遍歷一個可迭代對象的方法

for i in [ilter]:
    代碼塊
iter中的元素從前到後依次取出，代碼裏可以使用，也可以不使用，執行完代碼，再取第二個，再執行代碼，再取第三個，直到將iter中的最後一個元素取出來，執行完了代碼塊，跳出循環，執行for語句結構後的代碼

• break：立即跳出當前循環，執行當前循環代碼結構後的代碼
• continue:立即結束當輪循環，進行循環語句的條件判斷（while）/取ilter的下一個元素（for）
• break/continue 只能在循環語句中使用，不能單獨使用
• break/continue 只能在使用在嵌套語句的時候，只能對被嵌套的最近的一層循環結構起作用

字符串

• 雙引號/單引號中的數據就是字符串

• ”, “”,”’ ”’ ,”“” “”“,四種定義字符串的形式

• 字符串輸出，佔位符

• 字符串輸入，python3：input(), python2:raw_input();()裏爲提示字符
• 下標
  
  • 從0開始數
  • 切片[起始位置（包括）:結束位置（不包括） : 步長（一次跳幾個字符）]
  • 其中起始位置和結束位置如果是正數代表第當前第 數字+1 個字符，0 代表第 個字符，負數代表從最後往前數第幾個，-1代表倒數第一個
  • 步長不寫代表1，負數代表從後往前逆序截取字符
  • 反轉字符串 ：[::-1]
  • 常見的字符串操作
  • str.find（“字符”）查看是否有“字符”，有返回索引值，沒有返回-1
  • str.index（）:和find()一樣，只是，如果沒有找到不是返回-1，而是報異常
  • str.count(str1,a(開始索引值)，b(從索引值開始的長度))：返回str1在str中從索引爲a到之後的長度爲b的字符串片段中出現的次數,沒有出現過，返回 0
  • str.replace(str1,str2,num):將str1替換爲str2 num次
  • str.split(str=”“, num):將str以”“,分隔num次，若沒有參數，則是對str中的所有空白字符進行分隔，返回列表
  • str.capitalize():將str首字母大寫
  • str.title():將str的每一個單詞的首字母大寫
  • str.startwith(“str1”):若str是以str1開頭的，返回True,否則返回False
  • str.endwith(“str2”):若str是以str2結束，如果是返回True,否則返回False
  • str.lower():str中的所有大寫字符轉換爲小寫
  • str.upper():str中的所有小寫字母轉換爲大寫
  • str.rjust(width):返回str字符串的右對齊至長度爲width的新字符串，不足空格填充
  • str.center(width):返回str字符串居中至長度爲width的新字符串，不足以空格填充
  • str.lstrip():刪除str左邊的空白字符串
  • str.rstrip():刪除 str右邊的空白字符串
  • str.strip():刪除str字符串兩邊的空白字符串
  • str.rfind():類似於find（）函數，不過從右邊開始查找
  • str.rindex():類似於index（），不過是從右邊開始
  • str.partition(str1):把str以第一個出現的str1分割成三部分，str1,前，str1，後
  • str.rpartition(str1):把str以第一個出現的str1分隔成三部分，str1前，str1, 後，不過是從右邊開始找
  • str.splitlines(）：按照行分隔，返回一個包含各行作爲元素的列表
  • str.isalpha():如果str所有的字符都是字母，則返回True,否則返回False
  • str.isdigit():如果str所有的字符都是數字，則返回True,否則返回Flase
  • str.isalnum():如果str所有的字符都是字母或者數字，則返回True,否則返回False
  • str.isspace():如果str所有的字符都是空格，則返回True,否則返回False
  • str.join(列表)：列表中的每一個元素後面插入str，構造出一個新的字符串

列表

• 可以盛放各種數據類型的容器
• a = [1,2,3,”a”,”b”,”c”,{“name”:”michael”}]

• 性質：

  • 有下標，可以利用下標索引列表中的每一個值：name = a[6][“name”]
  • 可以被for遍歷

• 相關操作：增刪改查

  • 增：
  • list.append(元素)：在列表的最後面添加元素，一次只能添加一個,如a.append(3)
  • list.extend（list1）:在list中依次添加list1中的每一個元素，如a.extend（[3,4,5]）
  • list.insert(index_num,元素)：在list的索引值爲index_num的地方添加元素，如a.insert(1,88)
  • 刪：del,pop,remove
  • del list[index_num]:刪除list中索引值爲index_num的元素，如,del a[0]
  • list.remove(“元素”)：刪除list中的”元素“，如，a.remove(88)

  • list.pop(a):刪除list中索引值爲a的元素，不加參數，刪除最後一個,如，a.pop()

  • 改：

  • a[‘index_num’] = value,如 a[2] = 22

  • 查：

  • in， not in , index, count
  • a in list :判斷a是否在list中，在，返回true，否則返回False
  • a not in list :判斷a 是否不在list中，是，返回true，不是，返回False
  • a.index(value, a,b):獲取value在a中的下標 ，a,b表示在下標[a,b)索引區間內尋找，有，返回索引值，沒有，報錯。和字符串的index（）用法相同，如，a.index(‘a’,1,10)
  • 其實字符串就是一個列表
  • a.count(‘a’):列表a中，獲取‘a’在列表中出現的次數

  • 注意和字符串中的用法不一樣，字符串中，str.count(‘a’,a,b),a,b代表索引區間[a,b),列表中沒有這兩個參數

  • 列表可以嵌套：l1 = [[1,2,3],[4,5,6]], 查詢出6:li[1][2]

元組

• (1,”a”,{“name”:”michael”})
• 可以理解成不能修改的列表（不能增，刪，改）

字典

• 存儲key:value鍵值對的數據結構,可以根據有意義的key值，獲取自己記不住的vlaue,像字典一樣，key就是前面的索引，value對應是某個索引字的詳解
• dict = {“name”:”michael”,”age”:18}

• 操作，增刪改查

  • 增： dict[“沒有的key”] = value
  • 刪: del dict[‘key’] dict.clear():清空字典內容爲空字典
  • 改：dict[‘已有的key’] = new_value
  • 查：dict[key] ；
  • len(dict):查看dict 的鍵值對的個數，返回個數
  • dict.keys():獲取字典的所有key,返回列表對象，可遍歷獲取元素
  • dict.values():獲取字典大的所有value返回列表對象，可遍歷獲取元素

  • dict.items()：獲取字典的所有鍵值對，每個鍵值對放在一個元組裏，組成列表對象返回，可遍歷使用

  • ？實現帶下標索引的遍歷

  • 就是遍歷後輸出的結果前面帶索引值–加一個 計數器 從0開始計數，輸出的時候帶着這個計數器的值就可以了。

 a = ["a","b","c"]
 i = 0
 for x in a :
    print("%d,%s" % (i, x))
    i+=1 

• 以上功能用一個 內置的enumerate（）函數，就可以解決了

 a = ["a","b","c"]
 for index, i in enumerate(a) :
    print("%d,%s" % (index, i))

公共方法

• +，列表，元組，字符串；字典不可以，因爲字典的key不能重複
• *， 列表，元組，字符串；字段不可以，因爲字典的key不能重複
• in ,not in :列表，元組，字符串， 字典

python 內置函數

• cmp(a,b)：比較a,b的小，a>b,返回1；a

總結

• 數據類型：數字（int，long, float,complex）,bool, str,list,dict,turple
  
  • 執行流程
  • 選擇：if;if else;if elif
  • 循環:for;while

函數

• 爲了完成一個功能，將一行或者多行代碼封裝成一個可以調用，返回執行結果的結構。
• 格式

 # 定義
 def 函數名（形參）
     代碼
     return 返回值
 # 調用
 result = 函數名（實參）

• 四種函數類型：

  • 無參數，無返回值:花錢
  • 無參數，有返回值：不給錢，給我帶一份外賣
  • 有參數，無返回值：給你錢花，隨便花不用給我什麼
  • 有參數，有返回值：給你10塊錢，給我帶一份外賣

• 函數嵌套使用：函數裏面前套函數

  • 函數執行完是返回到調用它的地方

• 求三個數的平均值，調用函數完成

def avg(a, b, c):
    result = (a + b + c) / 3
    return result


result = avg(1, 2, 3)
print(result)

局部變量

• 在函數內定義的變量
  
  • 其作用範圍是只在定義它的內部，出了函數就不能用了

全局變量

• 在函數外定義的變量
• 一個函數裏可以用，另一個函數裏也可以用
• 如果想要在函數裏修改全局變量，需要 用 global聲明一下
• 若遇到全局變量和局部變量同名的情況，函數裏局部變量優先級大於全局變量

函數之間傳遞數據的方式

• 全局變量
• 傳參
• 函數嵌套

返回值2

• 遇到return就會返回函數的執行結果
• return 後面跟上列表，字典，元組等可以存儲多個數據的結構，就可以一次性返回多個值
• 如果函數直接跟多個值，默認返回元組

參數2

• 缺省參數：def test(age=1),如果傳入參數，參數實際值等於傳入的值，如果不傳入參數,就會默認age=1
  
  • 注意缺省參數一定要位於參數列表的最後面，否則會報錯

• 不定長參數

  • 需要處理不確定個數的參數的時候使用的參數形式
  • *args(元組),**kwargs(字典)
  • 如果同時有缺省參數，和兩種不定長參數，它們的順序應該是：（*args,a=5,b=6,**kwargs）

  拆包

  • 對於函數return的多個值的包一次性拆開，用多個變量接收

# 對元組進行拆包
def test()
  return 1,2
a,b = test()
# 字典和列表的拆包形式和元組相同
# 注意字典拆包獲取的是key值

• 交換兩個變量的值：
  
  • a,b=b,a

引用

• python中，變量名，類名，函數名，其實都只是對實際存儲的數據和代碼的存儲單元的地址碼的一個指向。這種指向就叫引用。
  
  • python值的傳遞，就是引用的傳遞
  • 可以用id（名字)來判斷引用的內存地址是否相同，來判定是否引用的是同一個數據

可變/不可變類型

• 可變/不可變類型，都是指的數據類型
• 不可變類型是值數據是一個整體，不能對已經賦值的數據進行增刪改的操作的數據類型
• 不可變類型包括 數字，布爾，字符串，元組
• 如果想要改變不可變類型變量的值，只有從新賦值，也就是變量需要重新引用一個新的內存地址碼
• 可變類型是可以對已經定義賦值的數據進行更改操作（增/刪/改）的數據類型

• 可變類型包括：字典，列表，集合

• 可變類型變量作爲參數傳遞，對變量進行更改，會改變原變量的值

• 不可變類型作爲參數傳遞，對變量進行更改（也只能重新賦值），不會改變原變量的值，因爲函數內更改的變量值，實際上是重新引用了一塊新的內存地址，但是如果聲明是全局變量了，那麼全局變量的值就會改變了

a = 100
b = []
def test(a):
    a = 200

def test1():
    global a
    a = 200    

def test2(b)
   b.append(2)

test(a)

a
100

test1()
a
200

test2(b)

b
[2]

函數使用注意事項

• 函數名不要重複
• 調用函數傳參的時候，注意實參和形參的順序要一致
• 如果函數有返回值，那麼就應該定義一個變量來接收

遞歸函數

• 函數的內部調用這個函數本身

• 關鍵點：函數在哪裏調用，返回值就回到哪裏

• 示例 1.使用遞歸函數計算10！

# 使用遞歸函數，計算10！
# 關鍵點，函數嵌套函數本身，函數在哪裏調用，結果就返回到哪裏

def diguiFun(a):
    if a > 1:
        result = a * diguiFun(a - 1)
    else:
        result = 1
    return result


if __name__ == '__main__':
    result = diguiFun(10)
    print(result)

匿名函數

• lambda函數，可以當做變量使用的函數
• 格式
  lambda 參數:表達式
• 使用方法：用一個變量定義表達式，像使用函數一樣給變量傳值（傳值的數量，格式要和lambda表達式的參數數量，格式一致），返回表達式計算的結果

a = lambda i:i+1
print(a(3))

• 特點是小而靈活，一般簡單的計算，使用lambda表達式
• 使用場景
  
  • 簡單的計算，不用定義標準函數了，一行搞定
  • 匿名函數（lambda表達式）可以當做參數傳遞給函數

lamb = lambda a,b:a*b
def test_lamb(lamb):
    print(lamb(2,3))

test_lamb(lamb)
6

• 作爲內置函數的參數

一個列表
stus = [
{"name": "zhangsan", "age": 18},
{"name": "lisi", "age": 19},
{"name": "wangwu", "age": 17}
]

#1.按照名字給列表stus排序
stus.sort(key=lambda i:i["name"])
stus
[{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]

#2.按照年齡給列表stus排序
stus.sort(key=lambda i:i["age"])
stus
[{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]

給程序傳參

• 給 sys模塊的argv列表傳參
• 步驟
  
  • 在.py文件中導入sys模塊
  • 在終端運行該.py文件，在文件名後面加上要傳的參數

test.py：
import sys
print(sys.argv)

終端：
python3 test.py 1 2 
['test.py', 'q'. '2']

• 特點，argv列表的第一個元素永遠是文件名

• 作用：一步到位，不用一個個傳入

應用場景：當你不想要一個個傳參數的時候，就使用給程序文件傳參的方式一次性把文件需要使用的參數傳完

列表推導式

• 快速生成一個列表的方式
• 基本格式
  [x for x in range(10)]

如:

[x for x in range(10)]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 多個 for 循環

[(x, y, z) for x in range(2) for y in range(2) for z in range(2)]

[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

# for 循環的嵌套

• 添加條件判斷

[x for x in range(10) if x > 5 ]

[6, 7, 8, 9]

• 練習

請寫出一段 Python 代碼實現分組一個 list 裏面的元素,比如 [1,2,3,...100]變成 [[1,2,3],[4,5,6]....]

# 思路：
# 1.三個一組，切片 ；2.切片的起點（index)，0，3，6...；3.用range(0,100,3)獲取這些切片下標的起點 4.獲取片的起始下標位置x,那麼新列表的每個元素就應該是[1,2,3..100][x:x+3]

# 代碼
a = [i for i in range(1,101)]
res = [a[x:x+3] for x in range(0,101,3)]

集合

• {a,b,c}

• 特點：

  • 無序，沒有下標
  • 不能有重複的元素

• 作用

  • 用來對數據的去重

a_before = [1,2,3,4,4,4,3,2,3,4,5,5]
a_set = set(a)
a_set
{1, 2, 3, 4, 5}

a_after = list(a_set)
a_after
[1,2,3,4,5]

列表，集合，元組之間的轉換

• 列表，集合，元組之間可以相互轉換
• list(tuple/set):將元組或者集合轉換爲列表返回
• tuple(list/tuple):將列表或者集合轉換爲元組返回
• set(list/tuple):將列表或者元組轉換爲集合返回

文件操作

• 文件數據的集合體
• 文件的格式
  
  • 系統，程序，配置文件：.iso, .dll, .py, .pyc, .sql,
  • 文本：.txt, .pages
  • 圖片：.image, .png, .gif, .ps, .mpeg
  • 音頻：.mp3
  • 視頻: .avi, .mp4, .rmvb, .3gp, .mov
  • 其他：.html, .xml, .json
  • ……
• 實際上計算機底層只人0，1，所有數據類型都是0，1的組合，進行不同的排序
• 文件類型是給人看的，對於程序員來說，文件類型是可以自定義的，一個後綴而已
• 使用文件的目的是爲了重複利用一段數據集
• 使用不同格式的數據的目的是區分不同類型的數據，雖然本質上都是0，1,但是不可能所有的數據都用0，1表示，無法操作。分成不同類型的數據，易於不同數據的歸類，對一類數據有一種處理方法，不同的數據處理方法不一致

文件操作

• 打開/新建文件，讀寫， 關閉
• 打開
  file = open (file, 'w' ) :以寫的方式打開file
• 讀寫
  file.write("內容") ：往打開的file文件中寫入’內容’
  
  • 關閉
    file.close() :將 file文件關閉

• 打開,讀寫，關閉是標準步驟，一定不要忘了關閉文件，忘了關閉，一直打開，會佔用系統資源

• 不想寫file.close()可以用以下結構打開文件

 with open(file, 'w') as f
   f.write('內容')

 文件file 寫完畢後會自動關閉

• 打開方式
  
  • r:只讀模式
  • w:只寫，覆蓋
  • a:只寫，追加
  • rb:以二進制格式打開，只讀
  • wb:以二進制格式打開，只寫，覆蓋
  • ab:以二進制格式打開，只寫，追加
  • r+:讀寫，文件指針會放在開頭
  • w+:讀寫，覆蓋
  • a+:讀寫，追加
  • rb+:ab+:以二進制打開，讀寫
  • wb+：以二進制打開，讀寫，覆蓋
  • ab+:以二進制打開，讀寫，追加
  • 默認爲 r 模式

讀取數據

• read() ：讀取全部內容，返回
• read(num):讀取Num個字符
• readlines():讀取全部內容，按照一個一個元素，返回一個列表
• readline():每次讀取一行，返回，再次讀取，會繼續讀取下一行

文件的相關操作

• 對文件的一些操作：重命名，刪除文件，創建文件夾，獲取當前目錄，改變默認目錄，獲取目錄列表，刪除文件夾
• 需要導入 os 模塊：import os
• 文件重命名：os.rename(old_file_name, new_file_name)
• 刪除文件：os.remove(file)
• 創建文件夾：os.mkdir("文件夾名")
• 獲取當前目錄：os.getcwd()
• 改變默認目錄：os.chdir('新的路徑')
• 獲取目錄列表：os.listdir('目錄路徑')

• 刪除文件夾：os.rmdir('文件夾路徑')

• *注意，如果既有對文件整體的操作，又有文件內容的操作，導入os模塊時，不能使用from os import *,這樣導入對文件整體的操作是省略了os.,方便了一些，但是打開文件的操作就會報錯。

面向對象編程

• 面向過程和麪向對象
• 早上起來穿衣服，自己一件一件穿–面向過程，保姆幫着穿，不用自己動手–面向對象
• 面向對象和麪向過程都是程序中解決實際生產問題的編程思想
• 面向過程偏向於一步一步，從前到後自己做
• 面向過程是交給他方去做，自己這邊獲取到返回結果即可

• 面向對象是基於面向過程的

• 面向對象的思想

  • 封裝
  • 繼承
  • 多態

類和對象

類

• 類：有着相同性質，能力的一類事務的抽象化集合
• 對象：一種類的一個實體

• 例子：百靈鳥，類，一隻在樹上唱歌的百靈鳥，對象

• 類的構成

  • 類名
  • 屬性：靜態數據

  • 方法 ：動態能力

  • 定義類

class 類名（父類）：
   方法列表

# 屬性也是用方法來完成定義的（__init__()）

• 性質

  • 類採用大駝峯名命名法（BigDog）
  • object 是所有父類的頂級父類
  • 經典類：class 類名 ； class 類名（）

• 實例化對象

  • 格式：對象名 = 類名（）

• __init__(self)

• 用來初始化類的實例對象屬性的魔法方法
• 會在實例化對象的時候自動調用
• self代表實例化對象本身

• 可以在實例化對象的時候傳參數給實例化的對象設置特殊的屬性

• __str__(self)

  • 如果類中沒有定義__str__()方法，print(對象)會打印對象的內存地址
  • 如果類中定義了__str__()方法，print(對象)會打印__str__()裏return的內容
  • __str__(),通常會返回這個對象的描述信息

• __del__(self)

  • 刪除對象，python解釋器默認調用的魔法方法
  • 當有變量保存了一個對象的引用時，此對象的引用次數會+1
  • 當解釋器調用__del__()方法一次，會減少一次對象的引用次數，當對象的引用次數=0時，對象纔會真正被刪除，即對象佔的內存會被回收

  繼承

  • 子類可以使用父類的方法和屬性

• 格式

  • class A(B),B即爲A的父類，A的實例化對象可以調用B的屬性和方法

  • 繼承種類

  • 單繼承：只繼承一個父類
  • 多繼承：繼承多個父類

  • 多層繼承 ：A繼承自父類B，B又繼承自其父類C，那麼A就是多層繼承的類

  • 多繼承

  • 多繼承可以繼承多個父類，會繼承多個父類的所有屬性和方法
  • 如果多個父類有相同的屬性和方法，默認使用第一個父類的屬性和方法（會自動調用魔法方法__mro__()來給所有的父類查找順序排序）

  • 父類們不重名的方法和屬性，子類使用不收影響

  • 子類重寫父類方法或者屬性

  • 當子類定義了和父類同名的方法或者屬性的時候，調用時，會使用子類新定義的，即子類重寫了父類的方法或屬性

  • 子類調用父類同名的屬性或者方法

  • 雖然重寫了父類的屬性或者方法，但是還想調用父類的屬性或者方法
  • 調用父類同名屬性，需要調用了父類的__init__()方法：父類名.__init__(self)
  • 調用父類的同名方法，需要調用父類的響應方法：父類名.同名方法名（self）

  • self 代表子類示例對象本身

  • super()方法的使用

    • 根據mro模仿方法的順序，調用第一個可用的父類的響應方法，或屬性
    • 調用格式
    • super().__init__()';super().方法名（）

• 封裝

  • 將相同/類似的功能代碼/將能夠完成一個特定功能的所有代碼，聚合在一起的過程
  • 定義類，實例化對象使用類定義的方法，屬性，就是封裝的思想

• 私有權限

  • 限制示例對象對類對象中的某些屬性/方法的訪問
  • 格式：在定義類的過程中，在想要設置爲私有權限的屬性/方法名前加__(兩個下劃線)
  • 設置爲私有權限的屬性或者方法，類對象可以正常訪問，實例對象不能訪問
  • 實際上，私有權限的屬性和方法就是解釋器自動改了屬性名/方法名而已
  • 示例對象要修改私有屬性的值，推薦使用間接的調用方法的形式修改。需要修改私有屬性的值，需要事先在定義類的時候，定義好修改私有屬性的方法，然後實例對象，調用響應方法，來完成對設置了私有權限的私有屬性的修改

  多態

  • 定義時的類型和運行時的類型不一樣，就是多態的思想
  • 多個子類重寫了父類的某個方法，現需要使用父類這個類的示例對象，並且需要調用這個方法。那麼給他子類的相關對象調用子類的重寫的方法也是可行的。
  • 好處時，調用一個同名方法，完成不同的功能
  • 舉例子：父類，狗 ，方法：叫 （汪汪）；子類：狼狗，方法：叫（汪汪汪）；子類：泰迪，方法：叫（哇哇哇）。當需要調用父類狗的叫方法的時候，調用狼狗的叫和泰迪的叫也是可以的，達到了，調用同一個方法，完成不同效果的效果

  類屬性，實例屬性

  • 類對象：定義類的時候會自動生成一個類對象；示例對象：實例化類，即生成一個實例對象
  • 類屬性，在類對象裏定義的屬性，即在定義類的代碼裏定義的屬性
  • 類對象和所有實例化對象都可以使用，公用的
  • 如果不想公用，可以將類屬性數值爲私有屬性__屬性
  • 實例屬性，在實例化對象裏定義的屬性
  • 只能在定義它的實例對象裏可以使用

靜態方法和類方法

• 靜態方法

  • 在類中定義的，使用裝飾器@staticmethod裝飾的方法
  • 類對象和實例對象都可以調用
    
    • 定義的時候不需要參數self，def static_method()

• 類方法

  • 在類中定義的，使用裝飾器@classmethod裝飾的方法
  • 第一個參數必須是類對象cls

  • 類對象和實例對象都可以調用

  • 類方法和靜態方法的區別

  • 因爲類方法的第一個參數是cls，通過cls 可以直接引用類對象的屬性和方法
  • 靜態方法沒有額外的參數，因此在靜態方法中想要引用類對象的屬性和方法，必須通過類對象來引用
  • 區別就是cls參數,類方法有cls,可以通過這個內置參數直接調用類對象的所有屬性和方法，靜態方法沒有。靜態方法的好處是沒有參數。

• __new__()

  • 在實例化對象的時候，自動調用的，用來生成實例對象的魔法方法
  • 至少有一個參數cls 代表要示例化的類 ，用來實例化實例對象
  • 重寫此方法的時候，必須return一個實例對象示例，可以object.__new__(cls)，也可以是其他父類父類名.__new__(cls)
  • __init__(self),這個self，就是__new__(cls)，實例化的實例對象
  • 也就是在實例化實例對象的時候，系統是先調用的__new__(cls),實例化了一個實例對象，然後在將這個實例對象通過self參數傳給__init__(self)，方法，完成實例對象的初始化（屬性的設置）
  • 比喻：要生產小布娃娃，__new__(cls):是原材料準備，__init__(self)，是使小娃娃基本成型

  單例模式

  • 確保一個類只能同時攢在一個實例的模式
  • 使用場景：任務管理器；回收站
  • 方式：在類中重寫__new__(cls)方法，使得第一次實例化的時候可以實例化成功，第二次及以後實例化的時候都直接返回第一次實例化的對象。
  • 單例模式只會執行一次__init__(self)方法。
  • 代碼

class DanLi(object):
    __instanse = None

    def __new__(cls, *args, **kwargs):
        if cls.__instanse == None:
            cls.__instanse == object.__new__(cls)
        else:
            return cls.__instanse


danli = DanLi()
print(id(danli))

danli2 = DanLi()
print(id(danli2))

結果：
4305004560
4305004560

• 其他開發模式
  
  • 工廠方法模式
  • 模板方法模式
  • 中介者模式
  • 裝飾模式
  • 迭代器模式
  • 解釋器模式
  • 橋樑模式
  • 。。。。。。

異常

• 程序報錯
• 捕獲異常
  
  • 檢測一段代碼，如果代碼在運行過程中出現異常，就捕獲它並作處理
  • 格式

try:
    一段代碼
except 錯誤集：
    處理代碼

• except後沒有錯誤集，就是捕獲所有異常，因爲不同錯誤處理方式不同，一般會精準捕捉錯誤類型，進行對症下藥，常見的錯誤類型有（IOError,NameError,Exception…）

• 捕獲多個異常

  • 在except後寫多個錯誤集,放在元組裏：except (IOError, NameError)

• 捕獲異常的信息描述

  • 在異常集後 用一個變量接收異常信息：except IOError as result
  • 這樣result就存儲了錯誤信息，可以使用，比如，打印出來print result

• else

  • 如果沒有捕獲到異常，就執行 else 裏的代碼
  • 格式

try:
  被監控的代碼
except:
  有異常執行的代碼
else:
  沒有異常執行的代碼

• finally
  
  • 無論有沒有異常，都要執行
  • 使用場景：文件關閉，釋放鎖，將數據庫鏈接返還給鏈接池等
  • 格式：

try:
  被監控的代碼塊
except:
  有異常，執行的代碼
else:
  沒有異常執行的代碼
finally:
  無論有沒有異常都要執行的代碼  

• 異常的傳遞

  • try 的嵌套
  • 內部的try沒有處理，會拋給外面一層的try，還沒處理(沒有except語句)，繼續拋給外面，都不處理，系統處理，正如我們沒有使用try語句，出現異常時看到的那樣
  • 一旦try處理了，就不外拋了

• 拋出自定義的異常

  • 自定義異常，自定義一個異常的類就行了。比如長度>3時就拋出自定義的異常類實例對象
  • 拋：raise 自定義異常實例對象

  • 拋出後可以使用try 自己捕捉自己處理，也可以不處理，拋給外層try或者系統

  • 異常處理中拋出異常

  • 在處理異常過程中，設置一個開關switch，if 判斷，需要處理的時候，自己處理，不需要自己處理的時候，再拋出 raise

模塊

• 工具包，集成了可以完成某個或者某些功能的代碼集。相當於C的頭文件/java的包

• 模塊的導入

  • 1.一般導入方式：import 模塊名
  • 使用模塊中的函數： 模塊名.函數名
  • 2.當只需要模塊的部分功能時：from 模塊名 import 類名/函數名/變量名，…,…,
  • 3.導入模塊的全部信息的第二種方式：from 模塊名 import *
  • 4.需要給導入的函數/類/變量重命名時： from 模塊名 import 變量名 as 自定義的名字

  • 也可以給導入的模塊名自定義名字 import 模塊名 as 自定義的名字

  • 定位模塊

  • python 搜索被導入模塊的順序爲：
  • 當前目錄 –》shell變量下的PYTHONPATH下的每個目錄–》查看默認目錄 （unix下，一般爲：/usr/local/lib/python/）
  • 模塊搜索路徑存儲子啊system模塊的sys.path中，可以自己添加

• 模塊製作

  • 自定義模塊：一個python文件就可以作一個模塊，模塊的名字就是文件的名字。
  • 調用：import 自己的文件名即可
  • 測試代碼：右鍵運行可以正常運行，導入的時候，不會運行，用來寫模塊的時候測試代碼

if __name__ == 'main':
   要測試的代碼

模塊中的__all__

• 定義可被其他文件導入的信息
• 格式 __all__ = ['fun1', 'fun2', 'var1']
• 如果一個文件中有__all__變量，則只有__all__變量中的內容可以被其它文件導入，不在__all__變量中的不會被導入

包

• 多個相關文件的集合，文件夾

• 導入包中的文件：import 包名.文件名

• 如果想一次性導入包裏的多個文件，或者設置可以被導入的文件：

  • 需要在包下創建文件__init__.py
  • __init__.py 文件是用來設置可以被其他文件導入的文件的
  • 在__init__.py文件裏寫入 __all__=['文件名1（不需要加.py後綴）', '文件名2']

  • 則只有文件名爲：文件名1和文件名2的兩個文件可以被其他文件導入

  • 總結：

  • 將有聯繫的模塊放在一起，並創建一個__init__.py文件，這個文件夾就叫做一個包
  • __init__.py 文件的作用是控制包的導入行爲的，如果爲空，包中的模塊導入不了
  • __all__ 變量，是控制在使用from 模塊 import *語句時，可被導入的內容的
  • 可以在__init__.py文件中編寫內容，當導入時，就會被執行