# 面向物件與面向過程

#   面向過程：以事物流程為中心，核心是“過程”步驟,即,先幹什麼,後幹什麼.
#   優點:負責的問題流程化,編寫相對簡單
#   缺點:可擴充套件性差

#   面向物件：一切以物件為中心，萬事萬物皆是物件(object)
#   優點: 可擴充套件性強
#   缺點: 程式設計的複雜度高於面向過程

# 面向物件
# 如何編寫面向物件

 1 # class 表示建立一個類
 2 # Car 類名 類是對事物的定義 歸類
 3 class Car:  # 類名首字母大寫
 4     pass
 5 
 6 c = Car()  # 通過類來建立物件 把類概念例項化  物件 = 類()
 

 7 
 8 c.chelu ="圓的" # 屬性
 9 c.color ="酷黑"
10 c.pailiang = "5.5"
11 c.pz = "浙A86666"
12 # c.xxx  可理解成  物件的 xx屬性/xx引數
13 print(c.pailiang)
14 print(c.color)
15 print(c.chelu)
16 print(c.pz)
17 
18 c1 = Car()  # 新的物件 不同物件是放在不同空間的 類可多次使用
19 c1.pz = "京A66666"
20 c1.pl = "6.6"
21 c1.color = "騷紅"
22 c1.suoyouren = "
 
jiang"
23 
24 print(c1.suoyouren)
25 print(c1.color)
26 print(c1.pl)
27 print(c1.pz)
28 # print(c.price) # 沒有的屬性會報錯
29 #  AttributeError: 'Car' object has no attribute 'price'

# 類的例項化
# 例項化：類名加括號就是例項化，會自動觸發__init__函式的執行,可用它來為每個例項定製自己的特徵
# self：在例項化時自動將物件/例項本身傳給__init__的第一個引數.

 1 class
 
 Computer:  # 建立類
 2     # 構造方法 __init__(self) 在建立物件時自動訪問這個方法 設定一些初始化的屬性資訊
 3     def __init__(self,pinpai,price,cpu,neicun): # 誰呼叫,self就是誰 傳參時self自動傳 self 自身本身
 4         self.pinpai = pinpai
 5         self.price = price
 6         self.cpu = cpu
 7         self.neicun = neicun
 8 
 9     def playgame(self,game): # 定義方法可以新添引數
10         print("我要打遊戲，我要%s"% game)
11         print("我用我的%s電腦,利用很吊的%s來成功%s"%(self.pinpai,self.cpu,game))
12 
13 d = Computer("小米","8999","I7-8750H","16G") # 建立物件 例項化
14 print(d.pinpai)
15 #
16 d1 = Computer("神舟","9999","I7-9700K","32G")
17 print(d1.cpu)
18 #
19 d1.playgame("吃雞") # 使用 playgame 方法 引數"吃雞"傳給game

# 總結:類與物件的關係:類是對事物的總結.抽象的概念.類用來描述物件.物件是類的
# 例項化的結果.物件能執行哪些方法.都由類來決定.類中定義了什麼.物件就擁有什麼

# 練習題
# 思考過程:
# 準備建立類class -> 定義__init__()  self.xxx = xxxx
# 物件能幹什麼事兒?  方法. def 方法名(self, 引數...)

 1 # 1.建立一個武松.武松可以打老虎,殺嫂子,替天行道
 2 class HaoHan: # 建立類
 3     def __init__(self,mingzi,chenhao,wugong,wuqi):  # 初始化引數
 4         self.mingzi = mingzi
 5         self.chenaho = chenhao
 6         self.wugong = wugong
 7         self.wuqi = wuqi
 8 
 9     def dalaohu(self): # 定義方法
