1. __doc__ 表示类的描述信息
class Dog(object):
'''这个类是描述狗这个对象的'''
def func(self):
pass
print(Dog.__doc__)
# 输出：类的描述信息
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
#lib/aa.py中代码如下：
class C:
def __init__(self):
self.name = 'wupeiqi'
#index.py中代码如下：
from lib.aa import C
obj = C()
print(obj.__module__) # 输出 lib.aa，即：输出模块
print(obj.__class__) # 输出 lib.aa.C，即：输出类
3. __init__ 构造方法，通过类创建对象时，自动触发执行。
4.__del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
5.__call__ 对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
6. __dict__ 查看类或对象中的所有成员
7.__str__ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
8.__getitem__、__setitem__、__delitem__
用于索引操作，如字典,列表。以上分别表示获取、设置、删除数据；也就是对象后面加[],触发执行。
class Foo(object):
def __init__(self):
self.data = {}
def __getitem__(self, key):
print('__getitem__', key)
return self.data.get(key)
def __setitem__(self, key, value):
print('__setitem__', key, value)
self.data[key] =value
def __delitem__(self, key):
print('__delitem__', key)
obj = Foo()
result = obj['k1'] # 自动触发执行 __getitem__
obj['k2'] = 'alex' # 自动触发执行 __setitem__
print(obj['k2']) # 自动触发执行 __getitem__
print(obj.data)
del obj['k1'] #自动触发执行 __delitem__
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
f = Fib()
print(f[0])
说明：对象后面加[]，触发执行。
9. __new__
class Foo(object):
def __init__(self, name):
self.name = name
print("Foo ---init__")
def __new__(cls, *args, **kwargs):
print("Foo --new--")
print(object.__new__(cls)) #输出<__main__.Foo object at 0x0000000001EA33C8>
return object.__new__(cls)
obj = Foo("Alex")
print(obj) #输出<__main__.Foo object at 0x0000000001EA33C8>
说明：
object.__new__(cls) 就是当前实例的内存地址；
__new__至少要有一个参数cls，代表当前类,也就是Foo
__new__必须要有返回值，返回实例化出来的实例
__init__有一个参数self，就是这个__new__返回的实例
__new__ 是创建实例的，__init__ 是初始化实例的；如果__new__ 不return 实例，__init__ 就不能初始化实例，因为__init__中self没有接收到实例；
10. metaclass
在Python2.7中，3.x中都可以：
# metaclass是类的模板，所以必须从`type`类型派生：
class MyType(type):
def __init__(self, what, bases=None, dict=None):
print("--MyType init---")
super(MyType, self).__init__(what, bases, dict)
def __call__(self, *args, **kwargs):
print("--MyType call---")
obj = self.__new__(self, *args, **kwargs)
obj.data = {"name":111}
self.__init__(obj, *args, **kwargs)
class Foo(object,metaclass = MyType):
def __init__(self, name):
self.name = name
print("Foo ---init__")
def __new__(cls, *args, **kwargs):
print("Foo --new--")
print(object.__new__(cls))
return object.__new__(cls)
obj = Foo("Alex")
返回信息：
--MyType init---
--MyType call---
Foo --new--
<__main__.Foo object at 0x7f345f5bcc50>
Foo ---init__
说明：
Foo类中写 metaclass = MyType 它指示Python解释器在创建Foo时，要通过MyType.__new__()来创建，在此，我们可以修改类的定义，比如，加上新的方法，然后，返回修改后的定义。
因为MyType没有重构__new__()这个方法，所以什么都没有执行；在执行__new__()之前先执行__call__，在MyType__call__中定义了如何创建Foo类实例和初始化实例；
Foo类中__new__, 初始化__init__,__call__都是调用MyType的了；
__new__这个对象是由__call__ 创建的,所以先执行__call__ 再执行__new_；
除了使用type()动态创建类以外，要控制类的创建行为，还可以使用metaclass。
metaclass，直译为元类，简单的解释就是：
当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。
但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。
连接起来就是：先定义metaclass，就可以创建类，最后创建实例。
所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。
参考：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319106919344c4ef8b1e04c48778bb45796e0335839000
11.type
class Foo(object):
def __init__(self, name):
self.name = name
f = Foo("alex")
print(type(f)) # 输出：<class '__main__.Foo'> 表示，f 对象由Foo类创建
print(type(Foo)) # 输出：<type 'type'> 表示，Foo类由 type 类创建
#Python中一切事物都是对象。 所以类也是一个对象，Foo类也是一个对象,Foo这个对象就是由type创建出来的；
用type创建类：
sex = 'M'
def func(self):
print('hello %s' % self.name)
def cls_init(self, name, age):
self.name = name
self.age = age
Foo = type('class_name', (object,), {'talk': func,
'__init__': cls_init,'sex':sex})
#type第一个参数：类名
#type第二个参数：当前类的基类，不继承要保留()
#type第三个参数：类的成员
#{'talk': func,'__init__': cls_init,'sex':sex} 就是talk 这个方法 对应func 这个函数;__init__ 这个这个方法对应cls_init这个函数,这个__init__就是实例初始化的方法，__init__这个名称是固定的;sex 这个类属性对应sex这个变量
f = Foo("Chrn", 22)
f.talk()
print(type(Foo))
print(f.sex)
type第二个参数接收的是个元组，注意object后面有个逗号(，) 因为加上逗号是个元组，不加逗号不是个元组，测试代码如下：
X = ('aa')
Y = ('bb',)
print(type(X)) #<class 'str'>
print(type(Y)) #<class 'tuple'>
参考：
https://www.cnblogs.com/alex3714/articles/5213184.html
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319098638265527beb24f7840aa97de564ccc7f20f6000
https://www.cnblogs.com/kex1n/p/5991249.html