类的成员有两种形式
公有成员，在任何地方都能访问
私有成员，只有在类的内部才能方法，私有成员命名时，前两个字符是下划线。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Foo: def __init__(self, name, age): self.name = name self.__age = age def show(self): # 间接方法私有字段 return self.__age obj = Foo('klvchen', 25)print(obj.name)res = obj.show()print(res) |
运行结果：
klvchen
25
公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
私有静态字段：仅类内部可以访问；
|
1
2
3
4
5
6
7
8
9
|
class Foo: __v = '666' # 私有静态字段 def __init__(self): pass def show(self): return Foo.__vobj = Foo()res = obj.show()print(res) |
运行结果:
666
|
1
2
3
4
5
6
7
8
9
10
11
|
class Foo: __v = '666' def __init__(self): pass def show(self): return Foo.__v @staticmethod def stat(): return Foo.__vres = Foo.stat()print(res) |
运行结果:
666
无法从父类继承私有字段
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class F: def __init__(self): self.ge = 123 self.__gene = 456 #私有字段class S(F): def __init__(self, name): self.name = name self.__age = 18 super(S, self).__init__() def show(self): print(self.name) print(self.__age) print(self.ge) print(self.__gene)s = S('klvchen')s.show() |
运行结果:
klvchen
18
123
AttributeError: 'S' object has no attribute '_S__gene'
类的特殊成员
int(对象),会自动执行对象中的__int__方法，并将返回赋值给 int 对象，同理 str(对象)，会自动执行__str__方法，并返回赋值给 str 对象。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Foo: def __init__(self): pass def __int__(self): return 666 def __str__(self): return 'hello world'obj = Foo()print(obj, type(obj))res = int(obj)print(res)res1 = str(obj)print(res1) |
运行结果:
<__main__.Foo object at 0x0000022BBE9DA978> <class '__main__.Foo'>
666
hello world
print(对象)，str(对象)，都会自动执行对象中的__str__方法，并返回
|
1
2
3
4
5
6
7
8
9
10
|
class Foo: def __init__(self, n, a): self.name = n self.age = a def __str__(self): return '%s-%d' %(self.name, self.age)obj = Foo('klvchen', 28)print(obj) |
运行结果：
klvchen-28
两个对象相加时，自动执行第一对象的__add__方法，并且将第二个对象当参数传递进去
|
1
2
3
4
5
6
7
8
9
10
|
class Foo: def __init__(self, name, age): self.name = name self.age = age def __add__(self, other): return self.age + other.ageobj1 = Foo('klv1', 23)obj2 = Foo('klv2', 24)res = obj1 + obj2print(res, type(res)) |
运行结果:
47 <class 'int'>
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
def __add__(self, other):
return Foo(obj1.name, obj2.age)
def __del__(self):
print('析构方法')
obj1 = Foo('klv1', 23)
obj2 = Foo('klv2', 24)
res = obj1 + obj2
print(res, type(res))
运行结果:
<__main__.Foo object at 0x0000016DFCE125C0> <class '__main__.Foo'>
析构方法
析构方法
析构方法
li[对象] 会自动执行 li 对象的类中的__getitem__方法，8当作参数传递给item
|
1
2
3
4
5
6
7
8
9
|
class Foo: def __init__(self, name, age): self.name = name self.age = age def __getitem__(self, item): return itemli = Foo('klvchen', 28)r = li[8]print(r) |
运行结果:
8
类中的__setitem__,__delitem__方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class Foo: def __init__(self, name, age): self.name = name self.age = age def __getitem__(self, item): return item def __setitem__(self, key, value): print(key, value) def __delitem__(self, key): print(key)li = Foo('klvchen', 28)r = li[8]print(r)li[100] = 'hello'del li[999] |
运行结果:
8
100 hello
999
执行类中的__iter__()方法，并获取其返回值，循环上一步中返回对象，用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了iter
|
1
2
3
4
5
6
7
8
9
|
class Foo: def __init__(self, name, age): self.name = name self.age = age def __iter__(self): return iter([11, 22, 33])li = Foo('klvchen', 26)for i in li: print(i) |
运行结果:
11
22
33
for 循环的内部操作
|
1
2
3
4
|
obj = iter([11, 22, 33])while True: val = obj.next() print val |
总结
以上所述是小编给大家介绍的Python 类的特殊成员解析，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
原文链接：http://www.cnblogs.com/klvchen/p/9189384.html
