类即是一个模型，根据模型建立起不同的对象，对象间拥有共同的一些属性
简单的类：
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="" #调用类方法
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="" 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="" #赋值
p1.funx #输出：----------- 1122 del p1.funx #删除
类的一些特殊方法
class P:
def __call__(self, *args, **kwargs):
print("----call----",args) p1=P() p1("",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","") #设置实例变量值，没有则新建实例变量
print(getattr(p1,"pvar")) #使用实例变量
delattr(p1, "pvar") # 删除实例变量