物件（object），python中，一切皆物件。

物件分為兩個部分：靜態物件，動態物件

類：

表示具有相同屬性的方法和物件的集合。封裝物件的屬性和行為的載體，具有相同屬性和行為的稱為一類

面向物件程式設計的三大基本特點：封裝，繼承，多型。

封裝：保證類內部結構完整性，，使用類的使用者只能執行公開的資料，提高程式的可維護性。

繼承：實現重複利用，子類通過繼承父類的的屬性和行為同時又添加了自己的特有的屬性和行為

多型：一個類衍生出不同的子類，子類繼承父類的特徵的同時，也具備自己的特徵，並且可以實現不同的功能。

在使用類時，需要先定義類，在建立類的例項，通過類的例項可以訪問類的屬性方法。

1、歸類——我們可以把學生都歸成一個學生類。

2、抽象出特徵——學生有什麼特點？（學校、姓名、性別、年齡）

3、抽象出技能——學生有什麼技能？（學習、吃飯、打球、睡覺）

定義類：

class ClassName(object)：#一般定義類每個單詞開頭大寫，‘駝峰式命名法’，慣例。

建立類的例項：

class Students(object):     #類
    school = '巨集福教育'     #屬性
    classes = '1807班'      #屬性
    gender = 'man'          #屬性
stu1 = Students()       #
 
宣告例項，繼承Students的屬性
# stu2 = Students()       #宣告例項，繼承Students的屬性
print(stu1.school)      #檢視stui的school屬性
print(stu1.classes)     #檢視classes屬性
print(stu1.gender)      #檢視gender屬性

巨集福教育
1807班
man

可在類中新增函式屬性

class Students(object):     #類
    classes = '1807班'      #屬性
    gender = '
 
man'          #屬性
    def school(self,name):    #可以寫形參，但是self形參必須有，而且在第一位
        print('%s是巨集福學校' % name)

stu1 = Students()       #宣告例項，繼承Students的屬性
stu1.school('zl')      #檢視例項stu1的school函式屬性，可傳引數

zl是巨集福學校

__init__(self)

初始化方法；每當建立一個類的例項時，python都會自動執行它，必須包含一個self引數，並且必須是第一個引數。在例項的方法呼叫時會自動傳遞實際引數self為例項名

class Students(object):     #類
    school = '巨集福學校'
    def __init__(self,name,age):    #設定初始化函式，self=例項名，
        self.qwe = name    #將name形參賦值給self.name
        self.asd = age      #將age形參賦值給self.age
    def event(self):
        print('%s is study,age is %s' % (self.qwe,self.asd))   #呼叫self.name和self.age的值

stu1 = Students('lucy',18)  #建立例項
stu1.event()    #檢視例項屬性
stu2 = Students('harry',29) #建立例項
stu2.event()    #檢視例項屬性
stu3 = Students('tom',20)   #建立例項
stu3.event()    #檢視例項屬性

只要宣告例項就會自動執行init下的程式碼

lucy is study,age is 18
harry is study,age is 29
tom is study,age is 20

__str__(self)

初始化返回值，無需呼叫就會將str裡面的函式自動執行，然後return返回

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


    def __str__(self):
        return '名字:%s\n體重:%s\n' % (self.name, self.weight)


xm = Person('小明', 75)
print(xm)

結果無需呼叫函式，直接print就能將return後面的值返回，每次宣告一個例項都會自動執行。

名字:小明
體重:75

對屬性的增刪改查

#對上面的程式碼進行操作

stu1 = Students('lucy',18)  #建立例項
print(stu1.school)          #檢視

stu1.school = '巨集福'        #修改
print(stu1.school)          #列印修改後的

stu1.city = '北京'          #新增屬性
print(stu1.city)            #列印新增的屬性

del stu1.city               #刪除city屬性

封裝

我們家裡都有電視機，從開機，瀏覽節目，換臺到關機，我們不需要知道電視機裡面的具體細節，只需要在用的時候按下遙控器就可以完成操作，這就是功能的封裝。

