“类”是一个模板，模板中包装了多个“函数”供使用，这篇博文将介绍Python类的成员、成员修饰符、类的特殊成员。

类的成员

类的成员大概可分为三大类：字段、方法和属性

注：所有成员中，只有普通字段的内容保存在对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中， 即：无论对象的多少，在内存中只创建一份。

字段

字段包括普通字段和静态字段，普通字段属于对象，静态字段属于类。

class World:

    string='earth'  #静态字段
    def _init_(self,name):
        self.name='name'  #普通字段

obj=World('China')
#直接访问普通字段
print(obj.name)

#直接访问静态字段
world.string

由上述代码可以看出，普通字段通过对象访问，静态字段通过类访问。即静态字段归属于类，而普通字段归属于对象，类中并没有保存对象中的普通字段。

通过类创建对象时，如果每个对象都有相同的字段，那么就使用静态字段

方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

  • 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；

  • 类方法：由类调用；至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；

  • 静态方法：由类调用；无默认参数；

class Foo:
    def _init_(self,name):
        self.name-name

    #定义普通方法，至少有一个self参数
    def ord_func(self):
        print('普通方法')

    #定义类方法，至少有一个cls参数
    @classmethod
    def class_func(cls):
        print('类方法')

    #定义静态方法，无默认参数
    @staticmethod
    def static_func():
        print('静态方法')

#调用普通方法
f=Foo()
f.ord_func()

#调用类方法
Foo.class_func()

#调用静态方法
Foo.static_func()

这些方法的相同点是均属于类（非对象）中，所以，在内存中只保存一份。不同点是方法的调用不同、调用方法时传入的参数也不同。

属性

属性的基本使用

class Foo:
    def func(self):
        pass

    @property  #定义属性
    def prop(self):
        pass

foo_obj=Foo()
foo_obj.func()
foo_obj.prop  #调用属性

由属性的定义和调用要注意几点：

  • 定义时，在普通方法的基础上添加@property装饰器;
  • 定义时，属性仅有一个self参数;
  • 调用时，无需括号;
  • 方法：foo_obj.func();
  • 属性：foo_obj.prop

属性由方法变种而来，如果Python中没有属性，方法完全可以代替它。

属性的存在可以制造出和访问字段完全相同的假象。

Python属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。

属性的两种定义方式：

  • 装饰器，即：在方法上应用装饰器
  • 静态字段，即：在类中定义值为property对象的静态字段

装饰器方式：在类的普通方法上应用@property装饰器

对于经典类，具有一种@property装饰器

class Goods:
    @property
    def price(self):
        return "four yuan"

obj=Goods()
result=obj.price  #自动执行@property修饰的price方法，并获取方法的返回值

对于新式类，具有三种@property装饰器

class Goods(object):
    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self,value):
        print('@price.setter')

    @price.deleter
    def price(self):
        print('@price.deleter')

obj=Goods()

obj.price  #自动执行@property修饰的price方法，并获取方法的返回值

obj.price=890  #自动执行@property修饰的price方法，并将890赋值给方法的参数

del obj.price  #自动执行@property修饰的price方法

由上述可知：经典类中的属性只有一种访问方式，其对应被@property修饰的方法;新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

由于新式类具有三种访问方法，根据这几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除。

静态字段方式，创建值为property对象的静态字段

当使用静态字段的方式创建属性时，经典类和新式类无区别

class Foo:
    def get_bar(self):
        return 'five yuan'

    BAR=property(get_bar)

obj=Foo()
result=obj.BAR  #自动调用get_bar并获取方法的返回值
print(result)

property的构造方法有四个参数

  • 第一个参数是方法名，调用对象.属性时自动触发执行方法
  • 第二个参数是方法名，调用对象.属性=XXX时自动触发执行方法
  • 第三个参数是方法名，调用del 对象.属性时自动触发执行方法
  • 第四个参数是字符串，调用对象.属性.__doc__，此参数是该属性的描述信息
class Foo：
    def get_bar(self):
        return 'five yuan'

    # 必须两个参数
    def set_bar(self, value):
        return 'set value' + value

    def del_bar(self):
        return 'five yuan'

    BAR ＝ property(get_bar, set_bar, del_bar, 'description...')
   
obj = Foo()
obj.BAR  #自动调用第一个参数中定义的方法：get_bar

