第五章---面向對象---1.面向過程/2.面向對象/3.如何使用類/4.__init__方法/5.屬性查找與綁定方法/6.補充知識/7.可擴展性高

編程範式（流派）：
   面向對象編程，面向過程編程 各有用處！！
   編程：語法+數據結構(list dict)+算法(邏輯)

1.面向過程編程：核心是過程二字，過程指得是解決問題的步驟，至關於設計一條流水線，機械式的思惟方式

       優勢：複雜的問題流程化，進而簡單化
       缺點：可擴展性差
       運用場景：系統監控腳本，自動部署腳本之類的，eg:軟件包解壓安裝（再也不須要擴展了）就可使用面向過程的思惟編寫代碼

 1 '''
 2 面向過程實例：用戶登陸註冊
 3 第一步：用戶輸入用戶名密碼
 4 第二步：檢查輸入的合法性
 5 第三步：註冊
 6 '''
 7 
 8 import json
 9 def interaction(): # 用戶交互函數，用戶用戶輸入用戶名密碼
10     name = input('name:').strip()
11     pwd = input('pwd:').strip()
12 
13     return {'name':name,
14              'pwd':pwd
15             }
16 
17 def check(user_info): # 用戶校驗函數，用戶校驗用戶名密碼的合法性
18     is_legal = True
19 
20     if len(user_info['name']) == 0:
21         print('用戶姓名不能爲空！')
22         is_legal = False
23 
24     if len(user_info['pwd']) < 6:
25         print('用戶密碼不能少於6位！')
26         is_legal = False
27     return {'is_legal':is_legal,
28              'user_info':user_info
29             }
30 
31 def register(check_info): # 註冊
32     if check_info['is_legal']:
33         with open('db.json','w',encoding='utf-8') as f:
34             json.dump(check_info['user_info'],f)
35 
36 def main():
37     user_info = interaction()
38     check_info = check(user_info)
39     register(check_info)
40 
41 if __name__ == '__main__':
42     main()

 

2.面向對象：核心就是對象二字，對象就是特徵與技能的結合體

  優勢：可擴展性強
  缺點：編程複雜度高
  應用場景：用戶需求常常變化，互聯網應用，遊戲，企業內部應用

類就是一系列對象類似的特徵與技能的結合體
強調：站在不一樣的角度，獲得的分類是不同的

在現實世界中：必定是先有對象，後又類
在程序中：必定先定義類，後調用類產生對象

站在路飛學院的角度，你們都是學生

在現實世界中：
    對象1：mm
        特徵：
            學校='luffycity'
            名字='mm'
            性別='女'
            年齡=18
        技能：
            學習
            吃飯
            睡覺

    對象2：mumu
        特徵：
            學校='luffycity'
            名字='mumu'
            性別='男'
            年齡=1
        技能：
            學習
            吃飯
            睡覺

    對象3：zz
        特徵：
            學校='luffycity'
            名字='zz'
            性別='男'
            年齡=20
        技能：
            學習
            吃飯
            睡覺

總結現實中路飛學院的學生類：
        類似的特徵
            學校='luffycity'

        類似的技能
            學習
            吃飯
            睡覺

 1  1 # 先定義類：
 2  2 class LuffyStudengt:
 3  3     school = 'luffycity'
 4  4     def learn(self):
 5  5         print('is learning')
 6  6     def eat(self):
 7  7         print('is eating')
 8  8     def sleep(self):
 9  9         print('is sleepping')
10 10 
11 11 # 後產生對象
12 12 stu1 = LuffyStudengt()  # 實例化

 

3.如何使用類：

   先定義類：
   特徵：變量 school
   技能：函數

類和函數的區別：
定義函數只有調用函數名加（）才執行
定義類的時候類的內部代碼都會執行

類的用途：
1.操做它的屬性 增刪改查
2.實例化 產生對象

 1 class LuffyStudengt:
 2     school = 'luffycity'  # 數據屬性
 3     
 4     def learn(self):      # 函數屬性
 5         print('is learning')
 6     def eat(self):     # 函數屬性
 7         print('is eating')
 8     def sleep(self):    # 函數屬性
 9         print('is sleepping')
10 
11 # 查看類的名稱空間
12 print(LuffyStudengt.__dict__)
13 print(LuffyStudengt.__dict__['school'])
14 
15 # 查:
16 print(LuffyStudengt.school) # == print(LuffyStudengt.__dict__['school'])
17 
18 # 增：
19 LuffyStudengt.country = 'China'
20 print(LuffyStudengt.__dict__)
21 
22 # 刪
23 del LuffyStudengt.country
24 print(LuffyStudengt.__dict__)
25 
26 # 改
27 LuffyStudengt.school = 'Luffycity'
28 print(LuffyStudengt.__dict__)

 

4.__init__方法：

__init__方法用來爲對象定製對象本身獨有的特徵

