Python檔案袋（ 面向對象 ）

類即是一個模型，根據模型建立起不同的對象，對象間擁有共同的一些屬性

簡單的類：

class P:
    #類變量，所有實例共享變量,推薦使用方法是：類名.類變量名
    pvarx="ppvar1"

    #構造函數
    def __init__(self,valuex):
        #實例變量，只屬于當前實例
        self.valuex=valuex

    #類方法
    def pfun1(self):
        print("類方法1輸出",self.valuex,P.pvarx)

    #析構函數，先生成，先死亡
    def __del__(self):
        print("再見，實例：",self)

#創建對象，類的實例化
p1=P("傳遞參數")

#調用類變量
P.pvarx="11222333"

#調用類方法
p1.pfun1()

#刪除對象，變量等，直接使用del()
#del p1

類變量和實例變量：

類變量：

類及所有實例共享變量,推薦使用方法是 【類名.變量名】

實例變量（self.變量名）：

只屬于當前實例

注意：

如果同名且用實例調用時，則優先尋找到實例變量

使用實例調用并修改類變量值時，只能修改自己的，不影響整體

類方法使用全局變量：

Global聲明變量為外部變量，表示可以長久修改外部變量，不寫則只能使用，不能修改

varx=1 #外部變量

class XX:
    def funx(self):
        #global varx #聲明為外部變量，表示可以長久修改外部變量，不寫則只能使用
        varx=111
        print("------",varx) #輸出：111

x=XX()
x.funx()
print(varx) #輸出：1

類屬性的私有化

私有變量：

在變量前加兩個下劃線即可，如【self.__變量名】，只能在類內訪問，不能在類外通過實例訪問

私有方法：

在類方法名前加入兩個下劃線，如【def __方法名(self){}】，使用與上相同

類的繼承：

類可以實現多繼承，多繼承則可以用逗號分隔類名，如：子類名（父類1，父類2），繼承的執行時從左到右，在列子中是先執行父類1，然后執行父類2

class P:
    pvarx="ppvar1"

    #類構造方法
    def __init__(self,var1x):
        print(var1x)
    #類方法
    def pfun1(self):
        print("PPPPPP")

#繼承P類
class P1(P):
    #重寫父類的方法
    def pfun1(self):
        #P.pfun1(self) #調用父類的方法1
        print("p1p1p1p1p1p1",P1.pvarx)

p1=P1("ppp111")#實例化
p1.pfun1()
P.pfun1(p1)#調用父類的方法2

構造函數：

如果子類有自己的構造函數，則必須在子類構造函數里調用父類的構造函數，如果父類的構造函數參數為空，則可忽略。使用下列方法1可以實現多繼承效果，一句就可以實現多個父類的構造函數，只是其中父類的構造函數參數必須相同

def __init__(self,v1,v2,v3):#super(P1,self).__init__(v1) #執行父類構造函數方法一#P(v1) #執行父類構造函數方法二P.__init__(self,v1) #方法三print(v1,v2,v3)

實例變量的繼承：

父類中可以訪問子類的實例變量

class P:#類方法def pfun1(self):print("PPPPPP",self.p1var)#繼承P類
class P1(P):def __init__(self,p1v):self.p1var=p1vp1=P1(11111)#實例化
p1.pfun1() #輸出：PPPPPP 11111

多態

一個方法的多種實現，通過傳遞實例對象，實現調用實例中對應的方法

def pto(obj):obj.funx()

靜態方法：

通過類名調用，與實例無關

class P:@staticmethoddef funx(varpx):print("-----------",varpx)P.funx("dongxiaodong")

類內方法：

不可訪問實例變量，只能訪問類變量：

class P:#類變量classvarx="112233"def __init__(self):self.xvar="類方法不可訪問此實例變量"#類內方法
   @classmethoddef funx(self,varpx):print("-----------",varpx,self.classvarx)p1=P()
p1.funx("dongxiaodong")

屬性方法：

調用簡單，調用時如同使用變量

class P:#屬性方法
   @propertydef funx(self):print("-----------")p1=P()
p1.funx  #調用，如同變量調用

內容補充：

class P:
   funxvar11x="xxxx"
   
   #屬性方法
   @property
   def funx(self):
       print("-----------",P.funxvar11x)

   @funx.setter
   def funx(self,funxvar11):
       P.funxvar11x=funxvar11

   @funx.deleter
   def funx(self):
       del P.funxvar11x

p1=P()
p1.funx #輸出：----------- xxxx
p1.funx="1122"  #賦值
p1.funx #輸出：----------- 1122

del p1.funx #刪除

類的一些特殊方法

class P:
 def __call__(self, *args, **kwargs):
     print("----call----",args)

p1=P()

p1("11",22) #對象加括號傳遞參數，自動調用類中的call方法
print(p1.__class__) #得到所屬類名

print(P.__dict__) #類名調用，打印類里的所有屬性
print(p1.__dict__) #實例調用，打印實例的所有屬性

反射

class P:
 def pfunx(self, name):
     print("---- pfunx ----",name)

p1=P()

if hasattr(p1,"pfunx"): #判斷對象里是否有某個方法
    funx=getattr(p1,"pfunx") #得到改方法的內存地址
    funx("dongxiaodong") #調用該方法

    setattr(p1,"pvar","112233") #設置實例變量值，沒有則新建實例變量
    print(getattr(p1,"pvar")) #使用實例變量
    delattr(p1, "pvar")  # 刪除實例變量