面向對象編程

python中一切皆為對象，所謂對象：人是一個對象，電腦是一個對象

我們通過描述屬性（特征）和行為來描述一個對象的。

什么是類

在python中，一個對象的特征也稱為屬性（attribute）。它所具有的行為也稱為方法（method）

結論：對象=屬性+方法

在python中，把具有相同屬性和方法的對象歸為一個類（class）

比如人，動物，植物等等，這些都是類的概念。

類是對象的模板或藍圖，類是對象的抽象化，對象是類的實例化。類不代表具體的事物，而對象表示

具體的事物。

• 類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬

  性和方法。對象是類的實例。

• 類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常

  不作為實例變量使用。

• 數據成員：類變量或者實例變量用于處理類及其實例對象的相關的數據。

• 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆

  蓋（override），也稱為方法的重寫。

• 實例變量：定義在方法中的變量，只作用于當前實例的類。

• 繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個

  派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal

• 類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。

• 實例化：創建一個類的實例，類的具體對象。

• 方法：類中定義的函數。

• 對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

使用class定義類

#類的最簡形式
class Person():
    '著定義了一個類，但是沒有什么功能'
    pass

someone = Person()

同函數一樣，用pass 表示這個類是一個空類

class Person():
    def __init__(self):
        print ('女的，是個活的')
        pass

someone = Person()

當你在類聲明里定義__init__() 方法時，第一個參數必須為self。盡管self 并不是一

個Python 保留字，但它很常用。沒有人（包括你自己）在閱讀你的代碼時需要猜測使用self
的意圖。

添加name 參數

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

someone = Person('xiaohong')

print(someone.name)

第一種方法__init__()方法是一種特殊的

方法，被稱為類的構造函數或初始化方法，當創
建了這個類的實例時就會調用該方法

class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('__init__函數執行了')

someone = Person('xiaohong',18)

print(someone.name)
print(someone.ega)

#記錄類被實例化的次數，再加一個函數用于輸出我們的類的屬性
class Person():
    '這是一個人的類，可以為我們實例化對象'
    person_count = 0

    def __init__(self,name,age):
        self.name = name
        self.age = age
        Person.person_count +=1

    def display_person(self):
        print('姓名：%s,年齡：%s'%(self.name,self.age))

someone1 = Person('xiaohong','18')
someone2 = Person('xiaoli','19')

print(someone.name)
print(someone.age)
print(someone.display_person())
print(someone.person_count)

print(someone1.__class__)
print(someone1.__doc__)#獲取類說明

類的繼承

從已有類中衍生出新的類，添加或修改部分功能。

#繼承

class Car():
    def car_print(self):
        print('''I'm drive a car!!!''')

class Benz(Car):
    pass

drive_car = Car()
drive_Benz = Benz()

print(drive_car.car_print())
print(drive_Benz.car_print())

覆蓋方法（重寫）

#重寫
class Car():
    def car_print(self):
        print('''I'm drive a car!!!''')

class Benz(Car):
    def car_print(self):
        print("I'm drive a Benz car!!!")

drive_car = Car()
drive_Benz = Benz()

drive_car.car_print()
drive_Benz.car_print()

初始化函數重寫

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

class MLPerson(Person):
    def __init__(self,name):
        self.name = "我是漂亮的"+name

class SJRYPerson(Person):
    def __init__(self,name):
         self.name = "我是善解人意的"+name

someone1 = Person('laowang')
someone2 = MLPerson('xiaoli')
someone3 = SJRYPerson('xiaohong')

子類添加新方法

#子類里面添加新方法
class Car():
    def car_print(self):
        print('''I'm drive a car!!!''')

class Benz(Car):
    def car_print(self):
        print("I'm drive a Benz car!!!")
    def didi(self):
        print('didididid!!!')

drive_car = Car()
drive_Benz = Benz()

drive_car.car_print()
drive_Benz.car_print()
drive_Benz.didi()

使用super從父類得到方法

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

class QQPerson(Person):
    def __init__(self,name,QQ):
        super().__init__(name)
        self.qq = QQ

someone = QQPerson('七喜小子','777777')
someone.name
someone.qq

屬性（property）

#屬性 property   ‘getter setter’

class Person():
    def __init__(self,first_name,last_name):
        self.first_name = first_name
        self.last_name = last_name

    def full_name(self):
        return '%s %s'%(self.first_name,self.last_name)

someone = Person('王','小紅')
someone.first_name
someone.last_name
someone.full_name()

someone.first_name = '劉'

someone.full_name = '劉小紅'
someone.full_name


#使用@property
class Person():
    def __init__(self,first_name,last_name):
        self.first_name = first_name
        self.last_name = last_name
    @property
    def full_name(self):
        return '%s %s'%(self.first_name,self.last_name)

someone = Person('王','小紅')
someone.first_name
someone.last_name
someone.full_name = '劉曉紅'  # @property將類中方法只讀屬性

#@property實現getter，seter方法

