python類和對象理解

類的概念

類（class）抽象的概念，比如說人類、鳥類、水果、是一個總的稱呼，沒有具體到某個物體；

對象（object，指具體實例，instance）；

類定義的語法：

class 類名：
　　執行語句
　　類變量
　　類方法

 類最重要的兩部分就是類變量和類方法，類成員之間的可以相互調用。

程序可以在類中給新變量賦值就是增加類變量，可以通過del語句刪除已有類的變量。

在__init__構造函數（構造函數后面會說到）里面的是實例變量，程序可以任何位置（類里面或者類外面）增加實例變量，刪除則用del語句。

在實例方法中有一個特別的方法 ：__init__ ，這個方法被稱為構造方法 。 構造方法用於構造該類的對象， Python 通過調用構造方法返回該類的對象 。 python提供一個功能就是：若開發者沒有定義構造函數，python會自動提供一個只包含self參數默認的構造方法。

class Bird:
    '這是學習python的第一個類'
    eyes = "two"
    def __init__(self, color,feet):
        '為python對象增                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 '
        self.color = color
        self.feet = feet
    def call(self,cd):
        print("This bird:",cd)

上面的 Bird類定義了 一個構造方法，該構造方法只是方法名比較特殊：__init__ ，該方法的第一個參數同樣是 self，被綁定到構造方法初始化的對象 。和函數定義文檔類似，類文檔用字符串即可。該文檔同樣被放在類聲明之后、類體之前。

下面是調用類的構造方法創建對象。第二行是調用實例方法。

xique = Bird("green","two")
xique.call("gezhi")

#打印實例變量
print(xique.color,xique.feet)
#訪問實例變量，對實例變量賦值
xique.color = "brown"
#增加實例變量
xique.skin = 'yellow'
#打印編輯后的實例變量
print(xique.color,xique.feet,xique.skin)
#調用實例方法call()，第一個參數仍是self,self代表實例本身，
#是自動綁定的，不需要再次輸入，因此調用實例方法，只需再輸入一個參數即可
xique.call("zhizhizhizhi")

同一個類的多個對象具有相同的特征，類用定義多個對象的相同特征。類不是一個具體的實體，對象才是一個具體的實體

class Person:
    '這是學習python的第二個類'
    hair = 'black'
    def __init__(self,name = "Will",age = 8):
        '下面對Person對象增加兩個實例變量'
        self.name = name
        self.age = age
    '定義一個say()方法'
    def say(self,content):
        print(content)

給對象增加一個實例變量

# 增加一個skills實例變量
p.skills = ['programming','writing']
print(p.skills)
#刪除p對象的name實例變量，而不是刪除類中變量，新建一個對象，name實例變量還是構造函數默認的。
del p.name
# print(p.name) 會報錯

給對象增加類方法

#動態增加方法
def info(self):
    print("-----info函數-----",self)
    print("動態增加方法")
    return None
p.foo = info  # foo實例方法名，info是我們在外面定義的方法，當然二者名字可以相同

'''方法增加，只用了變量名，后面並沒有加括號方法動態增加，第一個參數並沒有綁定給調
用類的對象，所以我們需要手動把第一個參數輸入，第一個參數是實例本身，可用實例名代表'''
print(p.foo(p))

#如果想自動綁定，調用方法時，不想輸入self參數，可以用type模塊包裝
#重新寫一個函數
def message(self,comment):
    print("我的個人信息是 %s " % comment)
    return None

p2 = Person()
p2.message = message

from types import MethodType
p2.message = MethodType(p2.message,per) 

#綜上，整隊某個對象動態增加的類變量和類方法，只能應用此對象，其他對象需重新增加

 實例方法調用另一個實例方法

class Dog:
    skin = "white"
    def __init__(self,name = 'Aled'):
        self.name = name
    def jump(self):
        print("執行jump方法")
    def run(self):
        self.jump()  #此處不能寫成jump()必須有self,通過調用實例對象的方法
        print("調用run方法")

g = Dog()
g.run() #通過run()方法，調用了jump()方法

類中self參數就是實例本身，可以自動綁定。

