下面是类的特殊成员，当我们执行一些特定操作时候，会自动调用这些特殊的方法
1. __doc__
表示类的描述信息
|
1
2
3
4
5
6
7
8
|
>>>
class
Foo:
""" 描述类信息，这是用于看片的神奇 """
def
func(
self
):
pass
print
(Foo.__doc__)
#输出：类的描述信息
-
-
-
-
-
-
-
-
-
-
-
-
-
描述类信息，这是用于看片的神奇
|
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
|
1
2
3
4
5
6
7
|
from
qq
import
person
John
=
person(
'John'
,
'male'
,
30
,
20
)
print
(John.__module__)
print
(John.__class__)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
qq
<
class
'qq.person'
>
|
3. __init__
构造方法，通过类创建对象时，自动触发执行
|
1
2
3
4
|
class
Foo:
def
__init__(
self
, name):
self
.name
=
name
self
.age
=
18
|
obj = Foo('aa') # 自动执行类中的 __init__ 方法
4. __del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
5. __call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
|
1
2
3
4
5
6
7
8
9
|
class
Foo:
def
__init__(
self
):
pass
def
__call__(
self
,
*
args,
*
*
kwargs):
print
(
'__call__'
)
obj
=
Foo()
# 执行 __init__
obj()
# 执行 __call__
-
-
-
-
-
__call__
|
6. __dict__
类或对象中的所有成员
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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'}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
{
'country'
:
'China'
,
'func'
: <function Province.func at
0x000002286C21C620
>,
'__dict__'
: <attribute
'__dict__'
of
'Province'
objects>,
'__doc__'
:
None
,
'__weakref__'
: <attribute
'__weakref__'
of
'Province'
objects>,
'__module__'
:
'__main__'
,
'__init__'
: <function Province.__init__ at
0x000002286C21C598
>}
{
'count'
:
10000
,
'name'
:
'HeBei'
}
{
'count'
:
3888
,
'name'
:
'HeNan'
}
|
7. __str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
|
1
2
3
4
5
6
|
>>>
class
Foo:
def
__str__(
self
):
return
'hhh'
obj
=
Foo()
print
(obj)
hhh
|
8、__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据；也可以用于列表操作，分别表示获取，切片，删除
字典操作
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>>
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'
]
=
'bb'
# 自动触发执行 __setitem__
del
obj[
'k1'
]
# 自动触发执行 __delitem__
__getitem__ k1
__setitem__ k2 bb
__delitem__ k1
|
列表操作（切片）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
>>
class
Foo(
object
):
def
__getitem__(
self
, key):
print
(
'__getitem__'
, key,
type
(key))
def
__setitem__(
self
, key, value):
print
(
'__setitem__'
,
type
(key),
type
(value))
def
__delitem__(
self
, key):
print
(
'__delitem__'
, key)
obj
=
Foo()
result
=
obj[
0
:
3
]
print
(result)
obj[
1
:
3
]
=
[
2
,
3
,
4
,
5
,
6
,
7
]
del
obj[
2
:
3
]
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
__getitem__
slice
(
0
,
3
,
None
) <
class
'slice'
>
None
__setitem__ <
class
'slice'
> <
class
'list'
>
__delitem__
slice
(
2
,
3
,
None
)
|
9. __iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>>
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)
-
-
-
-
-
-
-
-
-
-
-
-
11
22
33
44
|
本文转自 beanxyz 51CTO博客，原文链接：http://blog.51cto.com/beanxyz/1858788，如需转载请自行联系原作者
