Python中的魔法属性

魔法属性

在Python中，所有以 __ 双下划线包起来的方法，都统称为 Magic Method，例如类的初始化方法 __init__() ，实例对象创造方法 __new__()等。

魔法属性和方法是Python内置的一些属性和方法，有着特殊的含义。命名时前后加上两个下划线，在执行系统特定操作时，会自动调用。

<br/>

常见的魔法属性

\_\_doc\_\_

表示类的描述信息

# __doc__
class Foo:
    """ 描述类信息，这是用于测试的类 """
    
    def func(self):
        pass

    
# ipython 测验
In [2]: Foo.__doc__
Out[2]: ' 描述类信息，这是用于测试的类 '
    

<br/>

\_\_module\_\_ 和 \_\_class\_\_

• __module__ 表示当前操作的对象在那个模块
• __class__ 表示当前操作的对象的类是什么

# __module__、__class__
# oop.py
class Student(object):
    
    def __init__(self, name):
        self.name = name
        
        
# main.py
from oop import Student

s = Student()
print(s.__module__)  # 输出 oop 即：输出模块
print(s.__class__)   # 输出 <class 'oop.Student'> 即：输出类

<br/>

\_\_init\_\_ 、\_\_new\_\_

__init__() 初始化方法 和 __new__()，通过类创建对象时，自动触发执行。 __new__ 是用来创建类并返回这个类的实例，而 __init__ 只是将传入的参数来初始化该实例。

• __new__() 创建对象时调用，会返回当前对象的一个实例
• __init__() 创建完对象后调用，对当前对象的一些实例初始化，无返回值

# __init__ 、 __new__
class Student(object):

    def __init__(self, name, age):
        print('__init__() called')
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        print('__new__() called')
        print(cls, args, kwargs)
        return super().__new__(cls)
  

# ipython 测验
In [26]: s1 = Student('hui', age=21)
__new__() called
<class '__main__.Student'> ('hui',) {'age': 21}
__init__() called

In [27]: s2 = Student('jack', age=20)
__new__() called
<class '__main__.Student'> ('jack',) {'age': 20}
__init__() called

<br/>

\_\_del\_\_

当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，有 内存管理、垃圾回收机制，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，__del__ 的调用是由解释器在进行垃圾回收时自动触发执行的。

# __del__
class Foo:
    def __del__(self):
        print('__del__() called')

        
# ipython 测验
In [29]: f = Foo()

In [30]: del f
__del__() called

<br/>

\_\_call\_\_

让类的实例的行为表现的像函数一样，你可以调用它们，将一个函数当做一个参数传到另外一个函数中等等。这是一个非常强大的特性，其让Python编程更加舒适甜美。 对象后面加括号，触发执行。

注：__init__ 方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

__call__ 在那些 类的实例经常改变状态的时候会非常有效。调用这个实例是一种改变这个对象状态的直接和优雅的做法。用一个实例来表达最好不过了：

# __call__
class Rect(object)
    """
    调用实例对象来改变矩形的位置
    """

    def __init__(self, x, y):
        # x, y代表矩形坐标
        self.x, self.y = x, y

    def __call__(self, x, y):        
        # 改变实体的位置
        self.x, self.y = x, y


# ipython 测验
In [33]: r = Rect(10, 10)

In [34]: r.x, r.y
Out[34]: (10, 10)

In [35]: r(0, 0)

In [36]: r.x, r.y
Out[36]: (0, 0)

In [37]: r(100, 100)

In [38]: r.x, r.y
Out[38]: (100, 100)

<br/>

\_\_dict\_\_

类或对象中的所有属性

类的实例属性属于对象；类中的类属性和方法等属于类，即：

# __dict__
class Student(object):

    def __init__(self, name, age):
        self.name = name
        self._age = age

    @property
    def age(self):
        return self._age

    
# ipython 测验
In [47]: # 获取类属性

