3.1 面向對象的基本知識
一、面向過程：
核心是過程二字，過程指的是解決問題的步驟，設計一條流水線，機械式的思維方式
優點： 復雜的問題流程化，進而簡單化
缺點：擴展性差
適用場景：需求固定的情況
1 import json 2 import re 3 def interactive(): 4 name=input(‘>>: ‘).strip() 5 pwd=input(‘>>: ‘).strip() 6 email=input(‘>> ‘).strip() 7 return { 8 ‘name‘:name,View Code9 ‘pwd‘:pwd, 10 ‘email‘:email 11 } 12 13 def check(user_info): 14 is_valid=True 15 16 if len(user_info[‘name‘]) == 0: 17 print(‘用戶名不能為空‘) 18 is_valid=False 19 20 if len(user_info[‘pwd‘]) < 6: 21 print(‘密碼不能少於6位‘) 22 is_valid=False 2324 if not re.search(r‘@.*?\.com$‘,user_info[‘email‘]): 25 print(‘郵箱格式不合法‘) 26 is_valid=False 27 28 return { 29 ‘is_valid‘:is_valid, 30 ‘user_info‘:user_info 31 } 32 33 def register(check_info): 34 if check_info[‘is_valid‘]: 35 with open(‘db.json‘,‘w‘,encoding=‘utf-8‘) as f: 36 json.dump(check_info[‘user_info‘],f) 37 38 39 40 def main(): 41 user_info=interactive() 42 43 check_info=check(user_info) 44 45 register(check_info) 46 47 if __name__ == ‘__main__‘: 48 main()
二 、 面向對象
核心就是對象二字，對象就是特征與技能的結合
優點：可擴展性
缺點： 編程復雜度高
應用場景： 用戶需求經常變化，互聯網應用，遊戲，企業內部應用（如：辦公系統）
三、類的定義與實例化，以及類的使用
類就是一系列對象相似的特征與技能的結合體
強調：站在不同的角度，得到的分類是不一樣的。
在現實世界中：一定先有對象，後有類
在程序中：一定得先定義類，後調用類來產生對象 類相當於模版
類在定義的時候就調用了。
特征：用變量定義
技能：用函數定義
查看類的名稱空間
print(類名.__dict__)
print(類名.__dict__[‘school‘])
類的用法：
1 # 先定義類 2 class LuffyStudent: 3 # 數據屬性 4 school = ‘luffycity‘ 5 6 # 函數屬性 7 def learn(self): 8 print(‘is learning‘) 9 10 # 函數屬性 11 def eat(self): 12 print(‘is eating‘) 13 14 15 #後產生對象 16 stu1 = LuffyStudent() 17 18 #查看類的名稱空間 19 print(LuffyStudent.__dict__) 20 print(LuffyStudent.__dict__[‘school‘]) 21 22 # 查看類的屬性 23 print(LuffyStudent.school) #等價於print(LuffyStudent.__dict__[‘school‘]) 24 25 # 增加類的屬性 26 LuffyStudent.country = ‘china‘ 27 #print(LuffyStudent.__dict__) 28 print(LuffyStudent.country) 29 30 # 刪除類的屬性 31 del LuffyStudent.country 32 33 # 改類的屬性 34 LuffyStudent.school = ‘Luffycity‘View Code
總結：
1. () 的作用
函數() : 執行函數體的代碼
類(): 是實例化產生對象，在定義類的時候就已經執行了類體的代碼
2. 類的作用
1） 對屬性的操作，增刪改查
2） 實例化產生一個個的對象
四、對象
（一）__init__
__init__方法為對象定制對象自己獨有的特征
加上__init__方法後，實例化的步驟：
1. 先產生一個空對象
2. 自動觸發__init__方法 ,第一參數self是對象自己，不需要傳
1 class LuffyStudent: 2 school=‘luffycity‘ 3 4 # stu1, ‘王二丫‘, ‘女‘, 18 5 def __init__(self,name,sex,age): 6 self.Name=name 7 self.Sex=sex 8 self.Age=age 9 10 #stu1.Name=‘王二丫‘ 11 #stu1.Sex=‘女‘ 12 #stu1.Age=18 13 14 def learn(self): 15 print(‘is learning‘) 16 17 def eat(self): 18 print(‘is sleeping‘) 19 20 21 #後產生對象 22 stu1=LuffyStudent(‘王二丫‘,‘女‘,18) #LuffyStudent.__init__(stu1,‘王二丫‘,‘女‘,18) 23 24 #加上__init__方法後，實例化的步驟 25 # 1、先產生一個空對象stu1 26 # 2、LuffyStudent.__init__(stu1,‘王二丫‘,‘女‘,18) 27 28 29 #查 30 print(stu1.__dict__) 31 print(stu1.Name) 32 print(stu1.Sex) 33 print(stu1.Age) 34 35 # 改 36 stu1.Name=‘李二丫‘ 37 print(stu1.__dict__) 38 print(stu1.Name) 39 40 41 # 刪除 42 del stu1.Name 43 print(stu1.__dict__) 44 45 #增 46 stu1.class_name=‘python開發‘ 47 print(stu1.__dict__) 48 49 50 stu2=LuffyStudent(‘李三炮‘,‘男‘,38) #Luffycity.__init__(stu2,‘李三炮‘,‘男‘,38) 51 print(stu2.__dict__) 52 print(stu2.Name) 53 print(stu2.Age) 54 print(stu2.Sex)View Code
(二 ) 對象調用類中的屬性與方法
對象：特征與技能的結合體
類：類是一系列對象相似的特征與相似的技能的結合體
類中的數據屬性：是所以對象共有的 , id 都是同一個
print(LuffyStudent.school,id(LuffyStudent.school)) print(stu1.school,id(stu1.school)) print(stu2.school,id(stu2.school)) print(stu3.school,id(stu3.school))
類中的函數屬性:是綁定給對象使用的，綁定到不同的對象是不同的綁定方法，對象調用綁定方式時，會把對象本身當作第一個傳入，傳給self
print(LuffyStudent.learn) LuffyStudent.learn(stu1) #stu1.learn() LuffyStudent.learn(stu2) LuffyStudent.learn(stu3)
# 如果類中的函數有參數，則：
stu1.learn(‘python‘) # LuffyStudent.learn(stu1,‘python‘)
類中定義的函數，沒有經過任何附加處理的情況下，實際上是綁定給對象調用的。
誰來調就把誰當作第一個參數傳入給self，誰來調就是誰來執行。
名稱空間：
全局變量，類變量，對象變量同名
則，優化使用對象變量，
如果沒有對象變量，則找類變量，
如果類變量沒有，就到父類找，父類沒有，再到父父類，不會到全局找。
stu1.x=‘from stu1‘ LuffyStudent.x=‘from Luffycity class‘ print(stu1.__dict__) print(stu1.x)
python一切皆對象，python3統一了類與類型的
l1=[1,2,3] #l=list([1,2,3]) l2=[] #l=list([1,2,3]) # l1.append(4) #list.append(l1,4) list.append(l1,4) print(l1)
面向對象的可擴展性:
class Chinese:
county=‘China‘
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print(‘%s is eating‘ %self.name)
p1=Chinese(‘egon‘,18,‘male‘)
p2=Chinese(‘alex‘,38,‘female‘)
p3=Chinese(‘wpq‘,48,‘female‘)
# print(p1.county)
# print(p2.county)
# print(p3.county)
p1.eat()
p2.eat()
p3.eat()
五、練習
‘‘‘
練習1：編寫一個學生類，產生一堆學生對象， (5分鐘)
要求：
有一個計數器（屬性），統計總共實例了多少個對象
‘‘‘
class Student:
school=‘luffycity‘
count=0
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
# self.count+=1 是對象自己獨有的。 想要實現的是所有對象都能感應到。應該是共有的特征。
Student.count+=1
def learn(self):
print(‘%s is learing‘ %self.name)
stu1=Student(‘alex‘,‘male‘,38)
stu2=Student(‘jinxing‘,‘female‘,78)
stu3=Student(‘egon‘,‘male‘,18)
#對象.count 其實就是student.count ，值都相等
# print(Student.count)
# print(stu1.count) #自己沒有count屬性，就去類中找count
# print(stu2.count)
# print(stu3.count)
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)
對象交互：
‘‘‘
練習2：模仿LoL定義兩個英雄類， (10分鐘)
要求：
英雄需要有昵稱、攻擊力、生命值等屬性；
實例化出兩個英雄對象；
英雄之間可以互毆，被毆打的一方掉血，血量小於0則判定為死亡。
‘‘‘
class Garen:
camp=‘Demacia‘
def __init__(self,nickname,life_value,aggresivity):
self.nickname=nickname
self.life_value=life_value
self.aggresivity=aggresivity
def attack(self,enemy):
enemy.life_value-=self.aggresivity
#r1.life_value-=g1.aggresivity
class Riven:
camp = ‘Noxus‘
def __init__(self, nickname, life_value, aggresivity):
self.nickname = nickname
self.life_value = life_value
self.aggresivity = aggresivity
def attack(self, enemy):
enemy.life_value -= self.aggresivity
g1=Garen(‘草叢倫‘,100,30)
r1=Riven(‘可愛的銳雯雯‘,80,50)
print(r1.life_value)
g1.attack(r1)
print(r1.life_value)
3.1 面向對象的基本知識