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=p1v


p1=P1(11111)#实例化
p1.pfun1() #输出：PPPPPP 11111

多态

一个方法的多种实现，通过传递实例对象，实现调用实例中对应的方法

def pto(obj):
    obj.funx()

静态方法：

通过类名调用，与实例无关

class P:

   @staticmethod
   def funx(varpx):
       print("-----------",varpx)

P.funx("dongxiaodong")

类内方法：

不可访问实例变量，只能访问类变量：

class P:
    #类变量
   classvarx="112233"

   def __init__(self):
       self.xvar="类方法不可访问此实例变量"

   #类内方法
   @classmethod
   def funx(self,varpx):
       print("-----------",varpx,self.classvarx)

p1=P()
p1.funx("dongxiaodong")

属性方法：

调用简单，调用时如同使用变量

class P:

   #属性方法
   @property
   def 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")  # 删除实例变量