In [48]: Student.__dict__
Out[48]:
mappingproxy({'__module__': '__main__',
              '__init__': <function __main__.Student.__init__(self, name, age)>,
              'age': <property at 0x210e2a005e8>,
              '__dict__': <attribute '__dict__' of 'Student' objects>,
              '__weakref__': <attribute '__weakref__' of 'Student' objects>,
              '__doc__': None})

In [49]: # 获取实例对象的属性

In [50]: s = Student('hui', 21)

In [51]: s.__dict__
Out[51]: {'name': 'hui', '_age': 21}

In [52]: s2 = Student('jack', 20)

In [53]: s2.__dict__
Out[53]: {'name': 'jack', '_age': 20}

<br/>

\_\_str\_\_

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

In [65]: # __str__
    ...: class Foo(object):
    ...:     pass
    ...:

In [66]: f = Foo()

In [67]: print(f)
<__main__.Foo object at 0x00000210E2715608>

In [68]: class Foo(object):
    ...:
    ...:     def __str__(self):
    ...:         return '< Custom Foo object str >'
    ...:

In [69]: f = Foo()

In [70]: print(f)
< Custom Foo object str >

<br/>

\_\_getitem\_\_、\_\_setitem\_\_、\_\_delitem\_\_

用于索引操作，如字典。以上分别表示获取、设置、删除数据。

用于切片操作，如列表。

<br/>

字典示例

# __getitem__、__setitem__、__delitem__
class MyDict(object):

    def __init__(self):
        self.my_dict = dict()

    def __getitem__(self, key):
        print('__getitem__() ', key)
        return self.my_dict.get(key, None)

    def __setitem__(self, key, value):
        print('__setitem__() ', key, value)
        self.my_dict.update(key=value)

    def __delitem__(self, key):
        print('__delitem__() ', key)
        del self.my_dict[key]


# ipython 测验        
In [33]: mdict = MyDict()

In [34]: print(mdict['name'])
__getitem__()  name
None

In [35]: # 新增

In [36]: mdict['name'] = 'hui'
__setitem__()  name hui

In [37]: mdict['age'] = 21
__setitem__()  age 21

In [38]: mdict['name']
__getitem__()  name
Out[38]: 'hui'

In [39]: mdict['age']
__getitem__()  age
Out[39]: 21

In [40]: # 更新

In [41]: mdict['name'] = 'jack'
__setitem__()  name jack

In [42]: mdict['name']
__getitem__()  name
Out[42]: 'jack'

In [43]: # 删除

In [44]: del mdict['age']
__delitem__()  age

In [45]: print(mdict['age'])
__getitem__()  age
None

<br/>

列表示例

# 切片操作
class MyList(object):

    def __init__(self):
        self.mlist = list()

    def __getitem__(self, index):
        print('__getitem__() called')
        print(index)
        if isinstance(index, slice):
            return self.mlist[index]

    def __setitem__(self, index, value):
        print('__getitem__() called')
        print(index, value)
        if isinstance(index, slice):
            self.mlist[index] = value

    def __delitem__(self, index):
        print('__delitem__() called')
        if isinstance(index, slice):
            del self.mlist[index]
     
    
# ipython 测验
In [70]: mlist = MyList()

In [71]: mlist[0]
__getitem__() called
0

In [72]: mlist[0:-1]
__getitem__() called
slice(0, -1, None)
Out[72]: []

In [73]: mlist[:] = [1,2,3]
__getitem__() called
slice(None, None, None) [1, 2, 3]

In [74]: mlist[:]
__getitem__() called
slice(None, None, None)
Out[74]: [1, 2, 3]

In [75]: mlist[0:2]
__getitem__() called
slice(0, 2, None)
Out[75]: [1, 2]

In [76]: mlist[::-1]
__getitem__() called
slice(None, None, -1)
Out[76]: [3, 2, 1]

In [77]: mlist[0]
__getitem__() called
0

In [78]: mlist[0:1]
__getitem__() called
slice(0, 1, None)
Out[78]: [1]

In [79]: del mlist[0:1]
__delitem__() called

