Python 类的特殊成员

Python 类的特殊成员

一、类的特殊成员

• __doc__（表示类的描述信息）

#   __doc__表示类的描述信息
class Person(object):
    """ 定义人类. 存放人共有的属性. """
    pass
  
P = Person()
print(P.__doc__)
输出:定义人类. 存放人共有的属性. 

• __module__  和  __class__
  • __module__　表示当前操作的对象在那个模块
  • __class__　 表示当前操作的对象的类是什么

　　@一个脚本中__module__ and __class__

class A(object):
    def __init__(self,name):
        self.name = name
  
    def work(self):
        print("I am is %s"%self.name)
  
user = A("Harry")
user.work()
print(user.__module__)
print(user.__class__)
输出:

I am is Harry
__main__
<class '__main__.A'>

　　两脚本实现

class A(object):
    def __init__(self,name):
        self.name = name

    def work(self):
        print("I am is %s"%self.name)

 

from Day_08 import class_s_Mm_04_00

user = class_s_Mm_04_00.A("Harry")

print(user.__module__)
print(user.__class__)

 

　　输出:

Day_08.class_s_Mm_04_00
<class 'Day_08.class_s_Mm_04_00.A'>

　或:（输出同上）

mod = __import__("Day_08.class_s_Mm_04_00")

user = mod.class_s_Mm_04_00.A("Yuhonglin")

print(user)
print(user.__module__)
print(user.__class__)　　

• __main__（表示当前使用的这个类是在自己这个模块里）

class A(object):
    def __init__(self,name):
        self.name = name

    def work(self):
        print("I am is %s"%self.name)

if __name__ == "__main__":
    """__name__ 显示这个模块是以什么方式调用的."""
    user = A("Yuhonglin")
    user.work()
    print(user.__module__)
    print(user.__class__)

　　　　模块在导入时，是全部进行导入。不会导入部分.如果想只导入部分数据则需要在模块下加上 if __name__ == "__main__" 实例化.然后调用

• __init__（表示构造方法，通过类创建对象时.自动触发）

class Foo():
    def __init__(self, name):
        self.name = name
        self.age = 18
        print(self.name ,self.age)

obj = Foo('Harry') # 自动执行类中的 __init__ 方法

输出:
Harry 18

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

class Foo():
    def __init__(self, name):
        self.name = name
        self.age = 18
        print(self.name ,self.age)

    def __del__(self):
        print("......!!!.....")

    def tell(self):
        print(".......")
obj = Foo('Harry')
obj.tell()

　　　　输出:

Harry18
.......
......!!!.....

• __call__（表示对象后面加括号.触发执行）
• 构造方法的执行是由创建对象触发的.即：对象 = 类名(); 而对于 __call__ 方法的执行是由对象后加括号触发的.即：对象() 或者 类()()

class Foo():
    def __init__(self, name):
        self.name = name
        self.age = 18
        print(self.name ,self.age)

    def __call__(self, *args, **kwargs):
        print("---Call",args,kwargs)
        
obj = Foo('Harry')
obj()   #  注意:括号中也可添加参数的.

• __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('sichuan', 100000)
print(obj1.__dict__)

# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'}

obj2 = Province('chongqing', 5000)
print(obj2.__dict__)

# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'}

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

class Foo(object): 
    def __str__(self):
        return 'Harry' 
 
obj = Foo()
print obj
# 输出：Harry

• __getitem__、__setitem__、__delitem__（用于索引操作，如字典，以上分别表示获取、设置、删除数据）

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"] = "Harry"         #  自动触发执行 __setitem__
del obj["k1"]

• __new__ \ __metaclass__

class Foo(object):    
    def __init__(self,name):
        self.name = name   
   
obj = Foo("Harry")　　

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

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

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

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

　　那么. 创建类就可以有两种方式：

a.普通方式

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

b.特殊方式　　

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

@加上构造方法　　

def func(self):
    print("hello %s"%self.name)

def __init__(self,name,age):
    self.name = name
    self.age = age
Foo = type('Foo',(object,),{'func':func,'__init__':__init__})

obj = Foo("Harry",27)
obj.func()

　　

So.  类是由type类实例化产生的

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

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

 

• 自定义元类

class MyType(type):
    def __init__(self,*args,**kwargs):
        print("Mytype __init__",*args,**kwargs)

    def __call__(self, *args, **kwargs):
        print("Mytype __call__", *args, **kwargs)
        obj = self.__new__(self)
        print("obj ",obj,*args, **kwargs)
        print(self)
        self.__init__(obj,*args, **kwargs)
        return obj

    def __new__(cls, *args, **kwargs):
        print("Mytype __new__",*args,**kwargs)
        return type.__new__(cls, *args, **kwargs)

print('Gouer...')
class Foo(object,metaclass=MyType):

    def __init__(self,name):
        self.name = name

        print("Foo __init__")

    def __new__(cls, *args, **kwargs):
        print("Foo __new__",cls, *args, **kwargs)
        return object.__new__(cls)

obj = Foo("Yuhonglin")
print("f",obj)
print("fname",obj.name)　　

类的生成 调用 顺序依次是 __new__ --> __init__ --> __call__

metaclass 详解文章：http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python 得票最高那个答案写的非常好..