1 class P:
 2     #类变量，所有实例共享变量,推荐使用方法是：类名.类变量名
 3     pvarx="ppvar1"
 4
 5     #构造函数
 6     def __init__(self,valuex):
 7         #实例变量，只属于当前实例
 8         self.valuex=valuex
 9
10     #类方法
11     def pfun1(self):
12         print("类方法1输出",self.valuex,P.pvarx)
13
14     #析构函数，先生成，先死亡
15     def __del__(self):
16         print("再见，实例：",self)
17
18 #创建对象，类的实例化
19 p1=P("传递参数")
20
21 #调用类变量
22 P.pvarx="11222333"
23
24 #调用类方法
25 p1.pfun1()
26
27 #删除对象，变量等，直接使用del()
28 #del p1

 1 varx=1 #外部变量
 2
 3 class XX:
 4     def funx(self):
 5         #global varx #声明为外部变量，表示可以长久修改外部变量，不写则只能使用
 6         varx=111
 7         print("------",varx) #输出：111
 8
 9 x=XX()
10 x.funx()
11 print(varx) #输出：1

 1 class P:
 2     pvarx="ppvar1"
 3
 4     #类构造方法
 5     def __init__(self,var1x):
 6         print(var1x)
 7     #类方法
 8     def pfun1(self):
 9         print("PPPPPP")
10
11 #继承P类
12 class P1(P):
13     #重写父类的方法
14     def pfun1(self):
15         #P.pfun1(self) #调用父类的方法1
16         print("p1p1p1p1p1p1",P1.pvarx)
17
18 p1=P1("ppp111")#实例化
19 p1.pfun1()
20 P.pfun1(p1)#调用父类的方法2

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  #调用，如同变量调用

 1 class P:
 2    funxvar11x="xxxx"
 3
 4    #属性方法
 5    @property
 6    def funx(self):
 7        print("-----------",P.funxvar11x)
 8
 9    @funx.setter
10    def funx(self,funxvar11):
11        P.funxvar11x=funxvar11
12
13    @funx.deleter
14    def funx(self):
15        del P.funxvar11x
16
17 p1=P()
18 p1.funx #输出：----------- xxxx
19 p1.funx="1122"  #赋值
20 p1.funx #输出：----------- 1122
21
22 del p1.funx #删除

 1 class P:
 2  def __call__(self, *args, **kwargs):
 3      print("----call----",args)
 4
 5 p1=P()
 6
 7 p1("11",22) #对象加括号传递参数，自动调用类中的call方法
 8 print(p1.__class__) #得到所属类名
 9
10 print(P.__dict__) #类名调用，打印类里的所有属性
11 print(p1.__dict__) #实例调用，打印实例的所有属性

 1 class P:
 2  def pfunx(self, name):
 3      print("---- pfunx ----",name)
 4
 5 p1=P()
 6
 7 if hasattr(p1,"pfunx"): #判断对象里是否有某个方法
 8     funx=getattr(p1,"pfunx") #得到改方法的内存地址
 9     funx("dongxiaodong") #调用该方法
10
11     setattr(p1,"pvar","112233") #设置实例变量值，没有则新建实例变量
12     print(getattr(p1,"pvar")) #使用实例变量
13     delattr(p1, "pvar")  # 删除实例变量