In [80]: mlist[:]
__getitem__() called
slice(None, None, None)
Out[80]: [2, 3]

<br/>

注意： 当进行 mlist[0] 操作的时候传递并不是一个 slice 对象，不是一个 int 类型的数字，所以不能把索引为 0 的值取出来，改成 mlist[0, 1] 或者在 __getitem__() 的方法中新增数字判断，大家可以尝试一下。

<br/>

\_\_enter\_\_、\_\_exit\_\_

with 声明是从 Python2.5 开始引进的关键词。你应该遇过这样子的代码:

with open('foo.txt') as bar:
    # do something with bar
    pass

在 with 声明的代码段中，我们可以做一些对象的开始操作和退出操作,还能对异常进行处理。这需要实现两个魔术方法: \_\_enter\_\_ 和 \_\_exit\_\_。

__enter__(self):

定义了当使用 with 语句的时候，会话管理器在块被初始创建时要产生的行为。请注意，__enter__ 的返回值与 with 语句的目标或者 as 后的名字绑定。

__exit__(self, exception_type, exception_value, traceback):

定义了当一个代码块被执行或者终止后，会话管理器应该做什么。它可以被用来处理异常、执行清理工作或做一些代码块执行完毕之后的日常工作。如果代码块执行成功，exception_type，exception_value，和traceback 将会为 None 。否则，你可以选择处理这个异常或者是直接交给用户处理。如果你想处理这个异常的话，请确保__exit__ 在所有语句结束之后返回 True。如果你想让异常被会话管理器处理的话，那么就让其产生该异常。

<br/>

\_\_copy\_\_、\_\_deepcopy\_\_

　　有时候，尤其是当你在处理可变对象时，你可能想要复制一个对象，然后对其做出一些改变而不希望影响原来的对象。这就是Python的copy所发挥作用的地方。

__copy__(self):

　　定义了当对你的类的实例调用 copy.copy() 时所产生的行为。copy.copy() 返回了你的对象的一个浅拷贝——这意味着，当实例本身是一个新实例时，它的所有数据都被引用了——例如，当一个对象本身被复制了，它的数据仍然是被引用的（因此，对于浅拷贝中数据的更改仍然可能导致数据在原始对象的中的改变）。

__deepcopy__(self, memodict={}):

　　定义了当对你的类的实例调用 copy.deepcopy()时所产生的行为。copy.deepcopy() 返回了你的对象的一个深拷贝——对象和其数据都被拷贝了。memodict 是对之前被拷贝的对象的一个缓存——这优化了拷贝过程并且阻止了对递归数据结构拷贝时的无限递归。当你想要进行对一个单独的属性进行深拷贝时，调用copy.deepcopy()，并以 memodict 为第一个参数。

<br/>

　　这些魔术方法的用例看起来很小，并且确实非常实用. 它们反应了关于面向对象程序上一些重要的东西在Python 上，并且总的来说 Python 总是一个简单的方法去找某些事情，即使是没有必要的。这些魔法方法可能看起来不是很有用，但是一旦你需要它们，你会感到庆幸它们的存在。

<br/>

其他魔法方法

由于魔法属性、方法太多了在这就不一一描述和展示了，其他的就以表格形式呈现吧。

用于比较的魔术方法

<br/>

数值计算的魔术方法

单目运算符和函数

<br/>

双目运算符或函数

<br/>

增量运算

<br/>

类型转换

<br/>

源代码

源代码已上传到 Gitee PythonKnowledge: Python知识宝库，欢迎大家来访。

✍ 码字不易，还望各位大侠多多支持❤️。

<br/>

公众号

新建文件夹X

大自然用数百亿年创造出我们现实世界，而程序员用几百年创造出一个完全不同的虚拟世界。我们用键盘敲出一砖一瓦，用大脑构建一切。人们把1000视为权威，我们反其道行之，捍卫1024的地位。我们不是键盘侠，我们只是平凡世界中不凡的缔造者 。