在用支付寶進行付款的時候，只需要在用的時候把二唯碼給收款方或是掃一下收款方提供的二唯碼就可以完成支付，不需要知道支付寶的支付介面，以及後臺的處理資料的能力，這就是方法的封裝。

案例：

需求：

1:小明體重75公斤

2:小明每次跑步都會減肥0.5公斤

3:小明每次吃東西都會增加1公斤

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

    def run(self):      #定義run技能
        self.weight -= 0.5  #體重減0.5

    def eat(self):      #定義eat技能
        self.weight += 1    #體重增加1

    def __str__(self):  #定義返回值
        return '名字:%s\n體重:%s\n' % (self.name, self.weight)

xm = Person('小明', 75)     #宣告例項
xm.eat()        #呼叫eat技能
xm.run()        #呼叫run技能
print(xm)

名字:小明
體重:75.5

案例：

需求：

房子包含：戶型，傢俱列表，

傢俱包含：床（6平米），電視（2平米），餐桌（3平米）

把傢俱新增到房子中

檢視房子的：戶型，總面積，剩餘面積，傢俱列表。

#本著定義類要從小到大的原則，所以要先定義傢俱類，在定義房子類
class Furniture(object):            #定義傢俱類
    def __init__(self,name,area):   #初始化
        self.name = name            #傢俱名
        self.area = area            #傢俱面積
        print( '現在商場有一個傢俱%s,佔地%s平米\n' % (self.name,self.area))
class House(object):                #定義房子函式
    def __init__(self,type,sum):    #初始化
        self.type = type            #房子型別
        self.sum = sum              #房子總面積
        self.free = sum             #房子剩餘面積
        self.items = []             #房子裡的傢俱列表
    def add_furniture(self,item):           #定義技能
        self.free = self.free - item.area    #計算剩餘面積
        self.items.append(item.name)        #將傢俱新增到傢俱列表
    def __str__(self):                      #設定返回值
        return '戶型為：%s\n總面積:%s平米\n剩餘面積是%s平米\n家中有傢俱%s' % (self.type,self.sum,self.free,self.items)

bed = Furniture('席夢思',6)    #在傢俱建立床的例項物件
tv = Furniture('電視',2)       #在傢俱建立電視的例項物件
table = Furniture('餐桌',5)    #在傢俱建立餐桌的例項物件

house = House('一室一廳',20)    #建立例項，傳戶型和總面積實參
house.add_furniture(bed)        #給house新增bed
house.add_furniture(table)      #給house新增table
house.add_furniture(tv)         #給house新增tv
print(house)                    #列印返回值

現在商場有一個傢俱席夢思,佔地6平米

現在商場有一個傢俱電視,佔地2平米

現在商場有一個傢俱餐桌,佔地5平米

戶型為：一室一廳
總面積:20平米
剩餘面積是7平米
家中有傢俱['席夢思', '餐桌', '電視']

案例：

需求：

士兵：叫許三多，有一把槍，有一把AK47，可以裝填子彈。

槍：叫AK47，能夠發射子彈。

import time
class Gun(object):                  #建立槍類
    def __init__(self,gun_type):
        self.gun_type = gun_type    #初始化槍的型號
        self.bullet = 0             #初始化子彈的數量

    def add_count(self, count):     #新增子彈
        self.bullet += count

    def shoot(self):                #射擊
        if self.bullet > 0:         #假如子彈數量大於0
            for i in range(self.bullet):
                self.bullet -= 1
                print('衝啊.......突突突突.......[%s]' % self.bullet)
                time.sleep(0.5)

        else:
            print('沒有子彈啊，兄弟，別這麼坑我啊？？？')#否則沒有就顯示沒有子彈


