【python入门第三十三天】特殊成员和魔法方法

特殊成员和魔法方法

Python中有大量类似__doc__这种以双下划线开头和结尾的特殊成员及“魔法方法”，它们有着非常重要的地位和作用，也是Python语言独具特色的语法之一！

init: 构造函数，在生成对象时调用
del: 析构函数，释放对象时使用
repr: 打印，转换
setitem:按照索引赋值
getitem:按照索引获取值
len: 获得长度
cmp: 比较运算
call: 调用
add: 加运算
sub: 减运算
mul: 乘运算
div: 除运算
mod: 求余运算
pow: 幂

1.doc
说明性文档和信息。Python自建，无需自定义。

class Foo:				
      """ 描述类信息，可被自动收集 """				
      def func(self):								
          pass
#打印类的说明文档	
print(Foo.__doc__)

2.init()
实例化方法，通过类创建实例时，自动触发执行。

class Foo:				
      def __init__(self,name):								
          self.name = name								
          self.age =20
obj = Foo(python')	#自动执行类中的__init__方法

3.module__和__class
__module__表示当前操作的对象属于哪个模块。__class__表示当前操作的对象属于哪个类。
这两者也是Python内建，无需自定义。

class Foo:				
      pass
obj = Foo()
print(obj.__module__)
print(obj.__class__)
运行结果：
__main__
<class	'__main__.Foo'>

4.del()
析构方法，当对象在内存中被释放时，自动触发此方法。注：此方法一般无须自定义，因为Python自带内存分配和释放机制，除非你需要在释放的时候指定做一些动作。析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:				
      def __del__(self):								
          print("我被回收了！")
obj = Foo()
del obj

5.call()
如果为一个类编写了该方法，那么在该类的实例后面加括号，可会调用这个方法。
注：构造方法的执行是由类加括号执行的，即：对象=类名()，而对于__call__()方法，是由对象后加括号触发的，即：对象()或者类()()

class Foo:				
      def __init__(self):								
          pass				
      def __call__(self,*args,**kwargs):								   
          print('__call__')
obj = Foo()	#执行	__init__
obj()	    #执行	__call__

6.dict
列出类或对象中的所有成员！非常重要和有用的一个属性，Python自建，无需用户自己定义。

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__)
#获取	对象obj1的成员
obj1 = Province('tianjin',10000)
print(obj1.__dict__)
#获取	对象obj2的成员
obj2 = Province('beijing',3888)
print(obj2.__dict__)

7.str()
如果一个类中定义了__str__()方法，那么在打印对象时，默认输出该方法的返回值。这也是一个非常重要的方法，需要用户自己定义。
下面的类，没有定义__str__()方法，打印结果是：

<main.Foo object at 0x000000000210A358>

class Foo:				
      pass
obj = Foo()
print(obj)

定义了__str__()方法后，打印结果是：‘python’。

class Foo:				
      def __str__(self):								
          return 'python'
obj = Foo()
print(obj)

8、getitem()、setitem()、delitem()
取值、赋值、删除这“三剑客”的套路，在Python中，我们已经见过很多次了，比如前面的@property装饰器。
Python中，标识符后面加圆括号，通常代表执行或调用方法的意思。而在标识符后面加中括号[]，通常代表取值的意思。Python设计了__getitem__()、setitem()、delitem()这三个特殊成员，用于执行与中括号有关的动作。它们分别表示取值、赋值、删除数据。
也就是如下的操作：

a = 标识符[]:执行__getitem__方法
标识符[] = a:执行__setitem__方法
del 标识符[]:执行__delitem__方法

如果有一个类同时定义了这三个魔法方法，那么这个类的实例的行为看起来就像一个字典一样，如下例所示：

class Foo:				
      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'] = 'python'	#自动触发执行__setitem__
del obj['k1']		    #自动触发执行__delitem__

9.iter()
这是迭代器方法！列表、字典、元组之所以可以进行for循环，是因为其内部定义了__iter__()这个方法。
如果用户想让自定义的类的对象可以被迭代，那么就需要在类中定义这个方法，并且让该方法的返回值是一个可迭代的对象。当在代码中利用for循环遍历对象时，就会调用类的这个__iter__()方法。
普通的类：

