十六、物件導向程式設計

 1 def Person(name,sex,hp,ad):
 2     # 人模子
 3     self = {`name`: name, `sex`:sex, `hp`: hp, `ad`: ad}
 4     def attack(dog): # 閉包
 5         # 人攻擊狗
 6         print(`%s攻擊%s` % (self[`name`], dog[`name`]))
 7         # 狗掉血，狗的血量-人的攻擊力
 8         dog[`hp`] -= self[`ad`]
 9     self[`attack`] = attack
10     return self
11 
12 def Dog(name,kind,hp,ad):
13     # 狗模子
14     self = {`name`: name, `kind`:kind, `hp`: hp, `ad`: ad}
15     def bite(person):
16         print(`%s咬了%s` % (self[`name`], person[`name`]))
17         # 人掉血，人的血量-狗的攻擊力
18         person[`hp`] -= self[`ad`]
19         if person[`hp`] <= 0: print(`game over,%s win` % self[`name`])
20     def bite2():pass
21     self[`bite`] = bite
22     self[`bite2`] = bite2
23     return self
24 
25 # 人 規範了屬性的個數 簡化了創造任務的程式碼
26 alex = Person(`a_sb`,`不詳`,1,5)
27 boss_jin =Person(`金老闆`,`女`,2,50)
28 
29 # 狗
30 chen = Dog(`旺財`,`teddy`,50,20)
31 alex[`attack`](chen)
32 print(chen[`hp`])

引用動態變數
        # 1.類名.方法名  檢視這個方法的記憶體地址
        # 1.類名.方法名(實參)  呼叫了這個方法，必須傳一個實參，這個實參傳給了self
    # 創造一個物件 - 例項化
        # 產生一個例項（物件）的過程
        # 物件 = 類名()
# alex = Person()   # 創造一個物件
# alex 是物件、例項
# Person是類
# 物件 = 類名()

# 例項化的過程：
    # 1.創造一個例項,將會作為一個實際引數  # python
    # 2.自動觸發一個__init__的方法，並且把例項以引數的形式傳遞給__init__方法中的self形參
    # 3.執行完__init__方法之後，會將self自動返回給alex
# __init__方法 ：初始化方法，給一個物件新增一些基礎屬性的方法，一般情況下是針對self的賦值
# 物件
    # 在類的內部 self是本類的一個物件
    # 在類的外部，每一個物件都對應著一個名字，這個物件指向一個物件的記憶體空間
    # 屬性的呼叫：
        # 物件名.屬性名               第一種呼叫方法
        # 物件名.__dict__[`屬性名`]   第二種呼叫方法
    # 方法的呼叫 ：
        # 類名.方法名(物件名)  # 那麼方法中的self引數就指向這個物件
        # 物件名.方法名()      # 這樣寫 相當於  方法中的self引數直接指向這個物件

class Person:
    s = `aaaa`    
    def __init__(self,name,sex,hp,ad):    
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def atack(self):              
        print(`%s攻擊%s` % (self.name,gou.name))
class Dog:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def bite(self):
        print(`%s咬了%s` % (self.name,alex.name))
print(Person.s)                   
alex = Person(`alex`,`male`,78,23)
gou = Dog(`wangcai`,`female`,4,56)
print(alex.__dict__)
print(alex.name)
alex.name = `sb`
print(alex.name)
alex.atack()
gou.bite()
Person.atack(alex)
Dog.bite(gou)
#############

aaaa
{`name`: `alex`, `sex`: `male`, `hp`: 78, `ad`: 23}
alex
sb
sb攻擊wangcai
wangcai咬了sb
sb攻擊wangcai
wangcai咬了sb

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def s(self):
        return pi*self.r**2
    def lenth(self):
        return 2*pi*self.r
class Ring:
    def __init__(self,r,R):
        self.r = Circle(r)              組合
        self.R = Circle(R)              組合
    def s(self):
        return abs(self.r.s() - self.R.s())
    def lenth(self):
        return self.r.lenth() + self.R.lenth()
a = Ring(3,5)
print(a.s(),a.lenth())

class A:
    def func(self):
        print(`A`)
class B(A):
    pass
    def func(self):
        super().func()
        print(`B`)
class C(A):
    pass
    def func(self):
        super().func()
        print(`C`)
class D(B):
    pass
    def func(self):
        super().func()                          
        print(`D`)
class E(B,C):
    pass
    def func(self):
        super().func()
        print(`E`)
class F(D,E):
    pass
    def func(self):
        super().func()
        print(`F`)
