您现在的位置是:首页 > 文章详情

Python面向对象进阶及类成员

日期:2017-04-20点击:379

再次了解多继承

先来一段代码

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. class A:

  4.    def bar(self):

  5.        print("BAR")

  6.        self.f1()

  7. class B(A):

  8.    def f1(self):

  9.        print("B")

  10. class C:

  11.    def f1(self):

  12.        print("C")

  13. class D(C, B):

  14.    pass

  15. obj = D()

  16. obj.bar()

执行结果

  1. /usr/bin/python3.5 /home/ansheng/文档/Python_code/sublime/Week06/Day03/s1.py

  2. BAR

  3. C

  4. Process finished with exit code 0

流程释意:

  1. 创建了类A、B、C、D;

  2. D继承了CBB继承了AD内什么都不做,pass

  3. 创建一个对象obj,类是D,当执行Dbar方法的时候会先从C里面寻找有没有bar方法;

  4. C内没有bar方法,然后继续从B里面查找,B里面也没有,B的父类是AA里面有bar方法,所以就执行了Abar方法;

  5. Abar方法首先输出了BAR

  6. 然后又执行了self.f1()self=obj,相当于执行了obj.f1()

  7. 执行obj.f1()的时候先从C里面查找有没有f1这个方法,C里面又f1这个方法;

  8. 最后就执行C里面的f1方法了,输出了C

执行父类的构造方法

  1. lass Annimal:

  2.    def __init__(self):

  3.        print("Annimal的构造方法")

  4.        self.ty = "动物"

  5. class Cat(Annimal):

  6.    def __init__(self):

  7.        print("Cat的构造方法")

  8.        self.n = "猫"

  9.        # 寻找Cat类的父类,然后执行父类的构造方法

  10.        super(Cat, self).__init__()

  11. mao = Cat()

  12. print(mao.__dict__)

执行结果

  1. /usr/bin/python3.5 /home/ansheng/文档/Python_code/sublime/Week06/Day03/s1.py

  2. Cat的构造方法

  3. Annimal的构造方法

  4. {'ty': '动物', 'n': '猫'}

  5. Process finished with exit code 0

先执行了Cat的构造方法,然后又执行了Annimal的构造方法。
第二种执行父类的方法如下:

  1. Annimal.__init__(self)

不推荐使用

利用反射查看面向对象成员归属

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. class Foo:

  4.    def __init__(self, name):

  5.        self.name = name

  6.    def show(self):

  7.        print('show')

  8. obj = Foo("as")

  9. # 如果是类,就只能找到类里的成员

  10. print(hasattr(Foo, "show"))

  11. # 如果是对象,既可以找到对象,也可以找类里的成员

  12. print(hasattr(obj, "name"))

  13. print(hasattr(obj, "show"))

执行结果

  1. /usr/bin/python3.5 /home/ansheng/文档/Python_code/sublime/Week06/Day03/s2.py

  2. True

  3. True

  4. True

  5. Process finished with exit code 0

利用反射导入模块、查找类、创建对象、查找对象中的字段

s1脚本文件内容:

  1. #!/usr/bin/env python

  2. # _*_coding:utf-8 _*_

  3. # 导入模块

  4. m = __import__('s2', fromlist=True)

  5. # 去模块中找类

  6. class_name = getattr(m, "Foo")

  7. # 根据类创建对象

  8. obj = class_name("ansheng")

  9. # 去对象中找name对应的值

  10. print(getattr(obj, 'name')

s2脚本文件内容

  1. #!/usr/bin/env python

  2. # _*_coding:utf-8 _*_

  3. class Foo:

  4.    def __init__(self, name):

  5.        # 普通字段,保存在对象中

  6.        self.name = name

执行结果

  1. /usr/bin/python3.5 /home/ansheng/文档/Python_code/sublime/Week06/Day04/s1.py

  2. ansheng

  3. Process finished with exit code 0

面向对象类成员之静态字段

静态字段存在类中,如下:

  1. #!/usr/bin/env python

  2. # _*_coding:utf-8 _*_

  3. # 静态字段存在的意义就是将每个对象中重复的东西在类里面保存一份即可,这就是静态字段

  4. class Provice:

  5.    # 静态字段

  6.    contry = "China"

  7.    def __init__(self, name):

  8.        self.name = name

  9.    def show(self):

  10.        print(Provice.contry, self.name)

  11. hebei = Provice("河北")

  12. hebei.show()

  13. hubei = Provice("湖北")

  14. hubei.show()

执行结果

  1. /usr/bin/python3.5 /home/ansheng/文档/Python_code/sublime/Week06/Day04/s2.py

  2. China 河北

  3. China 湖北

  4. Process finished with exit code 0

类里面的成员类去访问,对象内的成员用对象去访问。

面向对象类成员之静态方法

  1. #!/usr/bin/env python

  2. # _*_coding:utf-8 _*_

  3. class Foo:

  4.    # 静态方法括号内没有self,切方法前一行要加上@staticmethod

  5.    @staticmethod

  6.    def static():

  7.    # def static(arg1, arg2): # 也可以设置参数

  8.        print("static")

  9. # 静态方法通过类名+方法名既可执行

  10. Foo.static()

  11. # Foo.static("arg1", "arg2") 通过类调用的时候传入对于的参数即可

  12. # 静态方法也可以通过对象去访问,对于静态方法用类去访问

  13. obj = Foo()

  14. obj.static()

执行结果

  1. /usr/bin/python3.5 /home/ansheng/文档/Python_code/sublime/Week06/Day04/s2.py

  2. static

  3. static

  4. Process finished with exit code 0

面向对象类成员之类方法

  1. #!/usr/bin/env python

  2. # _*_coding:utf-8 _*_

  3. class Foo:

  4.    # 创建类方法的时候需要在方法前面加上@classmethod

  5.    @classmethod

  6.    def ClassMethod(cls): # 并且方法的括号内必须带有cls关键字,类方法的参数是当前类的类名

  7.        print("类方法")

  8. # 调用类方法

  9. Foo.ClassMethod()

执行结果:

  1. /usr/bin/python3.5 /home/ansheng/文档/Python_code/sublime/Week06/Day04/s2.py

  2. 类方法

  3. Process finished with exit code 0

面向对象类成员内容梳理

字段

1.静态字段(每个对象都有一份)
2.普通字段(每个对象都不同的数据)

方法

1.静态方法(无需使用对象封装的内容)
2.类方法
3.普通方法(适用对象中的数据)

特性

1.普通特性(将方法未造成字段)

快速判断,类执行、对象执行:

1.self —> 对象调用
2.无self —> 类调用


原文链接:https://blog.51cto.com/yw666/1917624
关注公众号

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。

持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

转载内容版权归作者及来源网站所有,本站原创内容转载请注明来源。

文章评论

共有0条评论来说两句吧...

文章二维码

扫描即可查看该文章

点击排行

推荐阅读

最新文章