__init__實例化對象時會自動調

 1 class LuffyStudengt:
 2     school = 'luffycity'
 3 
 4     # stu1,'mm','女',18
 5     def __init__(self,name,sex,age):
 6         self.Name = name
 7         self.Sex = sex
 8         self.Age = age
 9 
10     def learn(self):
11         print('is learning')
12     def eat(self):
13         print('is eating')
14     def sleep(self):
15         print('is sleepping')
16 
17 # 後產生對象
18 stu1 = LuffyStudengt('mm','女',18)  # 實例化
19 
20 # 加上__init__方法後實例化的步驟
21 # 1.先產生一個空對象stu1
22 # 2.LuffyStudent.__init__(stu1,'mm','女',18)
23 
24 # 查
25 print(stu1.__dict__)
26 print(stu1.Name)
27 
28 # 改：
29 stu1.Name = '夢夢'
30 print(stu1.__dict__)
31 print(stu1.Name)
32 
33 # 刪除：
34 del stu1.Name
35 print(stu1.__dict__)
36 
37 # 增：
38 stu1.classname = 'python全站開發'
39 print(stu1.__dict__)
40 
41 stu2=LuffyStudent('mumu','男',1) #Luffycity.__init__(stu2,'mumu','男'，1)
42 print(stu2.__dict__)
43 print(stu2.Name)

 

5.屬性查找與綁定方法：

 1 class LuffyStudengt:
 2     school = 'luffycity'
 3 
 4     # stu1,'mm','女',18
 5     def __init__(self,name,sex,age):
 6         self.Name = name
 7         self.Sex = sex
 8         self.Age = age
 9 
10     def learn(self):
11         print('%s is learning'% self.Name)
12     def eat(self):
13         print('%s is eating'% self.Name)
14     def sleep(self):
15         print('%s is sleepping'% self.Name)
16 
17 # 後產生對象
18 stu1 = LuffyStudengt('mm','女',18)  # 實例化
19 stu2 = LuffyStudengt('mumu','男',1)
20 stu3 = LuffyStudengt('zz','男',20)
21 
22 # 對象：特徵和技能的結合體
23 # 類：類是一系列對象類似的特徵與類似的技能的結合體
24 
25 # 類中的數據屬性:是全部對象共有的
26 # print(stu1.school,id(stu1.school))
27 # print(stu2.school,id(stu2.school))
28 # print(stu3.school,id(stu3.school))
29 #
30 # # luffycity 6854800
31 # # luffycity 6854800
32 # # luffycity 6854800
33 # 類中的函數屬性:是綁定給對象使用的，綁定到不一樣的對象是不一樣的綁定方法
34 # 對象調用綁定方法時，會把對象自己當作第一個參數傳入，傳給self
35 # print(LuffyStudengt.learn)
36 # LuffyStudengt.learn(stu1)
37 
38 # print(stu1.learn)
39 # stu1.learn()
40 # print(stu2.learn)
41 # print(stu3.learn)
42 
43 # 變量查找順序：首先會在對象的名稱空間中找，找不到在去類的名稱空間找，而後去父類的名稱空間找，還找不到就不會去全局找了
44 stu1.x = 'from stu1'
45 LuffyStudengt.x = 'from LuffyStudent'
46 
47 print(stu1.x)
48 # from stu1

 

6.補充知識

1.站的角度不一樣，定義出的類是大相徑庭的；
2.現實中的類並不徹底等於程序中的類，好比現實中的公司類，在程序中有時須要拆分紅部門類，業務類等；
3.有時爲了編程需求，程序中也可能會定義現實中不存在的類，好比策略類，現實中並不存在，可是在程序中倒是一個很常見的類。

4.python 一切皆對象，在python3裏統一了類與類型（list dict）的概念

 1 # print(type([1,2]))
 2 # print(list)
 3 class LuffyStudent:
 4     school = 'luffycity'
 5 
 6     def __init__(self,name,sex,age):
 7         self.Name=name
 8         self.Sex=sex
 9         self.Age=age
10 
11     def learn(self,x):
12         print('%s,%s is learning' % (self.Name,x))
13 
14     def eat(self):
15         print('%s is eatting' % self.Name)
16 # print(LuffyStudent)
17 
18 li1 = [1,2,3] # li = list(1,2,3) # list 對象
19 li1.append(4) # 對象在調本身的綁定方法 # list.append(li1,4)
20 # list.append(li1,4) # 類中的方法 是給 對象用的
21 print(li1)

 

7.可擴展性高

 1 class Chinese:
 2     country = 'China'
 3     def __init__(self,name,age,sex):
 4         self.name=name
 5         self.age=age
 6         self.sex=sex
 7     def eat(self):
 8         print('%s is eating' % self.name)
 9 
10 p1 = Chinese('alice',19,'女')
11 p2 = Chinese('alex',22,'男')
12 
13 print(p1.name,p1.country)
14 print(p2.name,p2.country)
15 p1.eat()
16 p2.eat()