class Foo:				
      pass
obj = Foo()
for i in obj:				
    print(i)
#报错：TypeError:'Foo' object is not iterable<br>#原因是Foo对象不可迭代

添加一个__iter__()，但什么都不返回：

class Foo:				
      def __iter__(self):								
          pass
obj = Foo()
for i in obj:				
    print(i)
#报错：TypeError:iter() returned non-iterator of type	'NoneType'
#原因是__iter__方法没有返回一个可迭代的对象

返回一个个迭代对象：

class Foo:				
      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)
#这下没问题了！

最好的方法是使用生成器：

class Foo:				
      def __init__(self):							
          pass				
      def __iter__(self):								
          yield 1								
          yield 2								
          yield 3
obj = Foo()
for i in obj:				
    print(i)

10、len()
在Python中，如果你调用内置的len()函数试图获取一个对象的长度，在后台，其实是去调用该对象的__len__()方法，所以，下面的代码是等价的：

>>>	len('ABC')
3
>>>	'ABC'.__len__()
3

Python的list、dict、str等内置数据类型都实现了该方法，但是你自定义的类要实现len方法需要好好设计。11.repr()
这个方法的作用和__str__()很像，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，repr()是为调试服务的。通常两者代码一样。

class Foo:				
      def __init__(self,name):								
          self.name = name				
      def __str__(self):								
          return"this is %s"%self.name				
      __repr__ = __str__

12.add:加运算__sub__:减运算__mul__:乘运算__div__:除运算__mod__:求余运算__pow__:幂运算
这些都是算术运算方法，需要你自己为类设计具体运算代码。有些Python内置数据类型，比如int就带有这些方法。Python支持运算符的重载，也就是重写。

class Vector:			
      def __init__(self,a,b):						
          self.a = a						
          self.b = b			
      def __str__(self):						
          return 'Vector (%d,%d)'%(self.a,self.b)			
      def __add__(self,other):						
          return Vector(self.a+other.a,self.b+other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print(v1+v2)

13.author
__author__代表作者信息！类似的特殊成员还有很多，就不罗列了。

#!/usr/bin/env	python
#-*- coding:utf-8 -*-
"""
a test module
"""
__author__ = "python"
def show():				   
    print(__author__)
show()

14.slots
Python作为一种动态语言，可以在类定义完成和实例化后，给类或者对象继续添加随意个数或者任意类型的变量或方法，这是动态语言的特性。例如：

def print_doc(self):				
    print("python")
class Foo:				
    pass
obj1 = Foo()
obj2 = Foo()
#动态添加实例变量
obj1.name = "python"
obj2.age = 20
#动态的给类添加实例方法
Foo.show = print_doc
obj1.show()
obj2.show()

但是！如果我想限制实例可以添加的变量怎么办？可以使__slots__限制实例的变量，比如，只允许Foo的实例添加name和age属性。

def print_doc(self):				
    print("python")
class Foo:				
      __slots__ =("name","age")				
      pass
obj1 = Foo()
obj2 = Foo()
#动态添加实例变量
obj1.name = "python"
obj2.age = 20
obj1.sex = "male"	#这一句会弹出错误
#但是无法限制给类添加方法
Foo.show = print_doc
obj1.show()
obj2.show()

由于’sex’不在__slots__的列表中，所以不能绑定sex属性，试图绑定sex将得到AttributeError的错误。

Traceback (most recent call last):		
   File "F:/Python/pycharm/201705/1.py",line 14,in	<module>				
   obj1.sex = "male"
   AttributeError:'Foo' object has no attribute 'sex'

需要提醒的是，slots__定义的属性仅对当前类的实例起作用，对继承了它的子类是不起作用的。想想也是这个道理，如果你继承一个父类，却莫名其妙发现有些变量无法定义，那不是大问题么？如果非要子类也被限制，除非在子类中也定义__slots，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__