面向對象介紹
范式編程
編程是程序員用 特定的語法+數據結構+算法 組成的代碼來告訴計算機如何執行任務的過程。
一個程序員為了得到一個任務結果而編寫的一組指令的集合，正所謂條條大路通羅馬，實現一個任務的方式有很多不同的方式，對這些不同的編程方式的特點進行歸納總結得出來的編程方式的類別，即為編程范式。不同的編程范式本質上代表各種類型的任務采取的不同的解決問題的思路，大多數語言只支持一種編程范式，當然也有些語言可以同時支持多種編程范式。兩種最重要的編程范式分別是面向過程編程和面向對象編程
面向過程編程（Procedural Programming）
Procedural programming uses a list of instructions to tell the computer what to do step-by-step.
面向過程編程依賴 - procedures， 一個procedure包含一組要被執行的計算步驟，面向過程又被稱為top-down languages， 就是程序從上到下一步步執行， 從頭到尾解決問題。基本設計思路就是程序一開始是要著手解決一個大問題，然后把一個大問題分解為很多個小問題或子過程，這些子過程再執行的過程再繼續分解知道小問題足夠見到到可以在一個小步驟范圍內解決。
例如， 寫一個數據遠程備份程序，分為三步，本地打包，上傳到云服務器， 測試備份文件可用性。
def cloud_upload(file):
print("\nconnecting cloud storage center...")
print("cloud storage connected.")
print("upload file...xxx..to cloud...", file)
print('close connection.....')
def data_backup(folder):
print("找到要備份的目錄...", folder)
print("將備份文件打包，移至相應目錄...")
return '/tmp/backup20181103.zip'
def data_backup_test():
print("\n從另外一臺機器將備份文件從遠程cloud center下載，看文件是否無損")
def main():
zip_file = data_backup("c:\\users\\alex\歐美100G高清無碼")
cloud_upload(zip_file)
data_backup_test()
if __name__ == '__main__':
main()
但是如果需求改變,那你寫的子過程也需要修改,又如果又有其它子進程依賴這個子過程,那就會發成一連串的影響,隨著程序越來越大,這種編程方式的維護難度會越來越高.如果你要處理的任務是復雜的,且需要不斷迭代和維護的,還是使用面向對象方便.
面向對象編程(object oriented programming)
假設你現在視一家游戲公司的開發人員,需要你開發一款叫做"人狗大戰"的游戲,怎么描述這種不同的角色和他們的功能呢?
person = {
"name": "Alex",
"attack": 100,
"life_value": 1000
}
dog = {
"name": "Peiqi",
"attack": 200,
"life_value": 800
但是這樣是有問題的，因為如果你的字典的值不小心定義錯了，吧attack寫成了atteck，整個程序就有問題。所以你很快想出改進方案， 把字典放進函數：
def person(name,attack,life_value):
data = {
'name':name,
'attack':attack,
'life_value':life_value,
}
return data
def dog(name, attack, life_value):
data = {
'name': name,
'attack': attack,
'life_value': life_value,
}
return data
alex = person("Alex",100,1000)
rain = person("Black girl",80,700)
d = dog("PeiQi",200,800)
這樣的話，角色定義好了，還差每個角色的功能，人打狗，狗咬人的功能要定義出來
def attack(p,d):
"""人打狗功能"""
d['life_value'] -= p['attack'] #被打了，要掉血
print("人[%s] 打了 狗[%s]。。。,[%s]的生命值還有[%s]" % (p['name'], d['name'],d['name'],d['life_value']))
def bite(d,p):
"""狗咬人功能"""
p['life_value'] -= d['attack']
print("狗[%s] 咬了 人[%s]。。。,[%s]的生命值還有[%s]" % (d['name'], p['name'],p['name'],p['life_value']))
alex = person("Alex",100,1000)
black_girl = person("Black girl",80,700)
d = dog("PeiQi",200,800)
attack(alex,d)
bite(d,black_girl)
現在，就可以開心的玩耍啦。。。
但玩著玩著， 你不小心調用錯了，
你讓我咬black_girl一口我不介意，但以狗的身份，我是反對的，所以這明顯是個bug,bite()功能是狗專屬的，不應該允許人調用，這可怎么辦呢？
哈，想了一會，你又搞定了。
def person(name,attack_val,life_value):
def attack( d):
"""人打狗功能"""
d['life_value'] -= attack_val # 被打了，要掉血
print("人[%s] 打了 狗[%s]。。。,[%s]的生命值還有[%s]" % (name, d['name'], d['name'], d['life_value']))
data = {
'name':name,
'attack_val':attack_val,
'life_value':life_value,
'attack':attack
}
return data
def dog(name, attack_val, life_value):
def bite(p):
"""狗咬人功能"""
p['life_value'] -= attack_val
print("狗[%s] 咬了 人[%s]。。。,[%s]的生命值還有[%s]" % (name, p['name'], p['name'], p['life_value']))
data = {
'name': name,
'attack_val': attack_val,
'life_value': life_value,
'bite':bite
}
return data
alex = person("Alex",100,1000)
black_girl = person("Black girl",80,700)
d = dog("PeiQi",200,800)
alex['attack'](d)
d['bite'](black_girl)
你是如此的機智，這樣就實現了限制人只能用人自己的功能啦。
但，我的哥，不要高興太早，剛才你只是阻止了兩個完全 不同的角色 之間的功能混用， 但有沒有可能 ，同一個種角色，但有些屬性是不同的呢？ 比如 ，現在游戲升級了，不僅可以打狗，還可以生孩子，但男人不能生呀，只能女的生，怎么辦呢？你想了想說，簡單呀， 在person函數里包一個子函數叫get_birth(),
def get_birth(person_data):
if person_data['sex'] == 'female':
print("%s生孩子 啦..."% person_data['name'] )
else:
print("你是男的生個毛線.")
沒錯， 這雖然解決了只能女人生孩子的問題，但其實隨著游戲功能越來越多，你會發出男女之間的區別也越來越多 ，但又同時有很多共性，如果 在每個區別處都 單獨做判斷，那得累死。
你想了想說， 那就直接寫2個角色吧， 反正 這么多區別， 我的哥， 不能寫兩個角色呀，因為他們還有很多共性 ， 寫兩個不同的角色，就代表 相同的功能 也要重寫了，是不是我的哥？ 。。。 沒話說了吧？哈哈， 就是要逼你到絕路上。
上面的問題通過面向對象編程可輕松解決！
什么是面向對象編程？
OOP（Object Oriented Programming）編程是利用“類”和“對象”來創建模型實現對真實世界的描述。-
為什么要使用面向對象？
- 使程序更加容易擴展和易修改，使開發效率變得更高。
- 基于面向對象的程序可以使他人更加容易理解你的代碼邏輯
-
面向對象常用名詞
- 類： 一個類就是對一類有相同屬性的對象的抽象、藍圖、原型、模板。
- 屬性： 人類包括很多特征，把這些特征用程序來描述的話，就叫做屬性。在一個類中，可以有多個屬性。
- 方法： 人類不止有身高、年齡、性別這些屬性，還能做很多事情，比如說話、走路、吃飯等，這些動詞用程序來描述就叫做方法。
- 實例（對象）： 一個對象就是一個類實例化后的實例。
- 實例化： 把一個類轉變成一個對象發的過程就叫做實例化
-
面向對象的三大特征
- Encapsulation 封裝 在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，里面包含類的數據和方法
- Inherittance 繼承 一個類可以派生出子類，在這個父類里定義的屬性、方法自動被子類繼承。
- Polymorphism 多態 多態是面向對象的重要特征，簡單點說“一個接口，多種實現”，一個基類中派生出了不同的子類，且每個子類繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出來的多種形態。
類與對象
類與對象的概念
類即類別、種類，是面向對象設計最重要的概念，從一小節我們得知對象是特征與技能的結合體，而類則是一系列對象相似的特征與技能的結合體。
那么問題來了，先有的一個個具體存在的對象（比如一個具體存在的人），還是先有的人類這個概念，這個問題需要分兩種情況去看：
- 在現實世界中：肯定是先有對象，再有類
- 在程序中：務必保證先定義類，后產生對象
定義類
按照上述步驟，我們來定義一個類：
- 在現實世界中，先有對象，再有類
對象1：李坦克
特征:
學校=oldboy
姓名=李坦克
性別=男
年齡=18
技能：
學習
吃飯
睡覺
對象2：王大炮
特征:
學校=oldboy
姓名=王大炮
性別=女
年齡=38
技能：
學習
吃飯
睡覺
對象3：牛榴彈
特征:
學校=oldboy
姓名=牛榴彈
性別=男
年齡=78
技能：
學習
吃飯
睡覺
現實中的學生類
相似的特征:
學校=oldboy
相似的技能：
學習
吃飯
睡覺
- 在程序中，務必保證：先定義（類），后使用類（用來產生對象）
#在Python中程序中的類用class關鍵字定義，而在程序中特征用變量標識，技能用函數標識，因而類中最常見的無非是：變量和函數的定義
class OldboyStudent:
school='oldboy'
def learn(self):
print('is learning')
def eat(self):
print('is eating')
def sleep(self):
print('is sleeping')
注意：
- 類中可以有任意python代碼， 這類代碼在類定義階段會執行，因而會產生新的名稱空間，用來存放類的變量名和函數名，可以通過
類名.__dict__查看 - 類中定義的名字，都是類的屬性，點事訪問屬性的語法。
- 對于經典類來說我們都可通過該字典操作類名稱空間的名字，但新式類有限制
類的使用
- 引用類的屬性
OldboyStudent.school # 查
OldboyStudent.school='Oldboy' #改
OldboyStudent.x=1 #增
del OldboyStudent.x #刪
- 調用類，或稱為實例化，得到程序中的對象
s1=OldboyStudent()
s2=OldboyStudent()
s3=OldboyStudent()
#如此，s1、s2、s3都一樣了，而這三者除了相似的屬性之外還各種不同的屬性，這就用到了__init__
-
__init__方法
#注意：該方法是在對象產生之后才會執行，只用來為對象進行初始化操作，可以有任意代碼，但一定不能有返回值
class OldboyStudent:
......
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
......
s1=OldboyStudent('李坦克','男',18) #先調用類產生空對象s1，然后調用OldboyStudent.__init__(s1,'李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴彈','男',78)
對象的使用
#執行__init__,s1.name='牛榴彈'，很明顯也會產生對象的名稱空間可以用s2.__dict__查看，查看結果為
{'name': '王大炮', 'age': '女', 'sex': 38}
s2.name #查，等同于s2.__dict__['name']
s2.name='王三炮' #改，等同于s2.__dict__['name']='王三炮'
s2.course='python' #增，等同于s2.__dict__['course']='python'
del s2.course #刪，等同于s2.__dict__.pop('course')
補充說明
- 站的角度不同，定義的類是截然不同的；
- 現實中的類并不完全等于程序中的類，比如現實中的公司類，在程序中有時需要拆分成部門類，業務類等；
- 有時為了編程需求，程序中也可能會定義現實中不存在的類，比如策略類
屬性查找與綁定方法
屬性查找
類有兩種屬性： 數據屬性和函數屬性
- 類的數據屬性是對所有對象共享的
# 類的數據屬性是所有對象共享的，id都一樣
print(id(OldboyStudent.school))
# 下面print結果都一致
print(id(s1.school))
print(id(s2.school))
print(id(s3.school))
- 類的函數數據是綁定給對象使用的， 稱為綁定到對象的方法：
# 類的函數屬性書綁定給對象使用的，obj.method稱為綁定方法，內存地址都不一樣
print(OldboyStudent.learn) #<function OldboyStudent.learn at 0x1021329d8>
print(s1.learn) #<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x1021466d8>>
print(s2.learn) #<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146710>>
print(s3.learn) #<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146748>>
#ps:id是python的實現機制,并不能真實反映內存地址,如果有內存地址,還是以內存地址為準
在obj.name會先從obj自己的名稱空間概念里面找name，找不到則去類中找，類也找不到就去父類。。。最后都找不到就拋出異常
綁定方法
定義類并實例化三個對象
class OldboyStudent:
school='oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def learn(self):
print('%s is learning' %self.name) #新增self.name
def eat(self):
print('%s is eating' %self.name)
def sleep(self):
print('%s is sleeping' %self.name)
s1=OldboyStudent('李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴彈','男',78)
類中定義的函數（沒有被任何裝飾器裝飾的）是類的函數屬性，類可以使用，但必須遵循函數的參數規則，有幾個參數需要傳幾個參數:
OldboyStudent.learn(s1) #李坦克 is learning
OldboyStudent.learn(s2) #王大炮 is learning
OldboyStudent.learn(s3) #牛榴彈 is learning
類中定義的函數（沒有被任何裝飾器裝飾的）,其實主要是給對象使用的，而且是綁定到對象的，雖然所有對象指向的都是相同的功能，但是綁定到不同的對象就是不同的綁定方法。
強調：綁定到對象的方法的特殊之處在于，綁定給誰就由誰來調用，誰來調用，就會將‘誰’本身當做第一個參數傳給方法，即自動傳值（方法init也是一樣的道理）。
s1.learn() #等同于OldboyStudent.learn(s1)
s2.learn() #等同于OldboyStudent.learn(s2)
s3.learn() #等同于OldboyStudent.learn(s3)
注意：綁定到對象的方法的這種自動傳值的特征，決定了在類中定義的函數都要默認寫一個參數self，self可以是任意名字，但是約定俗成地寫出self。
類即類型
python中一切皆對象，且python3中類和類型是一個概念，類型就是類：
#類型dict就是類dict
>>> list
<class 'list'>
#實例化的到3個對象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()
#三個對象都有綁定方法append,是相同的功能,但內存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>
#操作綁定方法l1.append(3),就是在往l1添加3,絕對不會將3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#調用類list.append(l3,111)等同于l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111]
小節練習
練習1：編寫一個學生類，產生一堆學生對象， (5分鐘)
要求：
- 有一個計數器（屬性），統計總共實例了多少個對象
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-26 下午9:59
# @File : counter_test.py
class Counter():
count = 0
def __init__(self):
Counter.count += 1
c1 = Counter()
c2 = Counter()
print(Counter.count)
練習2：模仿王者榮耀定義兩個英雄類， (10分鐘)
要求：
- 英雄需要有昵稱、攻擊力、生命值等屬性；
- 實例化出兩個英雄對象；
- 英雄之間可以互毆，被毆打的一方掉血，血量小于0則判定為死亡。
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-26 下午10:04
# @File : heroes.py
class Heroes():
def __init__(self, name, attack, life):
self.name = name
self.attack = attack
self.life = life
self.status = "alive"
def hit(self, hero):
if not isinstance(hero, Heroes):
print("攻擊目標必須為英雄.")
return
hero.life -= self.attack
print("%s攻擊%s,造成%s點傷害..." % (self.name, hero.name, self.attack))
if hero.life <= 0:
print("%s已經被%s擊殺..." % (hero.name, self.name))
hero.life = 0
hero.status = "die"
def __str__(self):
rt = "英雄名: %s 攻擊力: %s 生命值: %s 狀態： %s " % (
self.name,
self.attack,
self.life,
self.status
)
return rt
h1 = Heroes("關羽", 97, 1000)
h2 = Heroes("夏侯惇", 92, 1200)
print(h1)
h1.hit(h2)
h2.hit(h1)
print(h1)
繼承與派生
繼承
什么是繼承？
繼承指的是類與類之間的關系，是一種什么是什么的關系，繼承的功能之一就是來解決代碼重用問題。
繼承是一種創建新類的方式，在python中，新建類可以繼承一個或多個父類， 父類有可以成為基類或超累，新建的類稱為派生類或子類。
- python中的繼承分為： 單繼承和多繼承
class ParentClass1: #定義父類
pass
class ParentClass2: #定義父類
pass
class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
pass
- 查看繼承
>>> SubClass1.__bases__ #__base__只查看從左到右繼承的第一個子類，__bases__則是查看所有繼承的父類
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
經典類與新式類(關于新式類與經典類的區別，我們稍后討論)
1.只有在python2中才分新式類和經典類，python3中統一都是新式類
2.在python2中，沒有顯式的繼承object類的類，以及該類的子類，都是經典類
3.在python2中，顯式地聲明繼承object的類，以及該類的子類，都是新式類
4.在python3中，無論是否繼承object，都默認繼承object，即python3中所有類均為新式類
提示：如果沒有指定基類，python的類會默認繼承object類，object是所有python類的基類，它提供了一些常見方法（如__str__）的實現。
>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)
繼承與抽象（先抽象再繼承）
抽象即抽取類似或者說比較像的部分。
抽象分成兩個層次：
1.將奧巴馬和梅西這倆對象比較像的部分抽取成類；
2.將人，豬，狗這三個類比較像的部分抽取成父類。
抽象最主要的作用是劃分類別（可以隔離關注點，降低復雜度）
image.png
繼承：是基于抽象的結果，通過編程語言去實現它，肯定是先經歷抽象這個過程，才能通過繼承的方式去表達出抽象的結構。
抽象只是分析和設計的過程中，一個動作或者說一種技巧，通過抽象可以得到類:
image.png
繼承與重用
在開發程序的過程中，如果我們定義了一個類A，然后又想新建立另外一個類B，但是類B的大部分內容與類A的相同時
我們不可能從頭開始寫一個類B，這就用到了類的繼承的概念。
通過繼承的方式新建類B，讓B繼承A，B會‘遺傳’A的所有屬性(數據屬性和函數屬性)，實現代碼重用
class Hero:
def __init__(self,nickname,aggressivity,life_value):
self.nickname=nickname
self.aggressivity=aggressivity
self.life_value=life_value
def move_forward(self):
print('%s move forward' %self.nickname)
def move_backward(self):
print('%s move backward' %self.nickname)
def move_left(self):
print('%s move forward' %self.nickname)
def move_right(self):
print('%s move forward' %self.nickname)
def attack(self,enemy):
enemy.life_value-=self.aggressivity
class Garen(Hero):
pass
class Riven(Hero):
pass
g1=Garen('草叢倫',100,300)
r1=Riven('銳雯雯',57,200)
print(g1.life_value) #結果:300
r1.attack(g1)
print(g1.life_value) #結果:243
提示：用已經有的類建立一個新的類，這樣就重用了已經有的軟件中的一部分設置大部分，大大節省了編程工作量，這就是常說的軟件重用，不僅可以重用自己的類，也可以繼承別人的，比如標準庫，來定制新的數據類型，這樣就是大大縮短了軟件開發周期，對大型軟件開發來說，意義重大.
再看屬性查找
提示：像g1.life_value之類的屬性引用，會先從實例中找life_value然后去類中找，然后再去父類中找...直到最頂級的父類。那么如何解釋下面的打印結果呢？
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Foo.f1')
b=Bar()
b.f2()
# 打印結果:
# Foo.f2
# Foo.f1
派生
當然子類也可以添加自己新的屬性或者在自己這里重新定義這些屬性（不會影響到父類），需要注意的是，一旦重新定義了自己的屬性且與父類重名，那么調用新增的屬性時，就以自己為準了。
class Riven(Hero):
camp='Noxus'
def attack(self,enemy): #在自己這里定義新的attack,不再使用父類的attack,且不會影響父類
print('from riven')
def fly(self): #在自己這里定義新的
print('%s is flying' %self.nickname)
在子類中，新建的重名的函數屬性，在編輯函數內功能的時候，有可能需要重用父類中重名的那個函數功能，應該是用調用普通函數的方式，即：類名.func()，此時就與調用普通函數無異了，因此即便是self參數也要為其傳值
class Riven(Hero):
camp='Noxus'
def __init__(self,nickname,aggressivity,life_value,skin):
Hero.__init__(self,nickname,aggressivity,life_value) #調用父類功能
self.skin=skin #新屬性
def attack(self,enemy): #在自己這里定義新的attack,不再使用父類的attack,且不會影響父類
Hero.attack(self,enemy) #調用功能
print('from riven')
def fly(self): #在自己這里定義新的
print('%s is flying' %self.nickname)
r1=Riven('銳雯雯',57,200,'比基尼')
r1.fly()
print(r1.skin)
'''
運行結果
銳雯雯 is flying
比基尼
'''
繼承的實現原理
python到底是如何實現繼承的，對于你定義的每一個類，python會計算出一個方法解析順序(MRO)列表，這個MRO列表就是一個簡單的所有基類的線性順序列表，例如
>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>,
<class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
為了實現繼承,python會在MRO列表上從左到右開始查找基類,直到找到第一個匹配這個屬性的類為止。而這個MRO列表的構造是通過一個C3線性化算法來實現的。我們不去深究這個算法的數學原理,它實際上就是合并所有父類的MRO列表并遵循如下三條準則:
- 子類會先于父類被檢查
- 多個父類會根據它們在列表中的順序被檢查
-
如果對下一個類存在兩個合法的選擇,選擇第一個父類
在Java和C#中子類只能繼承一個父類，而Python中子類可以同時繼承多個父類，如果繼承了多個父類，那么屬性的查找方式有兩種，分別是：深度優先和廣度優先
image.png
image.png
示范代碼:
class A(object):
def test(self):
print('from A')
class B(A):
def test(self):
print('from B')
class C(A):
def test(self):
print('from C')
class D(B):
def test(self):
print('from D')
class E(C):
def test(self):
print('from E')
class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有這個屬性可以查看線性列表，經典類沒有這個屬性
#新式類繼承順序:F->D->B->E->C->A
#經典類繼承順序:F->D->B->A->E->C
#python3中統一都是新式類
#pyhon2中才分新式類與經典類
在子類中調用父類的方法
在子類派生出的新方法中，往往需要重用父類的方法，我們有兩種方式實現:
方式一：指名道姓，即父類名.父類方法()
class Vehicle: #定義交通工具類
Country='China'
def __init__(self,name,speed,load,power):
self.name=name
self.speed=speed
self.load=load
self.power=power
def run(self):
print('開動啦...')
class Subway(Vehicle): #地鐵
def __init__(self,name,speed,load,power,line):
Vehicle.__init__(self,name,speed,load,power)
self.line=line
def run(self):
print('地鐵%s號線歡迎您' %self.line)
Vehicle.run(self)
line13=Subway('中國地鐵','180m/s','1000人/箱','電',13)
line13.run()
方式二：super()
class Vehicle: #定義交通工具類
Country='China'
def __init__(self,name,speed,load,power):
self.name=name
self.speed=speed
self.load=load
self.power=power
def run(self):
print('開動啦...')
class Subway(Vehicle): #地鐵
def __init__(self,name,speed,load,power,line):
#super(Subway,self) 就相當于實例本身 在python3中super()等同于super(Subway,self)
super().__init__(name,speed,load,power)
self.line=line
def run(self):
print('地鐵%s號線歡迎您' %self.line)
super(Subway,self).run()
class Mobike(Vehicle):#摩拜單車
pass
line13=Subway('中國地鐵','180m/s','1000人/箱','電',13)
line13.run()
這兩種方式的區別是：方式一是跟繼承沒有關系的，而方式二的super()是依賴于繼承的，并且即使沒有直接繼承關系，super仍然會按照mro繼續往后查找
#A沒有繼承B,但是A內super會基于C.mro()繼續往后找
class A:
def test(self):
super().test()
class B:
def test(self):
print('from B')
class C(A,B):
pass
c=C()
c.test() #打印結果:from B
print(C.mro())
#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
組合
組合與重用性
軟件重用的重要方式除了繼承之外還有另外一種方式，即：組合
組合指的是，在一個類中以另外一個類的對象作為數據屬性，稱為類的組合
>>> class Equip: #武器裝備類
... def fire(self):
... print('release Fire skill')
...
>>> class Riven: #英雄Riven的類,一個英雄需要有裝備,因而需要組合Equip類
... camp='Noxus'
... def __init__(self,nickname):
... self.nickname=nickname
... self.equip=Equip() #用Equip類產生一個裝備,賦值給實例的equip屬性
...
>>> r1=Riven('銳雯雯')
>>> r1.equip.fire() #可以使用組合的類產生的對象所持有的方法
release Fire skill
組合與繼承都是有效地利用已有類的資源的重要方式。但是二者的概念和使用場景皆不同，
- 繼承的方式
通過繼承建立了派生類與基類之間的關系，它是一種'是'的關系，比如白馬是馬，人是動物。
當類之間有很多相同的功能，提取這些共同的功能做成基類，用繼承比較好，比如老師是人，學生是人 - 組合的方式
用組合的方式建立了類與組合的類之間的關系，它是一種‘有’的關系,比如教授有生日，教授教python和linux課程，教授有學生s1、s2、s3...
示例：繼承與組合
class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Course:
def __init__(self,name,period,price):
self.name=name
self.period=period
self.price=price
def tell_info(self):
print('<%s %s %s>' %(self.name,self.period,self.price))
class Teacher(People):
def __init__(self,name,age,sex,job_title):
People.__init__(self,name,age,sex)
self.job_title=job_title
self.course=[]
self.students=[]
class Student(People):
def __init__(self,name,age,sex):
People.__init__(self,name,age,sex)
self.course=[]
egon=Teacher('egon',18,'male','沙河霸道金牌講師')
s1=Student('牛榴彈',18,'female')
python=Course('python','3mons',3000.0)
linux=Course('python','3mons',3000.0)
#為老師egon和學生s1添加課程
egon.course.append(python)
egon.course.append(linux)
s1.course.append(python)
#為老師egon添加學生s1
egon.students.append(s1)
#使用
for obj in egon.course:
obj.tell_info()
總結：
當類之間有顯著不同，并且較小的類是較大的類所需要的組件時，用組合比較好
抽象類
接口與歸一化設計
1.什么是接口
hi boy，給我開個查詢接口。。。此時的接口指的是：自己提供給使用者來調用自己功能的方式\方法\入口，java中的interface使用如下
=================第一部分：Java 語言中的接口很好的展現了接口的含義: IAnimal.java
/*
* Java的Interface接口的特征:
* 1)是一組功能的集合,而不是一個功能
* 2)接口的功能用于交互,所有的功能都是public,即別的對象可操作
* 3)接口只定義函數,但不涉及函數實現
* 4)這些功能是相關的,都是動物相關的功能,但光合作用就不適宜放到IAnimal里面了 */
package com.oo.demo;
public interface IAnimal {
public void eat();
public void run();
public void sleep();
public void speak();
}
=================第二部分：Pig.java：豬”的類設計,實現了IAnnimal接口
package com.oo.demo;
public class Pig implements IAnimal{ //如下每個函數都需要詳細實現
public void eat(){
System.out.println("Pig like to eat grass");
}
public void run(){
System.out.println("Pig run: front legs, back legs");
}
public void sleep(){
System.out.println("Pig sleep 16 hours every day");
}
public void speak(){
System.out.println("Pig can not speak"); }
}
=================第三部分：Person2.java
/*
*實現了IAnimal的“人”,有幾點說明一下:
* 1)同樣都實現了IAnimal的接口,但“人”和“豬”的實現不一樣,為了避免太多代碼導致影響閱讀,這里的代碼簡化成一行,但輸出的內容不一樣,實際項目中同一接口的同一功能點,不同的類實現完全不一樣
* 2)這里同樣是“人”這個類,但和前面介紹類時給的類“Person”完全不一樣,這是因為同樣的邏輯概念,在不同的應用場景下,具備的屬性和功能是完全不一樣的 */
package com.oo.demo;
public class Person2 implements IAnimal {
public void eat(){
System.out.println("Person like to eat meat");
}
public void run(){
System.out.println("Person run: left leg, right leg");
}
public void sleep(){
System.out.println("Person sleep 8 hours every dat");
}
public void speak(){
System.out.println("Hellow world, I am a person");
}
}
=================第四部分：Tester03.java
package com.oo.demo;
public class Tester03 {
public static void main(String[] args) {
System.out.println("===This is a person===");
IAnimal person = new Person2();
person.eat();
person.run();
person.sleep();
person.speak();
System.out.println("\n===This is a pig===");
IAnimal pig = new Pig();
pig.eat();
pig.run();
pig.sleep();
pig.speak();
}
}
java中的interface
2. 為何要用接口
接口提取了一群類共同的函數，可以把接口當做一個函數的集合。
然后讓子類去實現接口中的函數。
這么做的意義在于歸一化，什么叫歸一化，就是只要是基于同一個接口實現的類，那么所有的這些類產生的對象在使用時，從用法上來說都一樣。
歸一化的好處在于：
- 歸一化讓使用者無需關心對象的類是什么，只需要的知道這些對象都具備某些功能就可以了，這極大地降低了使用者的使用難度。
- 歸一化使得高層的外部使用者可以不加區分的處理所有接口兼容的對象集合
- 就好象linux的泛文件概念一樣，所有東西都可以當文件處理，不必關心它是內存、磁盤、網絡還是屏幕（當然，對底層設計者，當然也可以區分出“字符設備”和“塊設備”，然后做出針對性的設計：細致到什么程度，視需求而定）。
- 再比如：我們有一個汽車接口，里面定義了汽車所有的功能，然后由本田汽車的類，奧迪汽車的類，大眾汽車的類，他們都實現了汽車接口，這樣就好辦了，大家只需要學會了怎么開汽車，那么無論是本田，還是奧迪，還是大眾我們都會開了，開的時候根本無需關心我開的是哪一類車，操作手法（函數調用）都一樣
3. 模仿interface
在python中根本就沒有一個叫做interface的關鍵字，如果非要去模仿接口的概念
可以借助第三方模塊：http://pypi.python.org/pypi/zope.interface
也可以使用繼承，其實繼承有兩種用途
一：繼承基類的方法，并且做出自己的改變或者擴展（代碼重用）：實踐中，繼承的這種用途意義并不很大，甚至常常是有害的。因為它使得子類與基類出現強耦合。
二：聲明某個子類兼容于某基類，定義一個接口類（模仿java的Interface），接口類中定義了一些接口名（就是函數名）且并未實現接口的功能，子類繼承接口類，并且實現接口中的功能
class Interface:#定義接口Interface類來模仿接口的概念，python中壓根就沒有interface關鍵字來定義一個接口。
def read(self): #定接口函數read
pass
def write(self): #定義接口函數write
pass
class Txt(Interface): #文本，具體實現read和write
def read(self):
print('文本數據的讀取方法')
def write(self):
print('文本數據的讀取方法')
class Sata(Interface): #磁盤，具體實現read和write
def read(self):
print('硬盤數據的讀取方法')
def write(self):
print('硬盤數據的讀取方法')
class Process(Interface):
def read(self):
print('進程數據的讀取方法')
def write(self):
print('進程數據的讀取方法')
上面的代碼只是看起來像接口，其實并沒有起到接口的作用，子類完全可以不用去實現接口 ，這就用到了抽象類
抽象類
1.什么是抽象類
與java一樣，python也有抽象類的概念，但是同樣需要借助模塊實現，抽象類是一個特殊的類，他的特殊之處在于只能被繼承，不能被實例化。
2.為什么要有抽象類
如果說類是從一堆對象中抽取相同的內容而來的，那么抽象類就是從一堆類中抽取相同的內容而來的，內容包括數據屬性和函數屬性。
- 比如我們有香蕉的類，有蘋果的類，有桃子的類，從這些類抽取相同的內容就是水果這個抽象的類，你吃水果時，要么是吃一個具體的香蕉，要么是吃一個具體的桃子。。。。。。你永遠無法吃到一個叫做水果的東西。
- 從設計角度去看，如果類是從現實對象抽象而來的，那么抽象類就是基于類抽象而來的。
- 從實現角度來看，抽象類與普通類的不同之處在于：抽象類中只能有抽象方法（沒有實現功能），該類不能被實例化，只能被繼承，且子類必須實現抽象方法。這一點與接口有點類似，但其實是不同的，即將揭曉答案
3. 在python中實現抽象類
#一切皆文件
import abc #利用abc模塊實現抽象類
class All_file(metaclass=abc.ABCMeta):
all_type='file'
@abc.abstractmethod #定義抽象方法，無需實現功能
def read(self):
'子類必須定義讀功能'
pass
@abc.abstractmethod #定義抽象方法，無需實現功能
def write(self):
'子類必須定義寫功能'
pass
# class Txt(All_file):
# pass
#
# t1=Txt() #報錯,子類沒有定義抽象方法
class Txt(All_file): #子類繼承抽象類，但是必須定義read和write方法
def read(self):
print('文本數據的讀取方法')
def write(self):
print('文本數據的讀取方法')
class Sata(All_file): #子類繼承抽象類，但是必須定義read和write方法
def read(self):
print('硬盤數據的讀取方法')
def write(self):
print('硬盤數據的讀取方法')
class Process(All_file): #子類繼承抽象類，但是必須定義read和write方法
def read(self):
print('進程數據的讀取方法')
def write(self):
print('進程數據的讀取方法')
wenbenwenjian=Txt()
yingpanwenjian=Sata()
jinchengwenjian=Process()
#這樣大家都是被歸一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()
print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)
4. 抽象類與接口
抽象類的本質還是類，指的是一組類的相似性，包括數據屬性（如all_type）和函數屬性（如read、write），而接口只強調函數屬性的相似性。
抽象類是一個介于類和接口直接的一個概念，同時具備類和接口的部分特性，可以用來實現歸一化設計
多態與多態性
多態
多態指的是一類事物有多種形態，比如
動物有多種形態：人，狗，豬
import abc
class Animal(metaclass=abc.ABCMeta): #同一類事物:動物
@abc.abstractmethod
def talk(self):
pass
class People(Animal): #動物的形態之一:人
def talk(self):
print('say hello')
class Dog(Animal): #動物的形態之二:狗
def talk(self):
print('say wangwang')
class Pig(Animal): #動物的形態之三:豬
def talk(self):
print('say aoao')
文件有多種形態：文本文件，可執行文件
import abc
class File(metaclass=abc.ABCMeta): #同一類事物:文件
@abc.abstractmethod
def click(self):
pass
class Text(File): #文件的形態之一:文本文件
def click(self):
print('open file')
class ExeFile(File): #文件的形態之二:可執行文件
def click(self):
print('execute file')
多態性
什么是多態動態綁定 (在繼承的背景下使用時，有時也成為多態性）
多態性是指在不考慮實例的情況下使用實例，多態性分為靜態多態性和動態多態性。
靜態多態性：如任何類型都可以使用運算符+進行運算
動態多態性如下：
peo=People()
dog=Dog()
pig=Pig()
#peo、dog、pig都是動物,只要是動物肯定有talk方法
#于是我們可以不用考慮它們三者的具體是什么類型,而直接使用
peo.talk()
dog.talk()
pig.talk()
#更進一步,我們可以定義一個統一的接口來使用
def func(obj):
obj.talk()
為什么要用多態性（多態性的好處）
其實大家從上面多態性的例子可以看出，我們并沒有增加什么新的知識，也就是說python本身就是支持多態性的，這么做的好處是什么呢？
- 增加了程序的靈活性
以不變應萬變，不論對象千變萬化，使用者都是同一種形式去調用，如func(animal) - 增加了程序額可擴展性
通過繼承animal類創建了一個新的類，使用者無需更改自己的代碼，還是用func(animal)去調用
>>> class Cat(Animal): #屬于動物的另外一種形態：貓
... def talk(self):
... print('say miao')
...
>>> def func(animal): #對于使用者來說，自己的代碼根本無需改動
... animal.talk()
...
>>> cat1=Cat() #實例出一只貓
>>> func(cat1) #甚至連調用方式也無需改變，就能調用貓的talk功能
say miao
'''
這樣我們新增了一個形態Cat，由Cat類產生的實例cat1，使用者可以在完全不需要修改自己代碼的情況下。使用和人、狗、豬一樣的方式調用cat1的talk方法，即func(cat1)
'''
鴨子類型
逗比時刻：
Python崇尚鴨子類型，即‘如果看起來像、叫聲像而且走起路來像鴨子，那么它就是鴨子’
python程序員通常根據這種行為來編寫程序。例如，如果想編寫現有對象的自定義版本，可以繼承該對象
也可以創建一個外觀和行為像，但與它無任何關系的全新對象，后者通常用于保存程序組件的松耦合度。
例1：利用標準庫中定義的各種‘與文件類似’的對象，盡管這些對象的工作方式像文件，但他們沒有繼承內置文件對象的方法
#二者都像鴨子,二者看起來都像文件,因而就可以當文件一樣去用
class TxtFile:
def read(self):
pass
def write(self):
pass
class DiskFile:
def read(self):
pass
def write(self):
pass
例2：序列類型有多種形態：字符串，列表，元組，但他們直接沒有直接的繼承關系
#str,list,tuple都是序列類型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))
#我們可以在不考慮三者類型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()
len(s)
len(l)
len(t)
封裝
從封裝本身的意思去理解，封裝就好像是拿來一個麻袋，把小貓，小狗，小王八，還有alex一起裝進麻袋，然后把麻袋封上口子。照這種邏輯看，封裝=‘隱藏’，這種理解是相當片面的。
先看如何隱藏
在python中用雙下劃線開頭的方式將屬性隱藏起來（設置成私有的）
#其實這僅僅這是一種變形操作
#類中所有雙下劃線開頭的名稱如__x都會自動變形成：_類名__x的形式：
class A:
__N=0 #類的數據屬性就應該是共享的,但是語法上是可以把類的數據屬性設置成私有的如__N,會變形為_A__N
def __init__(self):
self.__X=10 #變形為self._A__X
def __foo(self): #變形為_A__foo
print('from A')
def bar(self):
self.__foo() #只有在類內部才可以通過__foo的形式訪問到.
#A._A__N是可以訪問到的，即這種操作并不是嚴格意義上的限制外部訪問，僅僅只是一種語法意義上的變形
這種自動變形的特點：
- 類中定義的__x只能在內部使用，如self.__x，引用的就是變形的結果。
- 這種變形其實正是針對外部的變形，在外部是無法通過__x這個名字訪問到的。
- 在子類定義的__x不會覆蓋在父類定義的_x，因為子類中變形成了：子類名_x,而父類中變形成了：父類名__x，即雙下滑線開頭的屬性在繼承給子類時，子類是無法覆蓋的。
這種變形需要注意的問題是：
- 這種機制也并沒有真正意義上限制我們從外部直接訪問屬性，知道了類名和屬性名就可以拼出名字：類名_屬性，然后就可以訪問了，如a._A__N
- 變形的過程只在類的定義是發生一次,在定義后的賦值操作，不會變形
- 在繼承中，父類如果不想讓子類覆蓋自己的方法，可以將方法定義為私有的
#正常情況
>>> class A:
... def fa(self):
... print('from A')
... def test(self):
... self.fa()
...
>>> class B(A):
... def fa(self):
... print('from B')
...
>>> b=B()
>>> b.test()
from B
#把fa定義成私有的，即__fa
>>> class A:
... def __fa(self): #在定義時就變形為_A__fa
... print('from A')
... def test(self):
... self.__fa() #只會與自己所在的類為準,即調用_A__fa
...
>>> class B(A):
... def __fa(self):
... print('from B')
...
>>> b=B()
>>> b.test()
from A
封裝不是單純意義的隱藏
將數據隱藏起來這不是目的。隱藏起來然后對外提供操作該數據的接口，然后我們可以在接口附加上對該數據操作的限制，以此完成對數據屬性操作的嚴格控制。
class Teacher:
def __init__(self,name,age):
self.__name=name
self.__age=age
def tell_info(self):
print('姓名:%s,年齡:%s' %(self.__name,self.__age))
def set_info(self,name,age):
if not isinstance(name,str):
raise TypeError('姓名必須是字符串類型')
if not isinstance(age,int):
raise TypeError('年齡必須是整型')
self.__name=name
self.__age=age
t=Teacher('egon',18)
t.tell_info()
t.set_info('egon',19)
t.tell_info()
封裝方法：目的是隔離復雜度
#取款是功能,而這個功能有很多功能組成:插卡、密碼認證、輸入金額、打印賬單、取錢
#對使用者來說,只需要知道取款這個功能即可,其余功能我們都可以隱藏起來,很明顯這么做
#隔離了復雜度,同時也提升了安全性
class ATM:
def __card(self):
print('插卡')
def __auth(self):
print('用戶認證')
def __input(self):
print('輸入取款金額')
def __print_bill(self):
print('打印賬單')
def __take_money(self):
print('取款')
def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()
a=ATM()
a.withdraw()
封裝方法的其他舉例：
- 你的身體沒有一處不體現著封裝的概念：你的身體把膀胱尿道等等這些尿的功能隱藏了起來，然后為你提供一個尿的接口就可以了（接口就是你的。。。，），你總不能把膀胱掛在身體外面，上廁所的時候就跟別人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。
- 電視機本身是一個黑盒子，隱藏了所有細節，但是一定會對外提供了一堆按鈕，這些按鈕也正是接口的概念，所以說，封裝并不是單純意義的隱藏！！！
- 快門就是傻瓜相機為傻瓜們提供的方法，該方法將內部復雜的照相功能都隱藏起來了
提示：在編程語言里，對外提供的接口（接口可理解為了一個入口），可以是函數，稱為接口函數，這與接口的概念還不一樣，接口代表一組接口函數的集合體。
特性（property）
什么是特性property
property是一種特殊的屬性，訪問它時會執行一段功能（函數）然后返回值
例一：BMI指數（bmi是計算而來的，但很明顯它聽起來像是一個屬性而非方法，如果我們將其做成一個屬性，更便于理解）
成人的BMI數值：
過輕：低于18.5
正常：18.5-23.9
過重：24-27
肥胖：28-32
非常肥胖, 高于32
體質指數（BMI）=體重（kg）÷身高^2（m）
EX：70kg÷（1.75×1.75）=22.86
class People:
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def bmi(self):
return self.weight / (self.height**2)
p1=People('egon',75,1.85)
print(p1.bmi)
例二：圓的周長和面積
import math
class Circle:
def __init__(self,radius): #圓的半徑radius
self.radius=radius
@property
def area(self):
return math.pi * self.radius**2 #計算面積
@property
def perimeter(self):
return 2*math.pi*self.radius #計算周長
c=Circle(10)
print(c.radius)
print(c.area) #可以向訪問數據屬性一樣去訪問area,會觸發一個函數的執行,動態計算出一個值
print(c.perimeter) #同上
'''
輸出結果:
314.1592653589793
62.83185307179586
'''
注意：此時的特性area和perimeter不能被賦值
c.area=3 #為特性area賦值
'''
拋出異常:
AttributeError: can't set attribute
'''
為什么要用property
將一個類的函數定義成特性以后，對象再去使用的時候obj.name,根本無法察覺自己的name是執行了一個函數然后計算出來的，這種特性的使用方式遵循了統一訪問的原則
除此之外，看下:
ps：面向對象的封裝有三種方式:
【public】
這種其實就是不封裝,是對外公開的
【protected】
這種封裝方式對外不公開,但對朋友(friend)或者子類(形象的說法是“兒子”,但我不知道為什么大家 不說“女兒”,就像“parent”本來是“父母”的意思,但中文都是叫“父類”)公開
【private】
這種封裝對誰都不公開
python并沒有在語法上把它們三個內建到自己的class機制中，在C++里一般會將所有的所有的數據都設置為私有的，然后提供set和get方法（接口）去設置和獲取，在python中通過property方法可以實現:
class Foo:
def __init__(self,val):
self.__NAME=val #將所有的數據屬性都隱藏起來
@property
def name(self):
return self.__NAME #obj.name訪問的是self.__NAME(這也是真實值的存放位置)
@name.setter
def name(self,value):
if not isinstance(value,str): #在設定值之前進行類型檢查
raise TypeError('%s must be str' %value)
self.__NAME=value #通過類型檢查后,將值value存放到真實的位置self.__NAME
@name.deleter
def name(self):
raise TypeError('Can not delete')
f=Foo('egon')
print(f.name)
# f.name=10 #拋出異常'TypeError: 10 must be str'
del f.name #拋出異常'TypeError: Can not delete'
封裝與擴展性
封裝在于明確區分內外，使得類實現者可以修改封裝內的東西而不影響外部調用者的代碼；而外部使用用者只知道一個接口(函數)，只要接口（函數）名、參數不變，使用者的代碼永遠無需改變。這就提供一個良好的合作基礎——或者說，只要接口這個基礎約定不變，則代碼改變不足為慮。
#類的設計者
class Room:
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
self.__width=width
self.__length=length
self.__high=high
def tell_area(self): #對外提供的接口，隱藏了內部的實現細節，此時我們想求的是面積
return self.__width * self.__length
#使用者
>>> r1=Room('臥室','egon',20,20,20)
>>> r1.tell_area() #使用者調用接口tell_area
#類的設計者，輕松的擴展了功能，而類的使用者完全不需要改變自己的代碼
class Room:
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
self.__width=width
self.__length=length
self.__high=high
def tell_area(self): #對外提供的接口，隱藏內部實現，此時我們想求的是體積,內部邏輯變了,只需求修該下列一行就可以很簡答的實現,而且外部調用感知不到,仍然使用該方法，但是功能已經變了
return self.__width * self.__length * self.__high
#對于仍然在使用tell_area接口的人來說，根本無需改動自己的代碼，就可以用上新功能
>>> r1.tell_area()
綁定方法與非綁定方法
類中定義的函數分成兩大類
綁定方法（綁定給誰，誰來調用就自動將它本身當做第一個參數傳入）
- 綁定到類的方法：用
classmethod裝飾器裝飾的方法。
為類量身定制
類.boud_method(),自動將類當作第一個參數傳入
（其實對象也可調用，但仍將類當作第一個參數傳入）
- 綁定到對象的方法：沒有被任何裝飾器裝飾的方法。
為對象量身定制
對象.boud_method(),自動將對象當作第一個參數傳入
（屬于類的函數，類可以調用，但是必須按照函數的規則來，沒有自動傳值那么一說）
非綁定方法： 用staticmethod裝飾器裝飾的方法
不與類或對象綁定，類和對象都可以調用，但是沒有自動傳值那么一說。就是一個普通工具而已
注意：與綁定到對象方法區分開，在類中直接定義的函數，沒有被任何裝飾器裝飾的，都是綁定到對象的方法，可不是普通函數，對象調用該方法會自動傳值，而staticmethod裝飾的方法，不管誰來調用，都沒有自動傳值一說
綁定方法
綁定給對象的方法（略）
綁定給類的方法（classmethod）
classmehtod是給類用的，即綁定到類，類在使用時會將類本身當做參數傳給類方法的第一個參數（即便是對象來調用也會將類當作第一個參數傳入），python為我們內置了函數classmethod來把類中的函數定義成類方法
#settings.py
HOST='127.0.0.1'
PORT=3306
DB_PATH=r'C:\Users\Administrator\PycharmProjects\test\面向對象編程\test1\db'
#test.py
import settings
class MySQL:
def __init__(self,host,port):
self.host=host
self.port=port
@classmethod
def from_conf(cls):
print(cls)
return cls(settings.HOST,settings.PORT)
print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()
conn.from_conf() #對象也可以調用，但是默認傳的第一個參數仍然是類
非綁定方法
在類內部用staticmethod裝飾的函數即非綁定方法，就是普通函數
staticmethod不與類或對象綁定，誰都可以調用，沒有自動傳值效果
import hashlib
import time
class MySQL:
def __init__(self,host,port):
self.id=self.create_id()
self.host=host
self.port=port
@staticmethod
def create_id(): #就是一個普通工具
m=hashlib.md5(str(time.time()).encode('utf-8'))
return m.hexdigest()
print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看結果為普通函數
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看結果為普通函數
classmethod與staticmethod的對比
import settings
class MySQL:
def __init__(self,host,port):
self.host=host
self.port=port
@staticmethod
def from_conf():
return MySQL(settings.HOST,settings.PORT)
# @classmethod #哪個類來調用,就將哪個類當做第一個參數傳入
# def from_conf(cls):
# return cls(settings.HOST,settings.PORT)
def __str__(self):
return '就不告訴你'
class Mariadb(MySQL):
def __str__(self):
return '<%s:%s>' %(self.host,self.port)
m=Mariadb.from_conf()
print(m) #我們的意圖是想觸發Mariadb.__str__,但是結果觸發了MySQL.__str__的執行，打印就不告訴你：
練習
練習1：定義MySQL類
要求：
- 對象有id、host、port三個屬性
- 定義工具create_id，在實例化時為每個對象隨機生成id，保證id唯一
- 提供兩種實例化方式，方式一：用戶傳入host和port 方式二：從配置文件中讀取host和port進行實例化
- 為對象定制方法，save和get_obj_by_id，save能自動將對象序列化到文件中，文件路徑為配置文件中DB_PATH,文件名為id號，保存之前驗證對象是否已經存在，若存在則拋出異常，;get_obj_by_id方法用來從文件中反序列化出對象
# my.cnf
[mysqld]
host = 127.0.0.1
port = 3066
DB_PATH = /home/fbo/PycharmProjects/fullstack/untitled1/Chapter5
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-27 下午9:20
# @File : mysql_test.py
import hashlib
import time
import os
import configparser
import pickle
class MySQL:
@staticmethod
def load_settings():
cnf = configparser.ConfigParser()
cnf.read("my.cnf")
return cnf
def __init__(self, *args):
self.id = self.creat_id()
if len(args) == 2:
self.host = args[0]
self.port = args[1]
else:
cnf = self.load_settings()
self.host = cnf['mysqld']['host']
self.port = cnf['mysqld']['port']
@staticmethod
def creat_id():
m = hashlib.md5(str(time.time()).encode(encoding="utf-8"))
return m.hexdigest()
@classmethod
def save(cls, obj):
file_path = os.path.join(cls.load_settings()["mysqld"]["DB_PATH"], obj.id)
# file_path = os.path.join(cls.load_settings()["mysqld"]["DB_PATH"], "123")
if os.path.isfile(file_path):
raise FileExistsError
with open(file_path, "wb") as f:
pickle.dump(obj, f)
@classmethod
def get_obj_by_id(cls, id):
file_path = os.path.join(cls.load_settings()["mysqld"]["DB_PATH"], id)
if not os.path.isfile(file_path):
raise FileNotFoundError
with open(file_path, "rb") as f:
rt = pickle.load(f)
return rt
my = MySQL()
my2 = MySQL("localhost", "3066")
print(my2.__dict__)
MySQL.save(my)
print(MySQL.get_obj_by_id('123').__dict__)
內置方法
isinstance(obj,cls)和issubclass(sub,super)
isinstance(obj,cls)檢查是否obj是否是類 cls 的對象
issubclass(sub, super)檢查sub類是否是 super 類的派生類
反射
什么是反射
反射的概念是由smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力（自省）。這一概念的提出很快引發了計算機科學領域關于應用反射性的研究。它首先被程序語言的設計領域所采用，并在Lisp和面向對象方面取得了成績。
python面向對象中的反射：通過字符串的形式操作對象相關的屬性。python中的一切事物都是對象（都可以使用反射）
四個可以實現自省的函數 下列方法適用于類和對象（一切皆對象，類本身也是一個對象）
hasattr(object, name)
判斷object中有沒有一個name字符串對應的方法或屬性
getattr(object, name, default=None)
def getattr(object, name, default=None): # known special case of getattr
"""
getattr(object, name[, default]) -> value
Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
When a default argument is given, it is returned when the attribute doesn't
exist; without it, an exception is raised in that case.
"""
pass
setattr(x, y, v)
def setattr(x, y, v): # real signature unknown; restored from __doc__
"""
Sets the named attribute on the given object to the specified value.
setattr(x, 'y', v) is equivalent to ``x.y = v''
"""
pass
delattr(x,y)
def delattr(x, y): # real signature unknown; restored from __doc__
"""
Deletes the named attribute from the given object.
delattr(x, 'y') is equivalent to ``del x.y''
"""
pass
四個方法的使用演示:
class BlackMedium:
feature='Ugly'
def __init__(self,name,addr):
self.name=name
self.addr=addr
def sell_house(self):
print('%s 黑中介賣房子啦,傻逼才買呢,但是誰能證明自己不傻逼' %self.name)
def rent_house(self):
print('%s 黑中介租房子啦,傻逼才租呢' %self.name)
b1=BlackMedium('萬成置地','回龍觀天露園')
#檢測是否含有某屬性
print(hasattr(b1,'name'))
print(hasattr(b1,'sell_house'))
#獲取屬性
n=getattr(b1,'name')
print(n)
func=getattr(b1,'rent_house')
func()
# getattr(b1,'aaaaaaaa') #報錯
print(getattr(b1,'aaaaaaaa','不存在啊'))
#設置屬性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.show_name(b1))
#刪除屬性
delattr(b1,'addr')
delattr(b1,'show_name')
delattr(b1,'show_name111')#不存在,則報錯
print(b1.__dict__)
類也是對象
class Foo(object):
staticField = "old boy"
def __init__(self):
self.name = 'wupeiqi'
def func(self):
return 'func'
@staticmethod
def bar():
return 'bar'
print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')
反射當前模塊成員:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys
def s1():
print 's1'
def s2():
print 's2'
this_module = sys.modules[__name__]
hasattr(this_module, 's1')
getattr(this_module, 's2')
導入其他模塊，利用反射查找該模塊是否存在某個方法
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
程序目錄：
module_test.py
index.py
當前文件：
index.py
"""
import module_test as obj
#obj.test()
print(hasattr(obj,'test'))
getattr(obj,'test')()
為什么用反射之反射的好處
好處一：實現可插拔機制
有倆程序員，一個lili，一個是egon，lili在寫程序的時候需要用到egon所寫的類，但是egon去跟女朋友度蜜月去了，還沒有完成他寫的類，lili想到了反射，使用了反射機制lili可以繼續完成自己的代碼，等egon度蜜月回來后再繼續完成類的定義并且去實現lili想要的功能。
總之反射的好處就是，可以事先定義好接口，接口只有在被完成后才會真正執行，這實現了即插即用，這其實是一種‘后期綁定’，什么意思？即你可以事先把主要的邏輯寫好（只定義接口），然后后期再去實現接口的功能.
egon還沒有實現全部功能:
class FtpClient:
'ftp客戶端,但是還么有實現具體的功能'
def __init__(self,addr):
print('正在連接服務器[%s]' %addr)
self.addr=addr
不影響lili的代碼編寫
#from module import FtpClient
f1=FtpClient('192.168.1.1')
if hasattr(f1,'get'):
func_get=getattr(f1,'get')
func_get()
else:
print('---->不存在此方法')
print('處理其他的邏輯')
__setattr__,__delattr__,__getattr__三者的用法演示:
class Foo:
x=1
def __init__(self,y):
self.y=y
def __getattr__(self, item):
print('----> from getattr:你找的屬性不存在')
def __setattr__(self, key, value):
print('----> from setattr')
# self.key=value #這就無限遞歸了,你好好想想
# self.__dict__[key]=value #應該使用它
def __delattr__(self, item):
print('----> from delattr')
# del self.item #無限遞歸了
self.__dict__.pop(item)
#__setattr__添加/修改屬性會觸發它的執行
f1=Foo(10)
print(f1.__dict__) # 因為你重寫了__setattr__,凡是賦值操作都會觸發它的運行,你啥都沒寫,就是根本沒賦值,除非你直接操作屬性字典,否則永遠無法賦值
f1.z=3
print(f1.__dict__)
#__delattr__刪除屬性的時候會觸發
f1.__dict__['a']=3#我們可以直接修改屬性字典,來完成添加/修改屬性的操作
del f1.a
print(f1.__dict__)
#__getattr__只有在使用點調用屬性且屬性不存在的時候才會觸發
f1.xxxxxx
二次加工標準類型(包裝)
包裝：python為大家提供了標準數據類型，以及豐富的內置方法，其實在很多場景下我們都需要基于標準數據類型來定制我們自己的數據類型，新增/改寫方法，這就用到了我們剛學的繼承/派生知識（其他的標準類型均可以通過下面的方式進行二次加工）
二次加工標準類型(基于繼承實現)
class List(list): #繼承list所有的屬性，也可以派生出自己新的，比如append和mid
def append(self, p_object):
' 派生自己的append：加上類型檢查'
if not isinstance(p_object,int):
raise TypeError('must be int')
super().append(p_object)
@property
def mid(self):
'新增自己的屬性'
index=len(self)//2
return self[index]
l=List([1,2,3,4])
print(l)
l.append(5)
print(l)
# l.append('1111111') #報錯，必須為int類型
print(l.mid)
#其余的方法都繼承list的
l.insert(0,-123)
print(l)
l.clear()
print(l)
練習（clear加權限限制）
class List(list):
def __init__(self,item,tag=False):
super().__init__(item)
self.tag=tag
def append(self, p_object):
if not isinstance(p_object,str):
raise TypeError
super().append(p_object)
def clear(self):
if not self.tag:
raise PermissionError
super().clear()
l=List([1,2,3],False)
print(l)
print(l.tag)
l.append('saf')
print(l)
# l.clear() #異常
l.tag=True
l.clear()
授權：授權是包裝的一個特性, 包裝一個類型通常是對已存在的類型的一些定制,這種做法可以新建,修改或刪除原有產品的功能。其它的則保持原樣。授權的過程,即是所有更新的功能都是由新類的某部分來處理,但已存在的功能就授權給對象的默認屬性。
實現授權的關鍵點就是覆蓋__getattr__方法
授權示范一
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-28 下午9:03
# @File : 授權示例一.py
import time
class FileHandle:
def __init__(self, filename, mode='r', encoding='utf-8'):
self.file = open(filename, mode, encoding=encoding)
def write(self, line):
t = time.strftime("%Y-%m-%d %T")
self.file.write("%s %s" % (t, line))
def __getattr__(self, item):
return getattr(self.file, item)
f1 = FileHandle('b.txt', "w+")
f1.write("hello")
f1.seek(0)
print(f1.read())
f1.close()
授權示例二
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-28 下午9:11
# @File : 授權示例二.py
import time
class FileHandle:
def __init__(self, filename, mode='r', encoding='utf-8'):
if 'b' in mode:
self.file = open(filename, mode)
else:
self.file = open(filename, mode, encoding=encoding)
self.filename = filename
self.mode = mode
self.encoding = encoding
def write(self, line):
if 'b' in self.mode:
if not isinstance(line, bytes):
raise TypeError("must be bytes")
self.file.write(line)
def __getattr__(self, item):
return getattr(self.file, item)
def __str__(self):
if 'b' in self.mode:
res = "<_io.BufferedReader name='%s'>" % self.filename
else:
res = "<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'" % (
self.filename,
self.mode,
self.encoding
)
return res
f = FileHandle('b1.txt', 'wb')
# f.write("hehe")
f.write("hehe".encode('utf-8'))
print(f)
f.close()
練習題
1. 面向對象三大特性，各有什么用處，說說你的理解。
面向對象的三大特性： 封裝，繼承，多態。
封裝： 將數據隱藏起來，隔離復雜度。
繼承： 繼承用來解決代碼重用性，子類可以繼承父類已經定義的方法。
多態：指一個基類中派生出了不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，多態增加了程序的靈活性和程序的可擴展性。
2.類的屬性和對象的屬性有什么區別?
image.png
3.面向過程編程與面向對象編程的區別與應用場景?
面向過程編程主要是流程，將復雜的問題流程化；缺點是一個流程對應一個問題，擴展性差；應用場景適用于一旦確定需求就很少去改動的程序。
面向對象編程重點是對象，將具體的問題抽象化，形成一個個的類別，解決了程序的擴展性問題；缺點是編程的復雜度遠遠高于面向過程編程；應用于需求經常變化的軟件中；
4.類和對象在內存中是如何保存的。
5.什么是綁定到對象的方法、綁定到類的方法、解除綁定的函數、如何定義，如何調用，給誰用？有什么特性
6.使用實例進行 獲取、設置、刪除 數據, 分別會觸發類的什么私有方法
class A(object):
pass
a = A()
a["key"] = "val" # __setitem__
a = a["key"] # __getitem__ __setattr__
del a["key"] # __delitem__
7.python中經典類和新式類的區別
經典類：深度優先
新式類：廣度優先
super()用法
8.如下示例, 請用面向對象的形式優化以下代碼
def exc1(host,port,db,charset):
conn=connect(host,port,db,charset)
conn.execute(sql)
return xxx
def exc2(host,port,db,charset,proc_name)
conn=connect(host,port,db,charset)
conn.call_proc(sql)
return xxx
# 每次調用都需要重復傳入一堆參數
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存儲過程的名字')
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午4:30
# @File : ex008.py
class DataBases:
def __init__(self, host, port, db, charset):
self.host = host
self.port = port
self.db = db
self.charset = charset
def execute(self, sql):
rt = ("execute Sql: [%s]." % sql)
return rt
def call_proc(self, proc_name):
rt = "Calling process: [%s]." % proc_name
return rt
conn = DataBases('127.0.0.1', 3306, 'db1', 'utf8')
print(conn.execute('select * from tb1;'))
print(conn.call_proc('存儲過程的名字'))
9.示例1, 現有如下代碼， 會輸出什么：
class People(object):
__name = "luffy"
__age = 18
p1 = People()
print(p1.__name, p1.__age)
程序會報錯，拋出AttributeError，因為python或將前綴為雙下劃線的屬性在構建時改為_People__name,實現屬性隱藏的目的。
10.示例2, 現有如下代碼， 會輸出什么：
class People(object):
def __init__(self):
print("__init__")
def __new__(cls, *args, **kwargs):
print("__new__")
return object.__new__(cls, *args, **kwargs)
People()
輸出結果為：
__new__ # People類實際上是默認元類type類的的實例對象，由class語法調用type類的__new__方法創建
__init__ # 在對象實例化時調用__init__方法
11.請簡單解釋Python中 staticmethod（靜態方法）和 classmethod（類方法）, 并分別補充代碼執行下列方法。
class A(object):
def foo(self, x): # 綁定到對象的方法，會將對象當做第一個參數傳入
print("executing foo(%s, %s)" % (self,x))
@classmethod #綁定到類的犯法，將類當做對個參數傳入
def class_foo(cls, x):
print("executing class_foo(%s, %s)" % (cls,x))
@staticmethod # 非綁定方法， 不會制動傳入任何參數
def static_foo(x):
print("executing static_foo(%s)" % (x))
a = A()
a.foo("foo")
A.class_foo("foo")
a.static_foo("aaaa")
A.static_foo("static")
12.請執行以下代碼，解釋錯誤原因，并修正錯誤。
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午5:00
# @File : ex012.py
class Dog(object):
def __init__(self,name):
self.name = name
@property
def eat(self):
print(" %s is eating" %self.name)
d = Dog("ChenRonghua")
# d.eat() # @property把一個方法變成一個靜態屬性 --> TypeError: 'NoneType' object is not callable
d.eat
13.下面這段代碼的輸出結果將是什么？請解釋。
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
# 1 1 1 繼承自父類的類屬性x，所以都一樣，指向同一塊內存地址
# 1 2 1 更改Child1，Child1的x指向了新的內存地址
# 3 2 3 更改Parent，Parent的x指向了新的內存地址
14.多重繼承的執行順序，請解答以下輸出結果是什么？并解釋。
class A(object):
def __init__(self):
print('A')
super(A, self).__init__()
class B(object):
def __init__(self):
print('B')
super(B, self).__init__()
class C(A):
def __init__(self):
print('C')
super(C, self).__init__()
class D(A):
def __init__(self):
print('D')
super(D, self).__init__()
class E(B, C):
def __init__(self):
print('E')
super(E, self).__init__()
class F(C, B, D):
def __init__(self):
print('F')
super(F, self).__init__()
class G(D, B):
def __init__(self):
print('G')
super(G, self).__init__()
if __name__ == '__main__':
g = G()
f = F()
# G
# D
# A
# B
#
# F
# C
# B
# D
# A
python3繼承時廣度優先，查找順序按照__dict__
15.請編寫一段符合多態特性的代碼.
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午5:18
# @File : ex015.py
import abc
class Animal(metaclass=abc.ABCMeta):
def talk(self):
pass
class People(Animal):
def talk(self):
print("I'm the king of the world!!!")
class Pig(Animal):
def talk(self):
print("Live is nothing but eat...")
People().talk()
Pig().talk()
16.很多同學都是學會了面向對象的語法，卻依然寫不出面向對象的程序，原因是什么呢？
原因就是因為你還沒掌握一門面向對象設計利器，即領域建模，請解釋下什么是領域建模，以及如何通過其設計面向對象的程序？領域建模 此blog最后面有詳解
17.請寫一個小游戲，人狗大站，2個角色，人和狗，游戲開始后，生成2個人，3條狗，互相混戰，人被狗咬了會掉血，狗被人打了也掉血，狗和人的攻擊力，具備的功能都不一樣。注意，請按題14領域建模的方式來設計類。
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午5:35
# @File : ex016.py
"""
人狗大站，2個角色，人和狗，
游戲開始后，生成2個人，3條狗，互相混戰，人被狗咬了會掉血，
狗被人打了也掉血，狗和人的攻擊力，具備的功能都不一樣。
"""
import abc
import random
class Role(metaclass=abc.ABCMeta):
def __init__(self, name, atc, life):
self.name = name
self.atc = atc
self.life = life
self.die = False
def attack(self, obj):
if obj.die:
print("目標已經死亡，攻擊無效！！！")
return
obj.life -= self.atc
if obj.life <= 0:
obj.life = 0
obj.die = True
class Human(Role):
def attck(self, obj):
super(Human, self).attack(obj)
print("[%s]攻擊了[%s],造成了<%s>點傷害..." % (self.name, obj.name, self.atc))
if obj.die:
print((obj.name + "已經死亡").center(80, "-"))
class Dog(Role):
def attck(self, obj):
super(Dog, self).attack(obj)
print("[%s]咬了[%s],造成了<%s>點傷害..." % (self.name, obj.name, self.atc))
if obj.die:
print((obj.name + "已經死亡").center(80, "-"))
h1 = Human("張三", 10, 100)
h2 = Human("李四", 8, 120)
d1 = Dog("Alex", 20, 50)
d2 = Dog("Wupeiqi", 22, 44)
d3 = Dog("zhang", 30, 30)
role_list = [h1, h2, d1, d2, d3]
game_end = False
while not game_end:
if len(role_list) == 1:
print("<%s> 贏得了勝利" % role_list[0].name)
game_end = True
else:
r1 = random.choice(role_list)
obj_list = [i for i in role_list if i != r1 ]
obj = random.choice(obj_list)
r1.attck(obj)
if obj.die:
role_list.remove(obj)
18.編寫程序, 在元類中控制把自定義類的數據屬性都變成大寫.
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午6:15
# @File : ex017.py
class MyMeta(type):
def __new__(cls, name, bases, args):
# print(name)
# print(bases)
rt_args = {}
for k, v in args.items():
if isinstance(v, str) and (not v.startswith("__")):
rt_args[k] = v.upper()
continue
else:
rt_args[k] = v
print(rt_args)
return type.__new__(cls, name, bases, rt_args)
class UpClass(metaclass=MyMeta):
name = "fbo"
age = 18
up = UpClass.__dict__
print(up)
19.編寫程序, 在元類中控制自定義的類無需init方法.
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午8:43
# @File : ex018.py
class MyMetaClass(type):
def __call__(cls, *args, **kwargs):
if args:
raise TypeError("must use key arguments!")
obj = object.__new__(cls)
for k, v in kwargs.items():
obj.__dict__[k] = v
return obj
class Test(metaclass=MyMetaClass):
pass
t = Test(name = "hehe", age = 22, male = "F")
print(t.__dict__)
20.編寫程序, 編寫一個學生類, 要求有一個計數器的屬性, 統計總共實例化了多少個學生.
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午9:00
# @File : ex020.py
import random
class Student:
count= 0
def __init__(self):
Student.count += 1
for i in range(random.randint(1, 100)):
s = Student()
print(Student.count)
21.編寫程序, A 繼承了 B, 倆個類都實現了 handle 方法, 在 A 中的 handle 方法中調用 B 的 handle 方法
class B:
def handle(self):
print("From B")
class A(B):
def handle(self):
print("From A")
super().handle()
a = A()
a.handle()
22.編寫程序, 如下有三點要求：
- 自定義用戶信息數據結構， 寫入文件, 然后讀取出內容, 利用json模塊進行數據的序列化和反序列化
e.g
{
"egon":{"password":"123",'status':False,'timeout':0},
"alex":{"password":"456",'status':False,'timeout':0},
}
- 定義用戶類，定義方法db，例如 執行obj.db可以拿到用戶數據結構
- 在該類中實現登錄、退出方法, 登錄成功將狀態(status)修改為True, 退出將狀態修改為False(退出要判斷是否處于登錄狀態).密碼輸入錯誤三次將設置鎖定時間(下次登錄如果和當前時間比較大于10秒即不允許登錄)
#!/usr/bin/env python3
# Author : fbo
# @Time : 18-4-29 下午9:12
# @File : ex022.py
import json
import time
import os
class User_Info():
__default = {
"egon": {"password": "123", 'status': False, 'timeout': 0},
"alex": {"password": "456", 'status': False, 'timeout': 0},
}
__file_name = "db.json"
def init_db(self):
self.save_db(self.__default)
def save_db(self, data):
with open(self.__file_name, "w") as f:
json.dump(data, f)
def db(self):
with open(self.__file_name) as f:
rt = json.load(f)
return rt
def login(self):
exit_flag = False
user_account = self.db()
print(user_account)
try_user = []
while not exit_flag:
user = input("Name: ").strip()
password = input("Password: ").strip()
if user in user_account:
if user_account[user]["status"]:
print("You already login...")
exit_flag = True
elif user_account[user]["timeout"] and (time.time() - user_account[user]["timeout"] < 10):
print("You has been lock...")
else:
if user_account[user]["password"] == password:
user_account[user]["status"] = True
user_account[user]["timeout"] = 0
self.save_db(user_account)
print("%s login success.." % user)
exit_flag = True
else:
try_user.append(user)
print(try_user)
if try_user.count(user) == 3:
try_user = [i for i in try_user if i != user]
user_account[user]["timeout"] = time.time()
else:
print("%s not exist..." % user)
ui = User_Info()
if not os.path.isfile(ui._User_Info__file_name):
ui.init_db()
ui.login()
23.用面向對象的形式編寫一個老師角色
實現以下功能, 獲取老師列表, 創建老師、刪除老師、創建成功之后通過 pickle 序列化保存到文件里，并在下一次重啟程序時能讀取到創建的老師, 例如程序目錄結構如下:
image.png
