Python档案袋( 面向对象 )

类即是一个模型,根据模型建立起不同的对象,对象间拥有共同的一些属性

简单的类:

 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

类变量和实例变量:

类变量:

类及所以实例共享变量,推荐使用方法是 【类名.变量名】

实例变量(self.变量名):

只属于当前实例

注意:

如果同名且用实例调用时,则优先寻找到实例变量

使用实例修改类变量值时,只能修改自己的,不影响整体

类方法使用全局变量:

Global声明变量为外部变量,表示可以长久修改外部变量,不写则只能使用,不能修改

 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

类属性的私有化

私有变量:

在变量前加两个下划线即可,如【self.__变量名】,只能在类内访问,不能在类外通过实例访问

私有方法:

在类方法名前加入两个下划线,如【def __方法名(self){}】,使用与上相同

类的继承:

类可以实现多继承,多继承则可以用逗号分隔类名,如:子类名(父类1,父类2),继承的执行时从左到右,在列子中是先执行父类1,然后执行父类2
 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
构造函数:
如果子类有自己的构造函数,则必须在子类构造函数里调用父类的构造函数,如果父类的构造函数参数为空,则可忽略。使用下列方法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  #调用,如同变量调用
内容补充:
 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\")  # 删除实例变量

人已赞赏
随笔日记

devops工具-Ansible基础

2020-11-9 3:55:47

随笔日记

半天超200亿!陈光明刷屏:睿远旗下首只公募“一日售罄” 基民入市热情被点燃?

2020-11-9 3:55:49

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索