f = F()
f.func()
print(mro(f))  查詢他的上一個父類 
這段程式碼super查詢父類中的方法查詢順序就如圖所示  遵循廣度優先的順序 並且每次找遍歷節點只遍歷一次

這個例子為經典類的遍歷方法
class A:
    # def func(self):
    #     print(`A`)
    pass
class B(A):
    pass
    # def func(self):
    #     # super().func()
    #     print(`B`)
class C(A):
    pass
    def func(self):
        # super().func()
        print(`C`)
class D(B):
    pass
    # def func(self):
    #     # super().func()
    #     print(`D`)
class E(B,C):
    pass
    # def func(self):
    #     # super().func()
    #     print(`E`)
class F(D,E):
    pass
    # def func(self):
    # #     # super().func()
    # print(`F`)
f = F()
f.func()

這段程式碼中的class A 就是抽象類  抽象類的目的是為了下面的類都繼承A類的方法   因為在呼叫方法的時候用了一個歸一化設計  以免其他的程式設計師在建立類的方法的時候沒有建立抽象類的方法
導致歸一化設計的函式在呼叫類的方法的時候出錯
from abc import ABCMeta,abstractmethod
class A(metaclass = ABCMeta):                   
    @abstractmethod
    def pay(self):pass                            
class Alipay(A):
    def pay(self,money):
        print(`支付寶支付%s元` % money)
class QQpay(A):
    def pay(self,money):
        print(`用qq支付了%s元` % money)
class WEchat(A):
    def pay(self,money):
        print(`用微信支付%s元` % money)
a = Alipay()
B = QQpay()
c = WEchat()
def pay(a,money):           這裡就是歸一化設計
    a.pay(money)
pay(a,100)
pay(B,200)
pay(c,300)
######
支付寶支付100元
用qq支付了200元
用微信支付300元

class D:
    def __init__(self):
        self.__func()
    def __func(self):
        print(`in D`)

class E(D):
    def __func(self):
        print(`in E`)
e = E()
###
in D
分析：第一步例項化 然後自動執行了D類中的def__init__(self):  self.__func()  找到D類中的私有的方法__func()
父類不想讓子類繼承自己方法也可以讓方法私有化，這樣就不能再外面呼叫父類的方法
如果要呼叫E中的__func()則要這樣寫e._E__func() 但是這樣雖說可以呼叫 但是我們絕不可以這樣寫 這樣只是可以做到。

class A:
    def __init__(self,name,discount,price):
        self.name = name
        self.__discount = discount
        self.__price =price
    @property 
    def dis_price(self):                            一致dis_price
        return self.__discount*self.__price
    @dis_price.setter                               一致dis_price     
    def dis_price(self,newdiscount):
        self.__discount = newdiscount
apple = A(`apple`,0.8,5)
print(apple.dis_price)
apple.dis_price = 0.3                               一致dis_price 
print(apple.dis_price)
####
4
1.5
這裡需要注意的是 如果在類中再建立一個和偽裝方法名一個屬性，則會被將內偽裝的方法名覆蓋，列印出來的是方法的記憶體地址

class Person:
    def __init__(self,n):
        self.__name = n  # 私有的屬性了
    @property            # 重要程度 ****
    def name(self):
        return self.__name
    @name.deleter
    def name(self):
        print(`name 被刪除了`)
    @name.deleter         # 重要程度*
    def name(self):
        del self.__name

p = Person(`alex`)
print(p.name)
del p.name  # 只是執行了被@name.deleter裝飾的函式
print(p.name)

class A:
    discount__ = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def really_price(self):
        return self.__price*A.__discount
    @classmethod                                 類方法：可以直接被類呼叫 不用再例項化  並且只需要傳一個類引數 當
    def new_discount(cls,newdiscount):            
        cls.__discount = newdiscount
A.new_discount(0.8)                                        只需要傳一個引數
a = A(`a`,3)
print(a.really_price)
由這段程式碼可以看出 當折扣恢復到原來的狀態時只需要進行如下操作
A.new_discount(1)
所以當一個方法需要使用類中的靜態屬性時 而不需要其他操作時 就用類方法

class Student:
    def __init__(self,name):pass
    @staticmethod
    def login():                   # login就是一個類中的靜態方法 靜態方法沒有預設引數 就當成普通的函式使用即可
        user = input(`user :`)
        if user == `alex`:
            print(`success`)
        else:
            print(`faild`)
Student.login()

當一個方法既不需要用到物件中的屬性又不需要用到類中的靜態屬性  就可以用到靜態方法來直接呼叫類中的方法 不需要例項化