一、繼承與派生

什麽是繼承？

繼承指的是類與類之間的關系，是一種什麽是什麽的關系，繼承的功能之一就是用來解決代碼重用問題。

繼承是一種創建新的類的方式，在python中，新建的類可以繼承一個或多個父類，父類又可以成為基類，或超類，新建的類稱為派生類或子類。

python中類的繼承分為：單繼承 和 多繼承

"""
    繼承：一種創建新類的方式
"""
class ParentClass1: #定義父類
    pass

class ParentClass2: #定義父類
    pass

#單繼承，基類是ParentClass1，派生類是SubClass1
class SubClass1(ParentClass1):
    pass

#python支持多繼承，用逗號分隔開多個繼承的類
class SubClass2(ParentClass1,ParentClass2):
    pass

# 查看 繼承的父類
print(SubClass1.__bases__)
print(SubClass2.__bases__)
"""
結果: 
(<class ‘__main__.ParentClass1‘>,)
(<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__）的實現。

class ParentClass1():
    pass

class ParentClass2():
    pass

print(ParentClass1.__bases__)

print(ParentClass2.__bases__)
"""
結果: 
(<class ‘object‘>,)
(<class ‘object‘>,)
"""

抽象與繼承（先抽象後繼承）

抽象即抽取類似或者比較像的部分。
抽象分成兩個層次：

1.將奧巴馬和梅西這倆對象比較像的部分抽取成類；
2.將人，豬，狗這三個類比較像的部分抽取成父類。

抽象最主要的作用是劃分類別（可以隔離關註點，降低復雜度）

繼承：是基於抽象的結果，通過編程語言去實現它，肯定先經歷抽象這一過程，才能通過繼承的方式去表達出抽象的結構。

抽象只是分析和設計的過程中，一個動作或者說一種技巧，通過抽象可以得到類。

繼承與重用性

　　如果在編程過程中 定義了一個類A，然後又需要定義一個類B，但B的大部分內容與A相同時，這就用到了類的繼承的概念。 通過繼承的方式新建類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

提示：用已經有的類建立一個新的類，這樣就重用了已經有的軟件中的一部分設置大部分，大大節省了編程工作量，這就是常說的軟件重用，不僅可以重用自己的類，也可以繼承別人的，比如標準庫，來定制新的數據類型，這樣就是大大縮短了軟件開發周期，對大型軟件開發來說，意義重大。

屬性查找

class Foo:
    def f1(self):
        print(‘from Foo.f1‘)

    def f2(self):
        print(‘from Foo.f2‘)
        self.f1()  # b.f1()

class Bar(Foo):
    def f1(self):
        print(‘from Bar.f1‘)

b=Bar()
b.f2()

‘‘‘
打印結果:
from Foo.f2
from Bar.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會計算出一個方法解析順序（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列表並遵循如下三條準則：

1、子類會先於父類被檢查。
2、多個父類會根據它們在列表中的順序被檢查。
3、如果對於下一個類存在兩個合法的選擇，選擇第一個父類。

　　在Java和C#中子類只能繼承一個父類，而Python中子類可以同時繼承多個父類，如果繼承了多個父類，那麽屬性的查找方式有兩種，分別是：深度優先和廣度優先。

代碼示例

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()

方式二：supper()

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‘>]

二、組合

　　組合指的是，在一個類中以另外一個類的對象作為數據屬性，稱為類的組合。

組合與繼承：

1、繼承的方式
通過繼承建立了派生類與基類之間的關系，它是一種‘是‘的關系，比如白馬是馬，人是動物。
當類之間有很多相同的功能，提取這些共同的功能做成基類，用繼承比較好，比如老師是人，學生是人。

2、組合的方式
用組合的方式建立了類與組合的類之間的關系，它是一種 ‘有’ 的關系，比如教授有生日，教授教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()

class People:
    school=‘luffycity‘

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex


class Teacher(People):
    def __init__(self,name,age,sex,level,salary,):
        super().__init__(name,age,sex)

        self.level=level
        self.salary=salary


    def teach(self):
        print(‘%s is teaching‘ %self.name)


class Student(People):
    def __init__(self, name, age, sex, class_time,):
        super().__init__(name,age,sex)

        self.class_time=class_time

    def learn(self):
        print(‘%s is learning‘ % self.name)

class Course:
    def __init__(self,course_name,course_price,course_period):
        self.course_name = course_name
        self.course_price = course_price
        self.course_period = course_period

    def tell_info(self):
        print(‘課程名<%s> 課程價錢<%s> 課程周期<%s>‘ %(self.course_name,self.course_price,self.course_period))

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day

    def tell_info(self):
        print(‘%s-%s-%s‘ %(self.year,self.mon,self.day))

# teacher1=Teacher(‘alex‘,18,‘male‘,10,3000,)
# teacher2=Teacher(‘egon‘,28,‘male‘,30,3000,)
# python=Course(‘python‘,3000,‘3mons‘)
# linux=Course(‘linux‘,2000,‘4mons‘)

# print(python.course_name)

# teacher1.course=python
# teacher2.course=python

# print(python)
# print(teacher1.course)
# print(teacher2.course)
# print(teacher1.course.course_name)
# print(teacher2.course.course_name)
# teacher1.course.tell_info()

# student1=Student(‘張三‘,28,‘female‘,‘08:30:00‘)
# student1.course1=python
# student1.course2=linux

# student1.course1.tell_info()
# student1.course2.tell_info()
# student1.courses=[]
# student1.courses.append(python)
# student1.courses.append(linux)


student1=Student(‘張三‘,28,‘female‘,‘08:30:00‘)
d=Date(1988,4,20)
python=Course(‘python‘,3000,‘3mons‘)


student1.birh=d
student1.birh.tell_info()

student1.course=python

student1.course.tell_info()

總結：
　　當類之間有顯著的不同時，並且較小的類是較大的類所需要的組件時，用 組合 比較好。

三、抽象類

　　抽象基類的核心定義在一個名為 abc 的模塊中。抽象類是一個特殊的類，它的特殊之處在於只能被繼承，不能被實例化。

　　抽象類與普通類的不同之處在於：抽象類中只能有抽象方法（沒有實現功能），該類不能被實例化，只能被繼承，且子類必須實現抽象方法。

一個抽象類具有以下特性：

　　1、抽象意味著這些類 中不包括我們需要的所有方法的定義。為了讓它成為一個真正有用的子類，我們需要提供一些方法定義。
　　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)

抽象類與接口

　　抽象類的本質還是類，指的是一組類的相似性，包括數據屬性（如all_type）和函數屬性（如read、write），而接口只強調函數屬性的相似性。

　　抽象類是一個介於類和接口直接的一個概念，同時具備類和接口的部分特性，可以用來實現歸一化設計。

四、多態與多態性

多態性是指在不考慮實例類型的情況下使用實例，多態性分為靜態多態性 和 動態多態性。

靜態多態性：如任何類型都可以用運算符 + 進行運算

動態多態性：如下

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是動物,只要是動物肯定有talk方法
#於是我們可以不用考慮它們三者的具體是什麽類型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更進一步,我們可以定義一個統一的接口來使用
def func(obj):
    obj.talk()

多態性的好處：

1.增加了程序的靈活性
　　以不變應萬變，不論對象千變萬化，使用者都是同一種形式去調用，如func(animal)

2.增加了程序額可擴展性
　通過繼承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)

五、封裝

　　在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是可以訪問到的，即這種操作並不是嚴格意義上的限制外部訪問，僅僅只是一種語法意義上的變形

# 封裝
class A:
    __x = 0

    def __init__(self, name):
        self.__name = name

    def __foo(self):  #  _A__foo
        print("run foo")

    def bar(self):
        self.__foo()
        print("from bar")

# print(A.__dict__)
# print(A.__foo)  # 報錯
# print(A.__x)  # 報錯

# print(A)
a = A(‘hyp‘)
# print(a.__name)  # 報錯

print(a.__dict__)  # _A__name

a.bar()
"""
結果:
{‘_A__name‘: ‘hyp‘}
run foo
from bar
"""

""" 這種變形的特點：
 1.外部無法直接 obj.__AttrName 訪問到
 2.在類內部 obj.__AttrName 可以直接使用
 """

這種自動變形的特點：

　　1、類中定義的__x只能在內部使用，如self.__x，引用的就是變形的結果。
　　2、這種變形其實正是針對外部的變形，在外部是無法通過__x這個名字訪問到的。
　　3、在子類定義的__x不會覆蓋在父類定義的__x，因為子類中變形成了：_子類名__x,而父類中變形成了：_父類名__x，即雙下滑線開頭的屬性在繼承給子類時，子類是無法覆蓋的。

註意的問題：

　　1、這種機制也並沒有真正意義上限制我們從外部直接訪問屬性，知道了類名和屬性名就可以拼出名字：_類名__屬性，然後就可以訪問了，如a._A__N

　　2、變形的過程只在類的定義是發生一次,在定義後的賦值操作，不會變形。

3、在繼承中，父類如果不想讓子類覆蓋自己的方法，可以講方法定義為私有的。

#正常情況
>>> 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

封裝的意義不只是隱藏

1、封裝數據

　　將數據隱藏起來這不是目的。隱藏起來然後對外提供操作該數據的接口，然後我們可以在接口附加上對該數據操作的限制，以此完成對數據屬性操作的嚴格控制。

class Teacher:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def tell_info(self):
        print(‘<name>: %s; <age>: %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(‘hyp‘, 18)
# t.tell_info()
t.set_info(‘lcy‘, 20)
t.tell_info()

2、封裝方法：目的是隔離復雜度

#取款是功能,而這個功能有很多功能組成:插卡、密碼認證、輸入金額、打印賬單、取錢
#對使用者來說,只需要知道取款這個功能即可,其余功能我們都可以隱藏起來,很明顯這麽做
#隔離了復雜度,同時也提升了安全性

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()

特性

　　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(‘hyp‘,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是執行了一個函數然後計算出來的，這種特性的使用方式遵循了統一訪問的原則。

class Foo:
    def __init__(self, val):
        self.__name = val

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError(‘%s must be str‘ %value)
        self.__name = value

    @name.deleter
    def name(self):
        raise TypeError(‘Can not delete‘)

f = Foo(‘HYP‘)
# print(f.name)
f.name = ‘lcy‘
print(f.name)

del f.name

封裝與擴展性

　　封裝在於明確區分內外，使得類實現者可以修改封裝內的東西而不影響外部調用者的代碼；而外部使用用者只知道一個接口(函數)，只要接口（函數）名、參數不變，使用者的代碼永遠無需改變。這就提供一個良好的合作基礎——或者說，只要接口這個基礎約定不變，則代碼改變不足為慮。

#類的設計者
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()

六、綁定方法與非綁定方法

綁定方法：綁定給誰，誰來調用就自動把它本身當做第一個參數傳入

1、綁定到類的方法：用 classmethod 裝飾器的方法。

2、綁定到對象的方法：沒有任何裝飾器的修飾。

classmehtod是給類用的，即綁定到類，類在使用時會將類本身當做參數傳給類方法的第一個參數（即便是對象來調用也會將類當作第一個參數傳入），python為我們內置了函數classmethod來把類中的函數定義成類方法。

class Foo:
    def __init__(self, name):
        self.name = name

    def tell(self):
        print(‘名字是%s ‘ %self.name)

    @classmethod
    def func(cls):  # cls = Foo
        print(cls)
        print(‘>>>>>>‘)
        return cls(‘None‘)

    @staticmethod  # 非綁定方法，可以被隨意調用
    def func1(x, y):
        print(x+y)


f = Foo(‘hyp‘)

# print(Foo.tell)  # 結果: <function Foo.tell at 0x0534AB70>
# Foo.tell(f)

# print(f.tell)  # 結果:<bound method Foo.tell of <__main__.Foo object at 0x04FD7450>>

# f.tell()

# print(Foo.func)  # 變成了 綁定方法

Foo.func()  # 會把 Foo 作為第一個參數傳入
# print(Foo)

# f.func()   # 等價於Foo.func()

# print(Foo.func1)
# print(f.func1)

# Foo.func1(1,2)
# f.func1(1,5)

非綁定方法：用 staticmethod 裝飾器的方法。

不與 類 或 對象 綁定，類和對象都可以調用，但是不能自動傳值。

註意：與綁定到對象方法區分開，在類中直接定義的函數，沒有被任何裝飾器裝飾的，都是綁定到對象的方法，可不是普通函數，對象調用該方法會自動傳值，而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__的執行，打印就不告訴你：

Python全棧開發之路 【第八篇】：面向對象編程設計與開發（2）