class Soldier:                      #建立一個士兵的類
    def __init__(self, name,gun=None):
        self.name = name            #初始化士兵的姓名
        self.gun = gun              #初始化槍

    def fire(self):                 #開火方法
        if self.gun:                #假如有槍
            self.gun.shoot()        #那就射擊
        else:                       #不然就顯示沒有槍
            print('沒有槍啊，兄弟，你讓我去送死嗎？？')

ak47 = Gun('AK47')                  #建立一個槍的物件叫ak47
ak47.add_count(10)                  #新增10顆子彈
xsd = Soldier('許三多')             #例項化一個許三多的士兵物件
xsd.gun = ak47                      #把槍交到許三多手中
xsd.fire()                          #開火

衝啊.......突突突突.......[9]
衝啊.......突突突突.......[8]
衝啊.......突突突突.......[7]
衝啊.......突突突突.......[6]
衝啊.......突突突突.......[5]
衝啊.......突突突突.......[4]
衝啊.......突突突突.......[3]
衝啊.......突突突突.......[2]
衝啊.......突突突突.......[1]
衝啊.......突突突突.......[0]

繼承

可以繼承一個，也可以繼承多個，實現可程式碼的重複利用性，相同的程式碼不需要重複寫。

重寫

當父類的方法不能夠滿足，不適合子類的需時，可以將父類的方法在子類中重寫

擴充套件

當父類的方法不能夠完全滿足於子類時，可以對父類的方法進行擴充套件

class Anamal(object):       #動物類
    def eat(self):          #定義eat的技能
        print('吃')
    def drink(self):        #定義drink的技能
        print('喝')
class Dog(Anamal):          #狗類，繼承動物類的所有屬性（繼承）
    def bark(self):         #新增自己特有的屬性
        print('汪汪叫')

class XiaoTianQuan(Dog):    #哮天犬繼承狗類的屬性
    def fly(self):          #新增自己的屬性
        print('我會飛啦！！！！')
    def bark(self):         #對父類方法的重寫（修改）
        print('牛逼的叫.......')
        
class Shengquan(Dog):       #新增神犬的類（繼承dog）
    def bark(self):         #擴充套件父類的方法
        print('霸道的叫')   #擴充套件霸道的叫
        super().bark()      #依舊保留父類原有的技能

dog = XiaoTianQuan()        #宣告哮天犬例項
dog.eat()                   #呼叫吃的技能           1
dog.drink()                 #呼叫喝的技能           2
dog.bark()                  #呼叫重寫後的叫的技能   3
dog.fly()                   #呼叫新增的fly技能      4
sq = shengquan()            #宣告神犬例項           
sq.bark()                   #呼叫擴充套件後的技能       5

吃                  #1
喝                  #2
牛逼的叫.......     #3
我會飛啦！！！！    #4
霸道的叫            #5
汪汪叫              #5

多型

子類繼承父類特徵的同時還擁有自己特徵，並且能夠實現不同的效果，

類方法：

@classmethod類方法

一般來說，如果要使用一個類的方法，需要先例項化一個物件在呼叫。

而@classmethod裝飾類方法就不需要例項化，直接類名.方法(),就可以呼叫，當然，也可以用例項化呼叫。

class Anamal(object):   # 動物類
    @classmethod
    def eat(self):      #定義eat的技能，
        print('吃')
    def drink(self):    #定義drink的技能
        print('喝')
Anamal.eat()            #可以通過類名呼叫

dog = Anamal()          #必須例項化才可以呼叫
dog.drink()

吃      #通過類名直接呼叫
喝      #通過例項化後呼叫

@staticmethod靜態方法

裝飾靜態方法，也可以不用例項化就可以呼叫，也可以例項化後呼叫。

class C(object):
    @staticmethod
    def f():            #函式()不需要傳參
        print('aaa')

C.f()       # 靜態方法無需例項化
cobj = C()
cobj.f()    #也可以例項化後呼叫

@staticmethod和@classmethod的區別

@classmethod：需要傳self引數

@staticmethod：不用傳參，靜態