面向?qū)ο缶幊?/h1>
python中一切皆為對象哈肖，所謂對象：人是一個對象躬拢，電腦是一個對象
我們通過描述屬性（特征）和行為來描述一個對象的躲履。
什么是類
在python中，一個對象的特征也稱為屬性（attribute）估灿。它所具有的行為也稱為方法（method）
結論：對象=屬性+方法
在python中崇呵，把具有相同屬性和方法的對象歸為一個類（class）
比如人，動物馅袁，植物等等域慷，這些都是類的概念。
類是對象的模板或藍圖，類是對象的抽象化犹褒，對象是類的實例化抵窒。類不代表具體的事物，而對象表示
具體的事物叠骑。
-
類(Class): 用來描述具有相同的屬性和方法的對象的集合李皇。它定義了該集合中每個對象所共有的屬
性和方法。對象是類的實例宙枷。
-
類變量：類變量在整個實例化的對象中是公用的掉房。類變量定義在類中且在函數(shù)體之外。類變量通常
不作為實例變量使用慰丛。
-
數(shù)據(jù)成員：類變量或者實例變量用于處理類及其實例對象的相關的數(shù)據(jù)卓囚。
-
方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫诅病，這個過程叫方法的覆
蓋（override）哪亿，也稱為方法的重寫。
-
實例變量：定義在方法中的變量贤笆，只作用于當前實例的類蝇棉。
-
繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個
派生類的對象作為一個基類對象對待芥永。例如篡殷，有這樣一個設計：一個Dog類型的對象派生自Animal
-
類，這是模擬"是一個（is-a）"關系（例圖恤左，Dog是一個Animal）贴唇。
-
實例化：創(chuàng)建一個類的實例，類的具體對象飞袋。
-
方法：類中定義的函數(shù)。
-
對象：通過類定義的數(shù)據(jù)結構實例链患。對象包括兩個數(shù)據(jù)成員（類變量和實例變量）和方法巧鸭。
使用class定義類
#類的最簡形式
class Person():
'著定義了一個類，但是沒有什么功能'
pass
someone = Person()
同函數(shù)一樣麻捻，用pass 表示這個類是一個空類
class Person():
def __init__(self):
print ('女的纲仍，是個活的')
pass
someone = Person()
當你在類聲明里定義__init__() 方法時，第一個參數(shù)必須為self贸毕。盡管self 并不是一
個Python 保留字郑叠，但它很常用。沒有人（包括你自己）在閱讀你的代碼時需要猜測使用self
的意圖明棍。
添加name 參數(shù)
class Person():
def __init__(self,name):
self.name = name
someone = Person('xiaohong')
print(someone.name)
第一種方法__init__()方法是一種特殊的
方法乡革，被稱為類的構造函數(shù)或初始化方法，當創(chuàng)
建了這個類的實例時就會調(diào)用該方法
class Person():
def __init__(self,name,age):
self.name = name
self.age = age
print('__init__函數(shù)執(zhí)行了')
someone = Person('xiaohong',18)
print(someone.name)
print(someone.ega)
#記錄類被實例化的次數(shù)，再加一個函數(shù)用于輸出我們的類的屬性
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()
初始化函數(shù)重寫
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實現(xiàn)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 作為第一個參數(shù)的方法都是實例方法（instance method）细办。上面已經(jīng)對實例方法做了說明，這里就不再累述蕾殴。
與之相對笑撞，類方法（class method）會作用于整個類，對類作出的任何改變會對它的所有實例對象產(chǎn)生影響钓觉。在類定義內(nèi)部娃殖，用前綴修飾符@classmethod 指定的方法都是類方法。與實例方法類似议谷，類方法的第一個參數(shù)是類本身炉爆。在Python 中，這個參數(shù)常被寫作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()
靜態(tài)方法
類定義中的方法還存在著第三種類型逼裆，它既不會影響類也不會影響類的對象郁稍。它們出現(xiàn)在類的定義中僅僅是為了方便，否則它們只能孤零零地出現(xiàn)在代碼的其他地方胜宇，這會影響代碼的邏輯性耀怜。這種類型的方法被稱作靜態(tài)方法（static method），用@staticmethod 修飾桐愉，它既不需要self 參數(shù)也不需要class 參數(shù)财破。
@staticmethod
class Person():
@staticmethod
def saying():
print('有朋自遠方來，不亦說乎从诲！')
Person.saying()
鴨子類型
Python 對實現(xiàn)多態(tài)（polymorphism）要求得十分寬松左痢，這意味著我們可以對不同對象調(diào)用同名的操作，甚至不用管這些對象的類型是什么系洛。
#創(chuàng)建三個類俊性，分別是地瓜、土豆描扯，吃瓜群眾
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()
#這里我們要演示一下動態(tài)類型
def who_say(obj):
print(obj.who() ,'saying:',obj.says())
who_say(td)
who_say(dg)
who_say(cg)
who_say(duck)
這種方式有時被稱作鴨子類型（duck typing）绽诚，這個命名源自一句名言：
如果它像鴨子一樣走路典徊，像鴨子一樣叫杭煎，那么它就是一只鴨子。
特殊方法
到目前為止宫峦，你已經(jīng)能創(chuàng)建并使用基本對象了〔砻保現(xiàn)在再往深鉆研一些。當我們輸入像a = 3 + 8 這樣的式子時导绷，整數(shù)3 和8 是怎么知道如何實現(xiàn)+ 的犀勒？同樣，a又是怎么知道如何使用= 來獲取計算結果的妥曲？你可以使用Python 的特殊方法（specialmethod）贾费，有時也被稱作魔術方法（magic method），來實現(xiàn)這些操作符的功能檐盟。別擔心褂萧，不需要甘道夫8 的幫助，它們一點也不復雜葵萎。
這些特殊方法的名稱以雙下劃線（__）開頭和結束导犹。沒錯，你已經(jīng)見過其中一個：__init__羡忘，它根據(jù)類的定義以及傳入的參數(shù)對新創(chuàng)建的對象進行初始化谎痢。假設你有一個簡單的Word 類，現(xiàn)在想要添加一個equals() 方法來比較兩個詞是否一致卷雕，忽略大小寫节猿。也就是說，一個包含值'ha' 的Word 對象與包含'HA' 的是相同的漫雕。下面的代碼是第一次嘗試滨嘱，創(chuàng)建一個普通方法equals()。self.text 是當前Word 對象所包含的字符串文本浸间，equals() 方法將該字符串與word2（另一個Word 對象）所包含的字符串做比較
#傳統(tǒng)方式
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