#自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
obj.BAR = "alex"

del Foo.BAR  #自动调用第三个参数中定义的方法：del_bar方法
obj.BAR.__doc__  #自动获取第四个参数中设置的值：description...

由于静态字段方式创建属性具有三种访问方式，同样道理，根据几个属性的访问特点，分别将三个方法定义为同一个属性：获取、修改、删除

类成员的修饰符

类的所有成员在前面中已经做了详细的介绍，对于每个类的成员而言都有两种形式：

  • 公有成员，在任何地方都能访问
  • 私有成员，只有在类的内部才能访问

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

class C:
    def __init__(self):
        self.first='公有字段'
        self._second='私有字段'

私有成员与公有成员的访问限制不同：

静态字段

  • 公有静态字段：类可以访问;类内部可以访问;派生类中可以访问
  • 私有静态字段：仅类内部可以访问
class C:
    name='公有静态字段'

    def func(self):
        print(C.name)

class B(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 B(C):
    def show(self):
        print(C.__name)

C.__name  #类访问，结果为错误

obj=C()
obj.func()  #类内部访问

obj_son=D()
obj_son.show()  #派生类中访问，结果为错误

普通字段

  • 公有普通字段：对象可以访问;类内部可以访问;派生类中可以访问
  • 私有普通字段：仅类内部可以访问

（可以通过对象.__类名__私有字段名访问，不建议强制访问私有成员）

关于方法、属性的访问与上述方式相似，即：私有成员只能在类内部访问

类的特殊成员

Python下存在着一些具有特殊含义的成员，如下：

  1. __doc__:表示类的描述信息
class Foo:
"""descrptioin...."""
    def func(self):
        pass

print(Foo.__doc__)  #输出"""descrption..."""

  1. __module__和__class__

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

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

  2. __init__:构造方法，在对象创建的同时即自动触发执行

  3. __del__:析构方法，当对象在内存中被释放时，自动触发执行

    此方法一般无需定义，通常情况下析构函数是有解释器在进行垃圾回收是自动触发执行的。

  4. __call__:对象后面加括号，触发执行

    构造方法的执行是由创建的对象触发的，即：对象=类名();而对于__call__的执行是由对象家括号触发的，即：对象()或者类()()

class Foo:
    def __init__(self):
        pass

    def __call__(self,*args,**kwargs):
        print('__call__')

obj=Foo()  #执行__init__
obj()  #执行__call__

  1. __dict__:类或对象中的成员

    类的普通字段属于对象;类中的静态字段和方法等属于类

  2. __str__:如果一个类中定义了__str__方法，在打印对象时，默认输出该方法的返回值

class A:
    def __str__(self):
        return 'simplestory'

obj=A()
print(obj)  #输出:simplestory

  1. __getitem__、__setitem__、__delitem__

    用于索引操作，分别表示获取、设置、删除数据

class A(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=A()

result=obj['k1']  #自动执行__getitem__
obj['k2']='simplestory'  #自动执行__setitem__
del obj['k1']  #自动执行__delitem__

  1. __getslice__、__setslice__、__delslice__

    这三种方法用于分片操作，如：列表

  2. __iter__

    之所以列表、字典、元组可以进行for循环，是因为类型内部定义了__iter__ for循环迭代的其实是iter

obj=iter([1,2,3,4,5,6,7])

for i in obj:
    print(i)
  1. __new__和__metcalss__
class Foo(object):
    def __init__(self):
        pass

obj=Foo()  #obj是通过Foo类实例化的对象

Python中一切事物都是对象 按照这一理论可以得知：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的构造方法创建。（可以由type()函数查看类的父类）

#继上述代码片段
print(type(obj))
#输出：<class '__main__.Foo'>，表示obj对象由Foo类创建

print(type(Foo))
#输出：<type 'type'>，表示Foo类对象由type类创建

类的创建其实可以有两种方式：

  • 普通方式
class Foo(object):
    def func(self):
        print('Hello World!')
  • 特殊方式（type类的构造函数）
def func(self):
    print('Hello World')

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

类是由type类实例化产生

那对于type类，有一个__metaclass__，其用来表示该类由谁来实例化创建，所以，我们可以为__metaclass__设置一个type类的派生类,然后在__metaclass__的作用域内所创建的类都会基于__metaclass__所指定的类或函数作为type类的派生类。