10         print("%s使用%s爆錘老虎"%(self.mingzi,self.wuqi))
11 
12     def shasaozi(self):
13         print("%s怒殺嫂子" % self.mingzi)
14 
15     def titianxingdao(self):
16         print("%s一雙%s,走南闖北,替天行道" % (self.mingzi,self.wugong))
17 
18 wusong = HaoHan("武松","行者","王霸拳","拳頭")
19 wusong.dalaohu()
20 wusong.shasaozi()
21 wusong.titianxingdao()
22 # 誰呼叫，self就是誰，可以多次呼叫
23 likui = HaoHan("李逵","黑旋風","板斧","旋風斬")
24 likui.dalaohu()
25 likui.shasaozi()
26 likui.titianxingdao()
27 
28 # 2.⽤面向物件的思維來模擬LOL裡的蓋倫上陣殺敵.
29 class Juese:
30     def __init__(self,xingwei,hp,fy):
31         self.xingwei = xingwei
32         self.hp = hp
33         self.fy = fy
34 
35     def yinggang(self,mingzi):
36         print("選%s,%shp%s防禦%s就是槓" % (mingzi,self.xingwei,self.hp,self.fy))
37 
38 gailun = Juese("上陣殺敵",5000,200)
39 gailun.yinggang("蓋倫")
40 
41 # 3.建立一個和尚類，自由發揮屬性和方法
42 class Heshang:
43     def __init__(self,mingzi,wugong,xingwei,simiao,shifu):
44         self.mingzi = mingzi
45         self.wugong = wugong
46         self.xingwei = xingwei
47         self.simiao = simiao
48         self.shifu = shifu
49 
50     def day(self):
51         print("%s師承%s,至%s而來,一身大成%s,%s英勇無敵"%(self.mingzi,self.shifu,self.simiao,self.wugong,self.xingwei))
52 
53 bajie = Heshang("八戒","金剛經","降妖除魔","靈隱寺","玄奘")
54 bajie.day()
55 
56 # 4.模擬使用者登入
57 class User: # 類名
58     def __init__(self,username,password): # 初始化
59         self.username = username
60         self.password = password
61 
62     def login(self,use,pas):  # 定義登入方法
63         if use == self.username and pas == self.password:
64             return True
65         else:
66             return False
67 
68 u1 = User("王尼瑪","123")  # 物件 u1
69 re = u1.login(input("請輸入賬號："),input("請輸入密碼:")) # 呼叫方法login
70 print(re)

# 面向物件與面向過程

 1 # 例子1：要把大象裝進冰箱
 2 # 面向過程
 3 def open():
 4     print("開門")
 5 def zhuang():
 6     print("裝大象")
 7 def close():
 8     print("關門")
 9 open()
10 zhuang()
11 close()
12 
13 # 面向物件
14 class DaXiang:
15     def __init__(self,open,zhuang,close):
16         self.open = open
17         self.zhuang = zhuang
18         self.close = close
19 dx = DaXiang("開冰箱","裝大象","關冰箱")
20 print(dx.open)
21 print(dx.zhuang)
22 print(dx.close)
23 # 如上可看到面向物件很麻煩
24 
25 # 例子2:佩奇大戰奧特曼
26 # 面向過程
27 def da_atm(name,age,jn):
28     print("%s,今年%s歲了,使用%s技能瘋狂輸出奧特曼"%(name,age,jn))
29 def da_bfx(name,age,jn):
30     print("%s,今年%s歲了,使用%s技能瘋狂輸出蝙蝠俠"%(name,age,jn))
31 def da_zzx(name,age,jn):
32     print("%s,今年%s歲了,使用%s技能瘋狂輸出蜘蛛俠"%(name,age,jn))
33 
34 da_atm("小豬佩奇",9,"嘴巴嘟嘟")
35 da_bfx("小豬佩奇",9,"嘴巴嘟嘟")
36 da_zzx("小豬佩奇",9,"嘴巴嘟嘟")
37 
38 # 面向物件
39 class Pig:
40     def __init__(self,name,age,jn):
41         self.name = name
42         self.age = age
43         self.jn = jn
44 
45     def da_atm(self):
46         print("%s,今年%s歲了,使用%s技能瘋狂輸出奧特曼" % (self.name,self.age,self.jn))
47     def da_bfx(self):
48         print("%s,今年%s歲了,使用%s技能瘋狂輸出蝙蝠俠" % (self.name,self.age,self.jn))
49     def da_zzx(self):
50         print("%s,今年%s歲了,使用%s技能瘋狂輸出蜘蛛俠" % (self.name,self.age,self.jn))
51 
52 peiqi = Pig("小豬佩奇",9,"嘴巴嘟嘟")
53 peiqi.da_atm()
54 peiqi.da_bfx()
55 peiqi.da_zzx()
56 
57 # 如上案例 面向物件思路更好，增添方法也容易
58 # 所以.用哪種程式設計思想不是絕對的.得根據需求來完成.

# 函數語言程式設計:簡單的基本功能 函數語言程式設計更好用
# 面向物件:如果功能非常複雜的時候. 面向物件
# 面向物件比面向過程複雜