class Duck():
    def __init__(self,input_name):
        self.hidden_name = input_name
    @property
    def name(self):
        print('insder the getter')
        return self.hidden_name
    @name.setter
    def name(self,input_name):
        print('insder the setter')
        self.hidden_name = input_name

duck = Duck('tanglaoye')

duck.name
duck.name ='米老鼠'
duck.hidden_name='唐老鴨'

名稱重整

#名稱重整
class Duck():
    def __init__(self,input_name):
        self.__name = input_name
    @property
    def name(self):
        print('insder the getter')
        return self.__name
    @name.setter
    def name(self,input_name):
        print('insder the setter')
        self.__name = input_name

duck = Duck('tanglaoye')

duck.name='唐老鴨'
duck.name
duck.__name

duck._Duck__name = '米老鼠'

方法的類型

以self 作為第一個參數的方法都是實例方法（instance method）。上面已經對實例方法做了說明，這里就不再累述。

與之相對，類方法（class method）會作用于整個類，對類作出的任何改變會對它的所有實例對象產生影響。在類定義內部，用前綴修飾符@classmethod 指定的方法都是類方法。與實例方法類似，類方法的第一個參數是類本身。在Python 中，這個參數常被寫作cls，因為全稱class 是保留字，在這里我們無法使用。

class Person():
    '類方法的演示'
    count = 0
    def __init__(self):
        Person.count += 1

    @classmethod
    def my_count(cls):
        print('Person類被實例化了%s次'%cls.count)

someone =Person()
someone1 =Person()
someone2 =Person()
someone.my_count()
Person.my_count()

靜態方法

類定義中的方法還存在著第三種類型，它既不會影響類也不會影響類的對象。它們出現在類的定義中僅僅是為了方便，否則它們只能孤零零地出現在代碼的其他地方，這會影響代碼的邏輯性。這種類型的方法被稱作靜態方法（static method），用@staticmethod 修飾，它既不需要self 參數也不需要class 參數。

@staticmethod

class Person():
    @staticmethod
    def saying():
        print('有朋自遠方來，不亦說乎！')


Person.saying()

鴨子類型

Python 對實現多態（polymorphism）要求得十分寬松，這意味著我們可以對不同對象調用同名的操作，甚至不用管這些對象的類型是什么。

#創建三個類，分別是地瓜、土豆，吃瓜群眾

class TD():
    def __init__(self,person,words):
        self.person  = person
        self.words = words
    def who(self):
        return self.person
    def says(self):
        return self.words + " 。"

class DG(TD):
    def says(self):
        return self.words + "!"
class CG(TD):
    def says(self):
        return self.words + "......"

td = TD('土豆','地瓜地瓜，我是土豆')
dg = DG('地瓜','你叫誰地瓜呢')
cg = CG('吃瓜群眾','哈哈哈哈哈')

td.who()
td.says()

dg.who()
dg.says()

cg.who()
cg.says()

class Duck():
    def who(self):
        return '唐老鴨'
    def says(self):
        return 'gagaga……'

duck = Duck()

#這里我們要演示一下動態類型
def who_say(obj):
    print(obj.who() ,'saying:',obj.says())

who_say(td)
who_say(dg)
who_say(cg)

who_say(duck)

這種方式有時被稱作鴨子類型（duck typing），這個命名源自一句名言：

如果它像鴨子一樣走路，像鴨子一樣叫，那么它就是一只鴨子。

特殊方法

到目前為止，你已經能創建并使用基本對象了。現在再往深鉆研一些。當我們輸入像a = 3 + 8 這樣的式子時，整數3 和8 是怎么知道如何實現+ 的？同樣，a又是怎么知道如何使用= 來獲取計算結果的？你可以使用Python 的特殊方法（specialmethod），有時也被稱作魔術方法（magic method），來實現這些操作符的功能。別擔心，不需要甘道夫8 的幫助，它們一點也不復雜。

這些特殊方法的名稱以雙下劃線（__）開頭和結束。沒錯，你已經見過其中一個：__init__，它根據類的定義以及傳入的參數對新創建的對象進行初始化。假設你有一個簡單的Word 類，現在想要添加一個equals() 方法來比較兩個詞是否一致，忽略大小寫。也就是說，一個包含值'ha' 的Word 對象與包含'HA' 的是相同的。下面的代碼是第一次嘗試，創建一個普通方法equals()。self.text 是當前Word 對象所包含的字符串文本，equals() 方法將該字符串與word2（另一個Word 對象）所包含的字符串做比較

#傳統方式
class Word():
    def __init__(self,text):
        self.text = text

    def equals(self,word2):
        return self.text.lower() == word2.text.lower()

ha1 = Word('Ha')
ha2 = Word('ha')
he = Word('he')

ha1.equals(ha2)
ha1.equals(he)
#ha1 == ha2

#魔法方法
class Word():
    def __init__(self,text):
        self.text = text

    def __eq__(self,word2):
        return self.text.lower() == word2.text.lower()

ha1 = Word('Ha')
ha2 = Word('ha')
he = Word('he')

ha1 == ha2