Explication détaillée des classes, de l'héritage et du polymorphisme en Python

Cet article explique en détail la définition et l'utilisation des classes Python, l'héritage et le polymorphisme à travers des exemples. Les amis dans le besoin peuvent se référer à la

Définition des classes <.>

Si vous souhaitez définir une classe Point pour représenter un point de coordonnées bidimensionnel :

# point.py
class Point:
  def __init__(self, x=0, y=0):
    self.x, self.y = x, y

Le plus basique est le __init__ méthode, équivalente au constructeur C++/Java. Les méthodes avec double trait de soulignement __ sont des méthodes spéciales en plus de __init__, il en existe bien d'autres, qui seront présentées plus tard.

Le paramètre self est équivalent à ceci en C++, indiquant l'instance actuelle. Toutes les méthodes ont ce paramètre, mais il n'a pas besoin d'être spécifié lors de l'appel.

>>> from point import *
>>> p = Point(10, 10) # __init__ 被调用
>>> type(p)
<class &#39;point.Point&#39;>
>>> p.x, p.y
(10, 10)

Presque toutes les méthodes spéciales (y compris __init__) sont appelées implicitement (pas appelées directement).

Pour Python, où tout est objet, la classe elle-même est bien sûr aussi un objet :

>>> type(Point)
<class &#39;type&#39;>
>>> dir(Point)
[&#39;__class__&#39;, &#39;__delattr__&#39;, &#39;__dict__&#39;, ..., &#39;__init__&#39;, ...]
>>> Point.__class__
<class &#39;type&#39;>

Point est une instance de type, ce qui revient à p étant une instance de Point.

Ajoutez maintenant un ensemble de méthodes :

class Point:
  ...
  def set(self, x, y):
    self.x, self.y = x, y

>>> p = Point(10, 10)
>>> p.set(0, 0)
>>> p.x, p.y
(0, 0)

p.set (...) n'est en fait qu'un sucre syntaxique. Vous pouvez également l'écrire sous la forme Point.set(p, ...), afin que vous puissiez voir clairement que p est le paramètre self :

<🎜. >

>>> Point.set(p, 0, 0)
>>> p.x, p.y
(0, 0)

Il est à noter que self n'est pas un mot-clé et peut même être remplacé par d'autres noms, comme celui-ci :

class Point:
  ...
  def set(this, x, y):
    this.x, this.y = x, y

À la différence du C++, les "variables membres" doivent être préfixées par self., sinon elles deviennent des attributs de la classe (équivalents aux membres statiques C++) plutôt que des attributs de l'objet.

Contrôle d'accès

Python n'a pas de contrôle d'accès de type public / protégé / privé Si vous devez exprimer "privé", il est d'usage d'ajouter un double. préfixe de soulignement.

class Point:
  def __init__(self, x=0, y=0):
    self.__x, self.__y = x, y

  def set(self, x, y):
    self.__x, self.__y = x, y

  def __f(self):
    pass

__x, __y et __f sont équivalents à privé :

>>> p = Point(10, 10)
>>> p.__x
...
AttributeError: 'Point' object has no attribute '__x'
>>> p.__f()
...
AttributeError: 'Point' object has no attribute '__f'

_repr_

Essayez d'imprimer l'instance Point :

>>> p = Point(10, 10)
>>> p
<point.Point object at 0x000000000272AA20>

Habituellement, ce n'est pas ce que nous voulons Le résultat que nous souhaitons est :

>>> p
Point(10, 10)

Ajoutez la méthode spéciale __repr__ pour obtenir :

class Point:
  def __repr__(self):
    return 'Point({}, {})'.format(self.__x, self.__y)

Il n'est pas difficile de voir que le mode interactif appelle réellement repr(p) lors de l'impression de p :

>>> 10)'

_str_

Si __str__ n'est pas fourni, str() est par défaut le résultat de repr(). Les deux sont des représentations sous forme de chaîne d'objets, mais il existe encore quelques différences. Pour faire simple, les résultats de repr() sont destinés à l'interpréteur et sont généralement du code Python légal, tel que Point(10, 10); tandis que les résultats de str() sont destinés à l'utilisateur et sont plus concis, tels que ( 10, 10).

Selon ce principe, nous fournissons la définition de __str__ pour Point comme suit :

class Point:
  def __str__(self):
    return '({}, {})'.format(self.__x, self.__y)

_add_

L'ajout de deux points de coordonnées est une exigence très raisonnable.

>>> p1 = Point(10, 10)
>>> p2 = Point(10, 10)
>>> p3 = p1 + p2
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: &#39;Point&#39; and &#39;Point&#39;

Ajoutez la méthode spéciale __add__ pour faire :

class Point:
  def __add__(self, other):
    return Point(self.__x + other.__x, self.__y + other.__y)

>>> p3 = p1 + p2
>>> p3
Point(20, 20)

C'est comme la surcharge d'opérateurs en C++.

Les types intégrés de Python, tels que les chaînes et les listes, « surchargent » tous l’opérateur +.

Il existe de nombreuses méthodes spéciales, je ne les présenterai donc pas une par une ici.

Héritage

