Explication détaillée des méthodes magiques en Python-Tutoriel Python-php.cn

Introduction

En Python, toutes les méthodes entourées de doubles traits de soulignement "__" sont collectivement appelées "Méthode magique", qui est appelée "Méthode magique" en chinois, comme la méthode d'initialisation de classe __init__, Python All Les méthodes magiques ont des descriptions correspondantes dans les documents officiels, mais les descriptions officielles sont confuses et mal organisées. Il est difficile de trouver un exemple.

Construction et initialisation

Chaque Pythoner connaît la méthode magique la plus basique, __init__ . Grâce à cette méthode, nous pouvons définir le fonctionnement initial d'un objet. Cependant, lorsque x = SomeClass() est appelé, __init__ n'est pas la première méthode appelée. En fait, il existe également une méthode appelée __new__, et les deux forment ensemble le « constructeur ».

__new__ est utilisé pour créer une classe et renvoyer une instance de cette classe, tandis que __init__ initialise simplement l'instance avec les paramètres passés.

À la fin de l'appel du cycle de vie de l'objet, la méthode __del__ sera appelée, et __del__ peut être comprise comme le "destructeur". Jetons un coup d'œil à ces trois méthodes via le code :

from os.path import join
class FileObject:
    &#39;&#39;&#39;给文件对象进行包装从而确认在删除时文件流关闭&#39;&#39;&#39;
    def __init__(self, filepath=&#39;~&#39;, filename=&#39;sample.txt&#39;):
        #读写模式打开一个文件
        self.file = open(join(filepath, filename), &#39;r+&#39;)
    def __del__(self):
        self.file.close()
        del self.file

Copier après la connexion

Contrôle de l'accès aux attributs

De nombreuses personnes qui passent à Python à partir d'autres langages se plaindront de l'absence d'une véritable encapsulation des classes. (Il n'existe aucun moyen de définir une variable privée, puis de définir des getters et setters publics). Python peut réellement réaliser l'encapsulation grâce à des méthodes magiques. Jetons un coup d'oeil :

__getattr__(self, name):

Copier après la connexion

Définit le comportement lorsque l'utilisateur tente d'obtenir une propriété qui n'existe pas. Ceci est utile pour récupérer et rediriger les fautes de frappe courantes, donner des avertissements lors de la récupération de certains attributs obsolètes (vous pouvez également calculer et donner une valeur si vous le souhaitez) ou gérer une AttributeError . Il ne sera renvoyé que lors de l'appel d'une propriété qui n'existe pas.

__setattr__(self, name, value):

Copier après la connexion

Contrairement à __getattr__(self, name), __setattr__ est une solution encapsulée. Que l'attribut existe ou non, il vous permet de définir le comportement d'affectation à l'attribut, afin que vous puissiez personnaliser la valeur de l'attribut. Évitez les erreurs de « récursion infinie » lors de l'implémentation de __setattr__.

__delattr__:

Copier après la connexion

Identique à __setattr__, mais la fonction est de supprimer un attribut au lieu de le définir. Il est également nécessaire d’éviter une récursion infinie lors de la mise en œuvre.

__getattribute__(self, name):

Copier après la connexion

__getattribute__ définit le comportement lors de l'accès à votre attribut. En comparaison, __getattr__ ne fonctionne que lorsque l'attribut n'existe pas. Par conséquent, dans les versions Python prenant en charge __getattribute__, __getattribute__ doit être appelé avant d'appeler __getattr__. __getattribute__ doit également éviter les erreurs de « récursivité infinie ». Il convient de rappeler qu'il est préférable de ne pas essayer d'implémenter __getattribute__, car cette approche est rarement vue et il est facile de provoquer des bugs.

Lors de la définition du contrôle d'accès aux attributs, cela peut facilement provoquer une "récursivité infinie". Par exemple, le code suivant :

#  错误用法
def __setattr__(self, name, value):
    self.name = value
    # 每当属性被赋值的时候(如self.name = value)， ``__setattr__()`` 会被调用，这样就造成了递归调用。
    # 这意味这会调用 ``self.__setattr__(&#39;name&#39;, value)`` ，每次方法会调用自己。这样会造成程序崩溃。
#  正确用法
def __setattr__(self, name, value):
    self.__dict__[name] = value  # 给类中的属性名分配值
    # 定制特有属性

Copier après la connexion

La méthode magique de Python est très puissante, mais elle doit être utilisée avec prudence. Il est très important de comprendre la bonne méthode d'utilisation.

Créer un conteneur personnalisé

Il existe de nombreuses façons de faire en sorte que vos classes Python se comportent comme des types de conteneurs intégrés, tels que notre liste, dict, tuple, chaîne, etc. couramment utilisés. Les types de conteneurs de Python sont divisés en types variables (tels que list, dict) et types immuables (tels que string, tuple). La différence entre les conteneurs variables et les conteneurs immuables est qu'une fois qu'une valeur est affectée à un conteneur immuable, l'un d'eux ne peut pas le faire. être modifié.

Avant de parler de création d'un conteneur personnalisé, vous devez d'abord comprendre le protocole. Le protocole ici est très similaire au concept dit "d'interface" dans d'autres langages. Il vous donne de nombreuses méthodes que vous devez définir. Cependant, les protocoles en Python sont très informels et ne nécessitent pas de déclarations d'implémentation explicites. En fait, ils ressemblent davantage à un guide.

Méthode magique du conteneur personnalisé

　Examinons de plus près les méthodes magiques qui peuvent être utilisées pour définir des conteneurs. Premièrement, lors de l'implémentation d'un conteneur immuable, vous ne pouvez définir que __len__ et __getitem__ (plus d'informations ci-dessous). Le protocole de conteneur mutable nécessite tous les conteneurs immuables, plus __setitem__ et __delitem__ . Si vous souhaitez que votre objet soit itérable, vous devez définir __iter__ qui renvoie un itérateur. Les itérateurs doivent suivre le protocole de l'itérateur, qui nécessite __iter__ (se retourne) et next.

__len__(self):

Copier après la connexion

Renvoie la longueur du conteneur. Tout cela fait partie du protocole pour les conteneurs mutables et immuables.

__getitem__(self, key):

Copier après la connexion

Définissez le comportement généré en utilisant self[key] lors de l'accès à un élément. Cela fait également partie du protocole pour les conteneurs immuables et mutables. Une TypeError sera levée si la clé est du mauvais type ; une KeyError sera levée si la clé n’a pas une valeur appropriée.

__setitem__(self, key, value):

Copier après la connexion

Lorsque vous exécutez self[key] = value, cette méthode est appelée.

__delitem__(self, key):

Copier après la connexion

Définit le comportement lorsqu'un élément est supprimé (par exemple del self[key]). Ceci n'est qu'une partie du protocole du conteneur mutable. Une exception appropriée doit être levée lorsqu'une clé non valide est utilisée.

__iter__(self):

Copier après la connexion

Renvoie un itérateur de conteneur Dans de nombreux cas, un itérateur sera renvoyé, en particulier lorsque la méthode intégrée iter() est appelée et lorsque la méthode for x in conteneur: est utilisée pour effectuer une boucle. . Les itérateurs sont eux-mêmes des objets et ils doivent définir une méthode __iter__ qui renvoie self.

__reversed__(self):

Copier après la connexion

　　实现当reversed()被调用时的行为。应该返回序列反转后的版本。仅当序列可以是有序的时候实现它，例如对于列表或者元组。

__contains__(self, item):

Copier après la connexion

　　定义了调用in和not in来测试成员是否存在的时候所产生的行为。你可能会问为什么这个不是序列协议的一部分？因为当__contains__没有被定义的时候，如果没有定义，那么Python会迭代容器中的元素来一个一个比较，从而决定返回True或者False。

__missing__(self, key):

Copier après la connexion

　　dict字典类型会有该方法，它定义了key如果在容器中找不到时触发的行为。比如d = {'a': 1}, 当你执行d[notexist]时，d.__missing__['notexist']就会被调用。

实例

　　下面是书中的例子，用魔术方法来实现Haskell语言中的一个数据结构。

# -*- coding: utf-8 -*-
class FunctionalList:
    &#39;&#39;&#39; 实现了内置类型list的功能,并丰富了一些其他方法: head, tail, init, last, drop, take&#39;&#39;&#39;
    def __init__(self, values=None):
        if values is None:
            self.values = []
        else:
            self.values = values
    def __len__(self):
        return len(self.values)
    def __getitem__(self, key):
        return self.values[key]
    def __setitem__(self, key, value):
        self.values[key] = value
    def __delitem__(self, key):
        del self.values[key]
    def __iter__(self):
        return iter(self.values)
    def __reversed__(self):
        return FunctionalList(reversed(self.values))
    def append(self, value):
        self.values.append(value)
    def head(self):
        # 获取第一个元素
        return self.values[0]
    def tail(self):
        # 获取第一个元素之后的所有元素
        return self.values[1:]
    def init(self):
        # 获取最后一个元素之前的所有元素
        return self.values[:-1]
    def last(self):
        # 获取最后一个元素
        return self.values[-1]
    def drop(self, n):
        # 获取所有元素，除了前N个
        return self.values[n:]
    def take(self, n):
        # 获取前N个元素
        return self.values[:n]

Copier après la connexion

　　其实在collections模块中已经有了很多类似的实现，比如Counter、OrderedDict等等。

反射

　　你也可以控制怎么使用内置在函数sisinstance()和issubclass()方法反射定义魔术方法. 这个魔术方法是:

__instancecheck__(self, instance):

Copier après la connexion

　　检查一个实例是不是你定义的类的实例

__subclasscheck__(self, subclass):

Copier après la connexion

　　检查一个类是不是你定义的类的子类

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

可调用的对象

　　你也许已经知道，在Python中，方法是最高级的对象。这意味着他们也可以被传递到方法中，就像其他对象一样。这是一个非常惊人的特性。

　　在Python中，一个特殊的魔术方法可以让类的实例的行为表现的像函数一样，你可以调用它们，将一个函数当做一个参数传到另外一个函数中等等。这是一个非常强大的特性，其让Python编程更加舒适甜美。

__call__(self, [args...]):

Copier après la connexion

　　允许一个类的实例像函数一样被调用。实质上说，这意味着 x() 与 x.__call__() 是相同的。注意 __call__ 的参数可变。这意味着你可以定义 __call__ 为其他你想要的函数，无论有多少个参数。

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

# -*- coding: UTF-8 -*-
class Entity:
    """
    调用实体来改变实体的位置
    """
def __init__(self, size, x, y):
    self.x, self.y = x, y
    self.size = size
def __call__(self, x, y):
    """
    改变实体的位置
    """
    self.x, self.y = x, y

Copier après la connexion

上下文管理

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

with open(&#39;foo.txt&#39;) as bar:
    # do something with bar

Copier après la connexion

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

__enter__(self):

Copier après la connexion

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

__exit__(self, exception_type, exception_value, traceback):

Copier après la connexion

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

创建对象描述器

　　描述器是通过获取、设置以及删除的时候被访问的类。当然也可以改变其它的对象。描述器并不是独立的。相反，它意味着被一个所有者类持有。当创建面向对象的数据库或者类，里面含有相互依赖的属相时，描述器将会非常有用。一种典型的使用方法是用不同的单位表示同一个数值，或者表示某个数据的附加属性。

　　为了成为一个描述器，一个类必须至少有__get__，__set__，__delete__方法被实现：

__get__(self, instance, owner):

Copier après la connexion

定义了当描述器的值被取得的时候的行为。instance是拥有该描述器对象的一个实例。owner是拥有者本身

__set__(self, instance, value):

Copier après la connexion

定义了当描述器的值被改变的时候的行为。instance是拥有该描述器类的一个实例。value是要设置的值。

__delete__(self, instance):

Copier après la connexion

定义了当描述器的值被删除的时候的行为。instance是拥有该描述器对象的一个实例。

　　下面是一个描述器的实例：单位转换。

# -*- coding: UTF-8 -*-
class Meter(object):
    """
    对于单位"米"的描述器
    """
    def __init__(self, value=0.0):
        self.value = float(value)
    def __get__(self, instance, owner):
        return self.value
    def __set__(self, instance, value):
        self.value = float(value)
class Foot(object):
    """
    对于单位"英尺"的描述器
    """
    def __get__(self, instance, owner):
        return instance.meter * 3.2808
    def __set__(self, instance, value):
        instance.meter = float(value) / 3.2808
class Distance(object):
    """
    用米和英寸来表示两个描述器之间的距离
    """
    meter = Meter(10)
    foot = Foot()
　　使用时：
>>>d = Distance()
>>>print d.foot
>>>print d.meter
32.808
10.0

Copier après la connexion

复制

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

__copy__(self):

Copier après la connexion

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

__deepcopy__(self, memodict={}):

Copier après la connexion

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