一. __new__ 和 __init__

__new__ : 创建对象

__init__ : 初始化对象

1class Foo(object):
2
3    def __init__(self):
4        print("初始化对象")
5
6    def __new__(cls, *args, **kwargs):
7        print("创建对象")
8        return object.__new__(cls)
9
10obj = Foo()
11
12# 以上代码执行结果是:
13# 创建对象
14# 初始化对象

由此可以看出, python面向对象中 创建对象 的过程是:
(1)执行 __new__ 方法, 最后的返回值才是实例化对象, 这一步是创建对象的过程.
(2)执行 __init__ 方法, 把创建好的对象进行初始化.

二. __call__

__call__ :  在对象后面接一个括号, 表示触发执行__call__方法

1class Foo:
2　　def __call__(self, *args, **kwargs):
3　　　　print("正在执行__call__方法")
4
5obj = Foo()    # 执行__new__方法, 执行__init__方法
6obj()    # 执行__call__方法
7
8# 以上代码执行结果:
9# 正在执行__call__方法

补充: Python内置函数callable的用法

callable()

描述: callable() 函数用于检查一个对象是否是可调用的. 如果返回True, object可能调用成功也可能调用失败, 视情况而定. 但如果返回False, 调用对象ojbect绝对不会成功.简单来讲, 只要内部有__call__方法都返回 True.

语法: callable(object)

参数: object -- 对象

返回值: 若对象可被调用返回True, 否则返回False.

例1:

1class A:
2    def method(self):
3        pass
4
5print(callable(A))  # 类都是可调用的, 返回True
6a = A()
7print(callable(a))  # 对象a没有实现__call__方法,返回False

例2:

1class B:
2    def __call__(self):
3        pass
4
5print(callable(B))  # 类返回True
6b = B()
7print(callable(b))  # 对象b实现了__call__方法,返回True

三. __getitem__, __setitem__, __delitem__

用于索引操作, 与字典的操作方法类似. 以上三者分别表示获取、设置、删除数据.

1class Foo:
2    def __getitem__(self, key):
3        print("正在调用__getitem__方法, 获取到的key是%s" % key)
4
5    def __setitem__(self, key, value):
6        print("正在调用__setitem__方法, 此时key是'%s', value是'%s'" % (key, value))
7
8    def __delitem__(self, key):
9        print("正在调用__delitem__方法, 要删除的key是%s" % key)
10
11obj = Foo()
12
13result = obj["王力宏"]    # 默认执行__getitem__方法
14obj["汪峰"] = "乐坛半壁江山"    # 默认执行__setitem__方法
15del obj["王力宏"]    # 默认执行__delitem__方法
16
17# 以上代码执行结果:
18# 正在调用__getitem__方法, 获取到的key是王力宏
19# 正在调用__setitem__方法, 此时key是'汪峰', value是'乐坛半壁江山'
20# 正在调用__delitem__方法, 要删除的key是王力宏

四. __str__

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

1class Foo:
2    def __str__(self):
3        return "我使用了__str__方法"
4
5obj = Foo()
6print(obj)
7
8# 以上代码执行结果:
9# 我使用了__str__方法

五. __dict__

__dict__ : 获取到类或对象中的所有成员.

1class Foo:pass
2print(Foo.__dict__)    # 获取类Foo中的所有成员
3
4以上代码执行结果是:
5{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}

六. __iter__

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

现在用以下步骤来说明__iter__的作用:

第一步:

1class Foo(object): pass
2obj = Foo()
3for i in obj: print(i)
4
5# 执行结果:
6# TypeError: 'Foo' object is not iterable
7# 报错结果显示: 'Foo'类对象是不可迭代的

第二步:

1class Foo(object):
2    def __iter__(self):
3        pass
4
5obj = Foo()
6
7for i in obj:
8    print(i)
9
10# 执行结果:
11# TypeError: iter() returned non-iterator of type 'NoneType'
12# 报错结果显示: iter方法没有返回一个迭代器

第三步:

1class Foo(object):
2    def __init__(self, iteration):
3        self.iteration = iteration
4
5    def __iter__(self):
6        return iter(self.iteration)
7
8obj = Foo([11, 22, 33])
9
10for i in obj:
11    print(i)
12
13# 执行结果:
14# 11
15# 22
16# 33

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

1obj = iter([11, 22, 33])
2for i in obj: print(i)

七. __class__和__module__

__class__ : 表示当前操作的对象的类是什么.
__module__ : 表示当前操作的对象在哪个模块.

1class Foo:pass
2
3obj = Foo()
4print(obj.__class__)    # 当前操作的对象的类是Foo
5print(obj.__module__)   # 当前操作的对象在__main__模块中
6
7# 以上代码执行结果:
8# <class '__main__.Foo'>
9# __main__

---------------------------------------

参考资料: python面向对象(三) 特殊成员

---------------------------------------