Donnez l'un des exemples les plus courants dans les manuels scolaires. Le cercle et le rectangle héritent de la forme. Différentes formes ont des méthodes de calcul de surface différentes.

# shape.py

class Shape:
  def area(self):
    return 0.0
    
class Circle(Shape):
  def __init__(self, r=0.0):
    self.r = r

  def area(self):
    return math.pi * self.r * self.r

class Rectangle(Shape):
  def __init__(self, a, b):
    self.a, self.b = a, b

  def area(self):
    return self.a * self.b

L'utilisation est relativement simple :

>>> from shape import *
>>> circle = Circle(3.0)
>>> circle.area()
28.274333882308138
>>> rectangle = Rectangle(2.0, 3.0)
>>> rectangle.area()
6.0

Si Circle est non défini Sa propre zone :

class Circle(Shape):
  pass

Ensuite, il héritera de la zone de la classe parent Shape :

>>> Shape.area is Circle.area
True

Une fois qu'un Cercle définit sa propre zone, la zone héritée de Shape est écrasée :

>>> from shape import *
>>> Shape.area is Circle.area
False

Ce peut être vu plus clairement à travers le dictionnaire de classe :

>>> Shape.__dict__['area']
<function Shape.area at 0x0000000001FDB9D8>
>>> Circle.__dict__[&#39;area&#39;]
<function Circle.area at 0x0000000001FDBB70>

Ainsi, lorsqu'une sous-classe remplace la méthode de la classe parent, elle change en fait la même chose le nom de la propriété est lié à différents objets de fonction. On voit que Python n'a pas le concept de remplacement.

De même, ce n'est pas grave même si Shape ne définit pas de zone. Shape, en tant qu'"interface", ne peut pas être garantie par la grammaire.

Vous pouvez même ajouter des méthodes de manière dynamique :

class Circle(Shape):
  ...
  # def area(self):
    # return math.pi * self.r * self.r

# 为 Circle 添加 area 方法。
Circle.area = lambda self: math.pi * self.r * self.r

Les langages dynamiques sont généralement très flexibles, et Python ne fait pas exception.

La première phrase du tutoriel officiel Python "9. Classes" est :

Comparé à d'autres langages de programmation, le mécanisme de classe de Python ajoute des classes avec un minimum de nouvelles syntaxes et sémantiques.

Python implémente le mécanisme de classe avec un minimum de nouvelles syntaxes et sémantiques, ce qui est effectivement étonnant, mais met également les programmeurs C++/Java assez mal à l'aise.

Polymorphisme

Comme mentionné précédemment, Python n'a pas de concept de remplacement. À proprement parler, Python ne prend pas en charge le « polymorphisme ».

为了解决继承结构中接口和实现的问题，或者说为了更好的用 Python 面向接口编程（设计模式所提倡的），我们需要人为的设一些规范。

请考虑 Shape.area() 除了简单的返回 0.0，有没有更好的实现？

以内建模块 asyncio 为例，AbstractEventLoop 原则上是一个接口，类似于 Java 中的接口或 C++ 中的纯虚类，但是 Python 并没有语法去保证这一点，为了尽量体现 AbstractEventLoop 是一个接口，首先在名字上标志它是抽象的（Abstract），然后让每个方法都抛出异常 NotImplementedError。

class AbstractEventLoop:
  def run_forever(self):
    raise NotImplementedError
  ...

纵然如此，你是无法禁止用户实例化 AbstractEventLoop 的：

loop = asyncio.AbstractEventLoop()
try:
  loop.run_forever()
except NotImplementedError:
  pass

C++ 可以通过纯虚函数或设构造函数为 protected 来避免接口被实例化，Java 就更不用说了，接口就是接口，有完整的语法支持。

你也无法强制子类必须实现“接口”中定义的每一个方法，C++ 的纯虚函数可以强制这一点（Java 更不必说）。

就算子类「自以为」实现了“接口”中的方法，也不能保证方法的名字没有写错，C++ 的 override 关键字可以保证这一点（Java 更不必说）。

静态类型的缺失，让 Python 很难实现 C++ / Java 那样严格的多态检查机制。所以面向接口的编程，对 Python 来说，更多的要依靠程序员的素养。

回到 Shape 的例子，仿照 asyncio，我们把“接口”改成这样：

class AbstractShape:
  def area(self):
    raise NotImplementedError

这样，它才更像一个接口。

super

有时候，需要在子类中调用父类的方法。

比如图形都有颜色这个属性，所以不妨加一个参数 color 到 __init__：

class AbstractShape:
  def __init__(self, color):
    self.color = color

那么子类的 __init__() 势必也要跟着改动：

class Circle(AbstractShape):
  def __init__(self, color, r=0.0):
    super().__init__(color)
    self.r = r

通过 super 把 color 传给父类的 __init__()。其实不用 super 也行：

class Circle(AbstractShape):
  def __init__(self, color, r=0.0):
    AbstractShape.__init__(self, color)
    self.r = r

但是 super 是推荐的做法，因为它避免了硬编码，也能处理多继承的情况。

相关推荐：

Python的环境配置解析

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!