#在構造方法中，self參數（第一個參數）表示該構造函數正在初始化的對象
class InConstructor:
    def __init__(self):
        #在構造方法中定義一個foo變量（局部變量）,臨時的
        foo = 1 #這是一個局部變量，不是實例變量，外界無法訪問
        print(type(foo))
        print(foo)
        #把構造方法正在初始化的foo變量編程實例變量，並且重新復制
        self.foo = 5
p = InConstructor()
print(p.foo)

#自動綁定的self參數不依賴具體的調用方式，不管是以方法調用還是函數調用，self參數用一樣可以自動綁定
class User:
    def test(self):
        print("self參數：",self)
u = User()
u.test() #self參數： <__main__.User object at 0x013ADCF0> User對象在內存...

#將User對象的test方法賦值給foo變量
foo = u.test #只需將名字賦值，不要加括號
#通過foo變量調用test()方法
foo() #效果 一樣，因為foo也是指向u.test
#self參數可以作為實例方法返回值

 self可以作為變量來訪問，或者作為實例方法的返回值

當 self 參數作為對象的默認引用時，程序可以像訪問普通變量一樣來訪 問這個self 參數，甚至可以把 self 參數當成實例方法的返回值 。 看下面程序 。 

class ReturnSelf:
    def grow(self):
        if hasattr(self,'age'):
            self.age += 1
            print("有age變量")
        else:
            self.age = 22
            print("無age變量")
        return self #返回調用該方法的實例對象
    def isnotexist(self):
        '實例變量不一定非要在構造方法中定義，也可以在類外，或者類里的實例方法中定義'
        print(self.age)

rs = ReturnSelf()
print(rs.grow().age) # 22
rs.isnotexist() #22
rs.grow().grow().isnotexist() #返回值是self實例本身，然后可以多次調用實例方法或變量

 類也能調用實例方法

 類名.method(參數)

類名.變量名

#類調用實例方法 類名.method

#前面都是通過創建對象，通過對象調用實例方法
#類很大程度上類似命名空間和定義變量和定義函數沒有什么不同

#定義全局空間的foo函數
def foo():
    print("全局空間的foo方法")
#定義全局空間bar變量
bar = 20 
class Bird:
    #定義Bird空間的foo函數
    def foo(self):
        print("Bird空間的foo方法")
    #定義Bird空間的bar變量
    bar = 200
#調用全局空間的函數和變量
foo()
print(bar)
#調用Bird空間的函數和變量
# Bird.foo() 這樣會報錯。缺少self參數
print(Bird.bar)

直接類名+方法會報錯，方法里面必須手動添加參數

class User:
    def walk(self):
        print(self,'正在慢慢走')
#通過類調用實例方法
# User.walk() 這樣報錯 TypeError

u = User() 

User.walk(u)  #顯式方法的第一個參數綁定參數值

這樣的調用效果等同於u.walk()

實際上，當通過 User 類調用 walk()實例方法時， Python只要求手動為第一個參數綁定參數值，並不要求必須綁定 User 對象，因此也可使用如下代碼進行調用 。 

User.walk("任意輸入都有可以，不一定非得是self參數")

如果傳入兩個參數呢

class Peaple:
    def walk(self,name = "Will"):
        print(name,"坐着",self)
#和普通函數調用沒啥區別，就當self是一個變量名，參數隨便輸入
Peaple.walk("吃飯")
Peaple.walk("吃飯","Alex")

類方法和靜態方法

 Python其實可以支持類方法定義，區別前面的實例方法，同時只是靜態方法定義，類方法和靜態方法類似，都可以通過類調用（同時也支持對象調用）區別在於類方法第一個參數為cls，會自動綁定到類，而靜態方法不會自動綁定到類

class Bird:
    #使用classmethod是類方法
    @classmethod
    def fly(cls):
        print('類方法fly:',cls)
    #使用staticmethod修飾的是靜態方法
    @staticmethod
    def info(p):
        print('靜態方法info:',p)
