• python基础(27):类成员的修饰符、类的特殊成员


    1. 类成员的修饰符

    类的所有成员在上一步骤中已经做了详细的介绍,对于每一个类的成员而言都有两种形式:

    公有成员,在任何地方都能访问

    私有成员,只有在类的内部才能方法

    私有成员和公有成员的定义不同:私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:__init__、__call__、__dict__等)

    class C:
     
        def __init__(self):
            self.name = '公有字段'
            self.__foo = "私有字段"

    私有成员和公有成员的访问限制不同:

    1.1 静态字段

    公有静态字段:类可以访问;类内部可以访问;派生类中可以访问

    私有静态字段:仅类内部可以访问

     公有静态字段:

    class C:
    
        name = "公有静态字段"
    
        def func(self):
            print(C.name)
    
    class D(C):
    
        def show(self):
            print(C.name)
    
    
    C.name         # 类访问
    
    obj = C()
    obj.func()     # 类内部可以访问
    
    obj_son = D()
    obj_son.show() # 派生类中可以访问

    私有静态字段:

    class C:
    
        __name = "公有静态字段"
    
        def func(self):
            print(C.__name)
    
    class D(C):
    
        def show(self):
            print(C.__name)
    
    
    C.__name       # 类访问            ==> 错误
    
    obj = C()
    obj.func()     # 类内部可以访问     ==> 正确
    
    obj_son = D()
    obj_son.show() # 派生类中可以访问   ==> 错误

    1.2 普通字段

    公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问

    私有普通字段:仅类内部可以访问

    如果想要强制访问私有字段,可以通过 【对象._类名__私有字段明 】访问(如:obj._C__foo),不建议强制访问私有成员。

    公有普通字段:

    class C:
        
        def __init__(self):
            self.foo = "公有字段"
    
        def func(self):
            print(self.foo)  # 类内部访问
    
    class D(C):
        
        def show(self):
            print(self.foo) # 派生类中访问
    
    obj = C()
    
    obj.foo     # 通过对象访问
    obj.func()  # 类内部访问
    
    obj_son = D();
    obj_son.show()  # 派生类中访问

    私有普通字段:

    class C:
        
        def __init__(self):
            self.__foo = "私有字段"
    
        def func(self):
            print(self.foo)  # 类内部访问
    
    class D(C):
        
        def show(self):
            print(self.foo) # 派生类中访问
    
    obj = C()
    
    obj.__foo     # 通过对象访问    ==> 错误
    obj.func()  # 类内部访问        ==> 正确
    
    obj_son = D();
    obj_son.show()  # 派生类中访问  ==> 错误

    方法、属性的访问于上述方式相似,即:私有成员只能在类内部使用

    非要访问私有属性的话,可以通过 对象._类__属性名

    2. 类的特殊成员

    前面介绍了Python的类成员以及成员修饰符,从而了解到类中有字段、方法和属性三大类成员,并且成员名前如果有两个下划线,则表示该成员是私有成员,私有成员只能由类内部调用。无论人或事物往往都有不按套路出牌的情况,Python的类成员也是如此,存在着一些具有特殊含义的成员,详情如下:

    2.1 __doc__

    表示类的描述信息 

    class Foo:
        """ 描述类信息,这是用于看片的神奇 """
    
        def func(self):
            pass
    
    print Foo.__doc__
    #输出:类的描述信息

    2.2 __module__ 和  __class__

    __module__ 表示当前操作的对象在那个模块

    __class__     表示当前操作的对象的类是什么

     lib/aa.py:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    class C:
    
        def __init__(self):
            self.name = 'xhh'

    index.py:

    from lib.aa import C
    
    obj = C()
    print obj.__module__  # 输出 lib.aa,即:输出模块
    print obj.__class__      # 输出 lib.aa.C,即:输出类

    2.3 __init__

    class Foo:
    
        def __init__(self, name):
            self.name = name
            self.age = 18
    
    obj = Foo('xhh') # 自动执行类中的 __init__ 方法

    2.4 __del__

    析构方法,当对象在内存中被释放时,自动触发执行。

    注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

    class Foo:
    
        def __del__(self):
            pass

    2.5 __call__

    对象后面加括号,触发执行。

    注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

    class Foo:
    
        def __init__(self):
            pass
        
        def __call__(self, *args, **kwargs):
    
            print '__call__'
    
    obj = Foo() # 执行 __init__
    obj()       # 执行 __call__

    2.6 __dict__

    类或对象中的所有成员

    上文中我们知道:类的普通字段属于对象;类中的静态字段和方法等属于类,即:

    class Province:
    
        country = 'China'
    
        def __init__(self, name, count):
            self.name = name
            self.count = count
    
        def func(self, *args, **kwargs):
            print('func')
    
    # 获取类的成员,即:静态字段、方法、
    print Province.__dict__
    # 输出:{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}
    
    obj1 = Province('HeBei',10000)
    print obj1.__dict__
    # 获取 对象obj1 的成员
    # 输出:{'count': 10000, 'name': 'HeBei'}
    
    obj2 = Province('HeNan', 3888)
    print obj2.__dict__
    # 获取 对象obj1 的成员
    # 输出:{'count': 3888, 'name': 'HeNan'}

    2.7 __str__

    如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值。

    class Foo:
    
        def __str__(self):
            return 'xhh'
    
    obj = Foo()
    print(obj)
    # 输出:wupeiqi

    2.8 __getitem__、__setitem__、__delitem__

    用于索引操作,如字典。以上分别表示获取、设置、删除数据 

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
     
    class Foo(object):
     
        def __getitem__(self, key):
            print '__getitem__',key
     
        def __setitem__(self, key, value):
            print '__setitem__',key,value
     
        def __delitem__(self, key):
            print '__delitem__',key
     
    obj = Foo()
     
    result = obj['k1']      # 自动触发执行 __getitem__
    obj['k2'] = 'wupeiqi'   # 自动触发执行 __setitem__
    del obj['k1']           # 自动触发执行 __delitem__

    2.9 __getslice__、__setslice__、__delslice__

    该三个方法用于分片操作,如:列表

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
     
    class Foo(object):
     
        def __getslice__(self, i, j):
            print '__getslice__',i,j
     
        def __setslice__(self, i, j, sequence):
            print '__setslice__',i,j
     
        def __delslice__(self, i, j):
            print '__delslice__',i,j
     
    obj = Foo()
     
    obj[-1:1]                   # 自动触发执行 __getslice__
    obj[0:1] = [11,22,33,44]    # 自动触发执行 __setslice__
    del obj[0:2]                # 自动触发执行 __delslice__

    2.10 __iter__ 

    用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 __iter__ 

    第一步:

    class Foo(object):
        pass
    
    obj = Foo()
    
    for i in obj:
        print(i)
        
    # 报错:TypeError: 'Foo' object is not iterable

    第二步:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    class Foo(object):
        
        def __iter__(self):
            pass
    
    obj = Foo()
    
    for i in obj:
        print(i)
    
    # 报错:TypeError: iter() returned non-iterator of type 'NoneType'

    第三步:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    class Foo(object):
    
        def __init__(self, sq):
            self.sq = sq
    
        def __iter__(self):
            return iter(self.sq)
    
    obj = Foo([11,22,33,44])
    
    for i in obj:
        print(i)

    以上步骤可以看出,for循环迭代的其实是  iter([11,22,33,44]) ,所以执行流程可以变更为:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
     
    obj = iter([11,22,33,44])
     
    for i in obj:
        print(i)

    for循环语法内部:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    obj = iter([11,22,33,44])
    
    while True:
        val = obj.next()
        print(val)

    2.11 __new__ 和 __metaclass__

     阅读以下代码:

    class Foo(object):
     
        def __init__(self):
            pass
     
    obj = Foo()   # obj是通过Foo类实例化的对象

    上述代码中,obj 是通过 Foo 类实例化的对象,其实,不仅 obj 是一个对象,Foo类本身也是一个对象,因为在Python中一切事物都是对象

    如果按照一切事物都是对象的理论:obj对象是通过执行Foo类的构造方法创建,那么Foo类对象应该也是通过执行某个类的 构造方法 创建。

    print type(obj) # 输出:<class '__main__.Foo'>     表示,obj 对象由Foo类创建
    print type(Foo) # 输出:<type 'type'>              表示,Foo类对象由 type 类创建

    所以,obj对象是Foo类的一个实例Foo类对象是 type 类的一个实例,即:Foo类对象 是通过type类的构造方法创建。

    那么,创建类就可以有两种方式:

    1.普通方式

    class Foo(object):
     
        def func(self):
            print 'hello xiaohuihui'

    2.特殊方式(type类的构造函数)

    def func(self):
        print 'hello xiaohuihui'
     
    Foo = type('Foo',(object,), {'func': func})
    #type第一个参数:类名
    #type第二个参数:当前类的基类
    #type第三个参数:类的成员

     类是由 type 类实例化产生

     那么问题来了,类默认是由 type 类实例化产生,type类中如何实现的创建类?类又是如何创建对象?

    答:类中有一个属性 __metaclass__,其用来表示该类由 谁 来实例化创建,所以,我们可以为 __metaclass__ 设置一个type类的派生类,从而查看 类 创建的过程。

     

    class MyType(type):
    
        def __init__(self, what, bases=None, dict=None):
            super(MyType, self).__init__(what, bases, dict)
    
        def __call__(self, *args, **kwargs):
            obj = self.__new__(self, *args, **kwargs)
    
            self.__init__(obj)
    
    class Foo(object):
    
        __metaclass__ = MyType
    
        def __init__(self, name):
            self.name = name
    
        def __new__(cls, *args, **kwargs):
            return object.__new__(cls, *args, **kwargs)
    
    # 第一阶段:解释器从上到下执行代码创建Foo类
    # 第二阶段:通过Foo类创建obj对象
    obj = Foo()
  • 相关阅读:
    SpringMVC详解
    会话控制cookie和session
    jsp详解
    Jquery Enter事件
    JS获取request字符串
    net 2.0使用ajax
    C#通过WebClient/HttpWebRequest实现http的post/get方法
    WCF Rest:不使用UriTemplate使用post方式传参解决HTTP400问题以及参数映射问题
    关于ASP.NET 中站点地图sitemap 的使用
    Web.config自定义节点configSections
  • 原文地址:https://www.cnblogs.com/liuhui0308/p/11861153.html
Copyright © 2020-2023  润新知