# 封裝：把很多資料封裝到一個物件中.把固定功能的程式碼封裝到一個程式碼塊,函式,物件,打包成模組.這都屬於封裝的思想

 1 class Pig:
 2     def __init__(self,name,age,jn):
 3         # 封裝 對屬性進行封裝
 4         self.name = name
 5         self.age = age
 6         self.jn = jn
 7 
 8     # 對方法進行封裝 丟到類Pig裡面
 9     def da_atm(self):
10         print("%s,今年%s歲了,使用%s技能瘋狂輸出奧特曼" % (self.name,self.age,self.jn))
11     def da_bfx(self):
12         print("%s,今年%s歲了,使用%s技能瘋狂輸出蝙蝠俠" % (self.name,self.age,self.jn))
13     def da_zzx(self):
14         print("%s,今年%s歲了,使用%s技能瘋狂輸出蜘蛛俠" % (self.name,self.age,self.jn))
15 
16 peiqi = Pig("小豬佩奇",9,"嘴巴嘟嘟")
17 peiqi.da_atm()
18 peiqi.da_bfx()
19 peiqi.da_zzx()
20 
21 # da_zzx() 直接訪問不到
22 # 把屬性 方法封裝到Pig裡面 新建物件peiqi拿出來使用

# 封裝 應用在資料庫裡

 1 class DBUtil:
 2     def __init__(self, ip, username, password):
 3         self.ip = ip
 4         self.username = username
 5         self.password = password
 6 
 7    # 對功能的封裝
 8     def test_connect(self):
 9         pass
10 
11     def connect(self):
12         pass
13 
14     def add(self):
15         pass
16 
17     def upd(self):
18         pass
19 
20     def remove(self):
21         pass
22 
23     def sel(self):
24         pass
25 
26 db = DBUtil("192.168.1.1","root","123")  # 方便快速呼叫

# 相似的 檔案讀取 工具類 封裝
# # excel doc txt 視訊 圖片

# 繼承: 子類自動擁有父類中除了私有內容外的其他所有內容
# 現階段在我們寫的內容沒有私有的

'''
繼承：兒子可以隨便用爹的東西.但一定要認清楚，必須先有爹,後有兒子.順序不 能亂,
在python中實現繼承非常簡單.在宣告類的時候,類名後面新增一個⼩括號,就可以完成繼承關係.
'''

 1 # 例子
 2 class Niu:
 3     def da(self):
 4         print("牛魔王打架很厲害")
 5 
 6 class HongHaiEr(Niu):
 7     # pass
 8     def da(self):
 9         print("噴火")
10 hhl = HongHaiEr()
11 # hhl.da()  # 沒有這個功能找父類要 打印出牛魔王打假很厲害
12 hhl.da() # 噴火 自己有先用自己的

# 當程式中出現了 x是一種y. x可以繼承y

1 class Animal:
2     def chi(self):
3         print("喜歡吃東西")
4 
5 # 當程式中出現了 x是一種y. x可以繼承y
6 # 如 貓是一種動物
7 class Cat(Animal):
8     pass

# 派生 子類在父類的基礎上擴充套件了一些功能

 1 class Foo:
 2     def a(self):
 3         pass
 4 
 5     def b(self):
 6         pass
 7 
 8 class Bar(Foo): #  子類在父類的基礎上擴充套件了一些功能. 派生
 9     def c(self): # 拓展
10         pass
11 
12 # b = Bar()
13 # b.a()
14 # b.b()
15 # b.c()

# 多繼承
# 靠誰近先找誰，自己有先用自己的

 1 class Foo1:
 2     def money(self):
 3         print("有錢")
 4 
 5 class Foo2:
 6     def play(self):
 7         print("玩兒")
 8 
 9     def money(self):
10         print("沒錢")
11 
12 class Bar(Foo2, Foo1): # MRO c3演算法
13     pass
14 
15 b = Bar() # 誰靠近 找誰
16 b.play()
17 b.money()

# 多型: 同一個物件, 多種形態.

1 # 如 建立一個變數a = 10,此時a是整數型別.但我們可以通過讓a = "duotai",這時a又變成了字串型別.
2 a = 10
3 a = "duotai"
4 print(a) # duotai
5 # 這就是多型性 同一個變數可以是多種形態

# python自動多型效果

 1 class Aniaml:
 2     def dong(self):
 3         print("動物可以動")
 4 
 5 class Cat(Aniaml):
 6     def chi(self):
 7         print("貓喜歡吃魚")
 8 
 9 a = Cat()
10 a.chi() # 站在貓的角度. 可以吃
11 a.dong() # 站在動物的角度可以動

# 多型的好處: 程式具有超高的可擴充套件性.面向物件思想的核⼼與靈魂. python自帶多型