#調用類方法，類會自動綁定到第一個參數cls
Bird.fly()
#調用靜態方法，不會自動綁定，意思是第一個參數必須手動輸入
Bird.info("真麻煩")
#創建Bird對象
b = Bird()
#使用對象調用fly類方法，其實還是使用類調用
#因此第一個參數 依然自動綁定到Bird類
b.fly()
#使用對象調用info靜態方法，其實還是使用類調用
b.info('fkit')

 裝飾器

#裝飾器
#funA裝飾funB，funB作為參數引入到funA中，同時funA返回值就是修飾后的返回值
def funA(funB):
    print("A")
    funB()
    return "最終修飾結果"
def funB():
    print("B")
funB()

@funA
def funB():
    print("B")
print(type(funB)) #這里是函數名，不是函數調用
print(funB) #裝飾函數修飾后，通過被修飾函數名查看返回值

這個函數裝飾器導致被修飾的函數變成了字符串，那么函數裝飾器有什么用？別忘記了，被修飾的函數總是被替換成＠符號所引用的函數的返回值，因此被修飾的函數會變成什么，完全由於＠符號所引用的函數的返回值決定一一如果＠符號所引用的函數的返回值是函數，那么被修飾的函數在替換之后還是函數 。

def foo(fn):
    #定義一個嵌套函數
    def bar(*args):
        print("===1===",args)
        n = args[0]
        print("===2===",n * (n -1))
        #查看傳遞給foo函數的fn函數
        print(fn.__name__)
        fn(n * (n -1))
        print("*" * 15)
        return fn(n * (n -1))
    return bar

@foo
def my_test(a):
    print("===my_test函數===",a)
print(my_test)  #返回值是bar函數<function foo.<locals>.bar at 0x032C3D20>
my_test(10)  #意思就是my_test函數被bar函數替換，調用my_test函數就是調用bar函數
my_test(6,5)

上面裝飾結果相當於foo(my_test)，my_test函數會被替換（裝飾）成foo（my_test）的返回值，他的返回值是bar函數，因此funB（my_test函數）就是bar函數

 通過修飾函數，也可以在修飾函數中添加權限檢查，邏輯驗證，異常處理

下面將示范通過函數修飾器給函數添加權限檢查的功能：

def auth(fn):
    def auth_fn(*args):
        print("----模擬執行權限檢查-----")
        #回調被修飾的目標函數
        fn(*args) #作為函數參數時前面必須有*，如果在函數里面的參數則為args
    return auth_fn
@auth
def bedecorated(a,b):
    print("執行bedecotated函數，參數a:%s,參數b:%s" % (a, b))

#調用bedecorated函數，其實就是調用修飾后返回的auth_fn函數

bedecorated(4,5)    

類命名空間

#類命名空間
global_fn = lambda p: print("執行lambda表達式，P參數：",p)
class Category:
    cate_fn = lambda p:print("執行lambda表達式，p參數",p)
#調用全局的global_fn，為參數p傳入參數值
global_fn('fkit')
c = Category()
c.cate_fn()

綜上，在全局命名空間調用，類命名空間的lambda函數也可以調用，通過類對象調用lambda函數相當於調用類方法，python同樣會自動為該剛方法綁定第一個參數值（self），也就是實例對象本身

成員變量

class Address:
    detail = '廣州'
    post_code = '2019723'
    def info(self):
        #嘗試直接訪問類變量
        #print(detail) 報錯
        print(Address.detail)
        print(Address.post_code)
Address.info(32) #通過類調用方法，需要手動輸入第一個參數
#通過類來訪問Address類的類變量
print(Address.detail)
addr = Address()
addr.info()
#修改Address的類變量
Address.detail = "佛山"
Address.post_code = '2018723'
addr.info()

 在類命名空間內定義的變量就屬於類變量 ， Python 可以使用類來讀取、修改類變量。 對於類變量而言，它們就是屬於在類命名空間內定義的變量 ，因此程序不能直接訪問這些變量，程序必須使用類名來調用類變量。不管是在全局范圍內還是函數內訪問這些類變量，都必須使用類名進行訪問。

#python也可以使用對象訪問類變量，建議使用類訪問類變量
class Record:
    #定義兩個類變量
    item = '鼠標'
    date = '2019-07-23'
    def info(self):
        print('info方法：',self.item)
        print('info方法：',self.date)
rc = Record()
print(rc.item)
print(rc.date)
rc.info()

#修改Record類的兩個類變量
Record.item = "鍵盤"
Record.date = '2020-01-01'
rc.info()

 

 Python 允許通過對象訪問類變量 ，但如果程序通過對象嘗試對類變量賦值，此時性質就變了一Python 是動態語言，賦值語句往往意味着定義新變量。因此，如果程序通過對象對類變量賦值，其實不是對“類變量賦值”，而是定義新的實例變量 。例如如下程序 。

class Inventory:
    #定義兩個變量
    quantity = 2000
    item = '鼠標'
    #定義實例方法
    def change(self,item,quantity):
        self.item = item
        self.quantity = quantity
#創建Inventory對象
iv = Inventory()
iv.change('顯示器',500)
#訪問iv的item和quantity實例變量
print(iv.item) #顯示器
print(iv.quantity) #500

#訪問Inventotry的item和quantity類變量
print(Inventory.item) #鼠標
print(Inventory.quantity) #2000

 

通過類修改類變量的值，實例變量不會受到影響

Inventory.item = '類變量item'
Inventory.quantity = '類變量quantity'
#訪問iv對象的實例變量item和quantity
print(iv.item) #顯示器
print(iv.quantity) #500

同樣修改實例變量的值，這種修改也不影響類變量或者其他對象的實例變量。

iv.item = 'iv實例變量item'
iv.quantity = 'iv實例變量quantity'
print(Inventory.item)
print(Inventory.quantity)
iv2 = Inventory()
print(iv2.item) #類變量item,前面修改了類變量，此處沒有調用change方法創建新的實例變量，所以這樣調用的是類變量
#新對象創建實例變量item ,quantity
iv2.change('音響',600)
print(iv2.item) #音響，這次就不是類變量了，因為創建的實例變量，python內在機制，實例可以調用類變量，其實還是通過類訪問的類變量

 使用property函數定義屬性

class Retangle:
    def __init__(self,width,height):
        self.width = width
        self.height = height
    def setsize(self,size_):
        self.width,self.height = size_
    def getsize(self):
        return self.width,self.height
    def delsize(self):
        self.width,self.height = 0,0
    size = property(getsize,setsize,delsize,'描述事物的屬性')
#訪問size的說明文檔
print(Retangle.size.__doc__)
#通過內置的help函數查看說明文檔
help(Retangle.size)
rect = Retangle(4,3)
print(rect.size)
rect.setsize((7,9))
print(rect.size)
rect.size = 9,7
print(rect.width,rect.height)
del rect.size
print(rect.width,rect.height)

class Retangle:
    def __init__(self,width,height,length):
        self.width = width
        self.height = height
        self.length = length
    def getsize(self):
        return self.width,self.height,self.length
    def setsize(self,size):
        self.width,self.height,self.length = size
    def delsize(self):
        self.width,self.height,self.length = 0,0,0
    size = property(getsize,setsize,delsize,'描述事物的屬性')
rec = Retangle(88,56,72)
print(rec.size)
rec.size = 85,45,23
print(rec.size)
print(rec.width,rec.length,rec.height)
del rec.size
print(rec.size)


class User:
    def __init__(self,first,last):
        self.first = first
        self.last = last
    def getfullname(self):
        return self.first + ',' + self.last
    def setfullname(self,fullname):
        name = fullname.split(',')
        self.first = name[0]
        self.last = name[1]
    fullname = property(getfullname,setfullname)
u = User('孫','悟空')
print(u.fullname)
print(u.first,u.last)
u.fullname = 'smith,jackey'
print(u.fullname)
print(u.first,u.last)

 隱藏和封裝

class User:
    def __hide(self):
        print("示范隱藏的方法")
    def getname(self):
        return self.__name

    def setname(self,name):
        if len(name) < 3 or len(name) > 8:
            raise ValueError("輸入長度在3-8之間的")
        self.__name = name
    name = property(getname,setname) #參數必須先

    def getage(self):
        return self.__age #可以和property的屬性區分開來
    def setage(self,age):
        if age < 11 or age > 70:
            raise ValueError("年齡在11到70歲之間")
        self.__age = age
    age = property(getage,setage)

u = User()
u.name = "fuck"
print(u.name)
print(u.getname())
u.age = 56
print(u.getage())

set和get函數方法順序無關，但是property函數內參數，必須是先讀取后寫入的順序。

繼承

#繼承
class Fruit:
    def info(self,weight): #如果后面有參數，函數內就必須初始化，如果沒參數，后面初始化不同寫
        self.weight = weight
        print("this fruit weigh %s" % (self.weight))
class Food:
    def taste(self):
        print("不同食物，口味不同")
class Apple(Fruit,Food):
    pass
a = Apple()
a.info(25)
a.taste()

 

#當父類方法名字重合，選擇第一個
class Item:
    def info(self):
        print("這是一個商品")
class Product:
    def info(self):
        print('這是一個工藝')

class Mouse(Product,Item): #父類順序，如果有相同的方法，先調用一個參數
    pass

m = Mouse()
m.info()

父類方法重寫

class Bird:
    def fly(self):
        print("我在天空里自由自在地飛翔")
class Ostrich(Bird):
    #重寫Bird類的fly()方法
    def fly(self):
        print("我只能在地上奔跑")
#創建Ostrich對象
os = Ostrich()
#執行Ostrich對象的fly(),將輸出“我只能在地上奔跑”
os.fly()

 

 子類重寫父類方法，那如何調用父類被重寫的方法。

class BaseClass:
    def foo(self):
        print("父類中定義的foo方法")
class SubClass(BaseClass):
    def foo(self):
        print("子類中定義的foo方法")
    def bar(self):
        print("執行bar方法")
        self.foo()
        #通過類名調用父類被重寫的方法
        BaseClass.foo(self)
sc = SubClass()
sc.bar()

 使用super函數調用父類構造方法

class  Employee:
    def __init__(self,salary):
        self.salary = salary
    def work(self):
        print("普通員工正在寫代碼，工資是：",self.salary)
class Customer:
    def __init__(self,favorite,address):
        self.favorite = favorite
        self.address = address
    def info(self):
        print("我是一個顧客，我的愛好是：%s,地址是%s" % (self.favorite,self.address))
        #manager 繼承了Employee,Customer
class Manager(Customer):
    def __init__(self,favorite,address):
        print("manager的構造方法")
        #通過super函數調用父類的構造方法
        super(Manager,self).__init__(favorite,address)

        

m = Manager("IT","beijing")

m.info()

class Fooparent:
    def __init__(self):
        self.parents = 'I\'m the parent' # 5
        print("Parent11") # 1
    def bar(self,message):
        print("%s from Parent"% message) # 3
class FooChild(Fooparent):
    def __init__(self):
        super(FooChild,self).__init__()
        print("child22") # 2
    def bar(self,message):
        super(FooChild,self).bar(message)
        print("Child bar function") #4
        print(self.parents)
if __name__ == "__main__":
    foochild = FooChild() #創建一個子類對象
    foochild.bar("helloworld")

#從上面可見先執行父類構造函數的打印函數，在執行子類打印函數，然后根據調用執行父類函數

 

python動態屬性與slots

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

def walk_func(self):
    print("%s慢慢走過每一片草地"% self.name)
d1 = Cat('Marry')
d2 = Cat('Kitty')
Cat.walk = walk_func
d1.walk()
d2.walk()

#__slot__限制動態添加的屬性和方法
class Dog:
    __slots__ = ('walk','age','name')
    def __init__(self,name):
        self.name = name
    def test():
        print("預先定義好的test方法")
d = Dog('Snoogy')
d.age = 5
print(d.age)
# d.weight = 24報錯
Dog.walk = walk_func
d.walk()
Dog.bar = lambda self:print("abc")
d.bar()

type函數定義類

def fn(self):
    print("fn函數")
#使用type函數定義Dog類
Dog = type('Dog',(object,),dict(walk = fn,age = 6))
#創建dog對象
d = Dog()
#分別查看d.dog的類型
print(type(d))
print(type(Dog))
print(type(Dog()))
print(type(d.walk))
d.walk()
print(d.age)