Detaillierte Erklärung von Klassen, Vererbung und Polymorphismus in Python

Dieser Artikel erklärt die Definition und Verwendung von Python-Klassen, Vererbung und Polymorphismus im Detail anhand von Beispielen. Freunde in Not können sich auf die

Definition von Klassen beziehen 🎜>

Wenn Sie eine Klasse Point definieren möchten, um einen zweidimensionalen Koordinatenpunkt darzustellen:

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

Die grundlegendste davon ist die __init__-Methode. was dem Konstruktor in C++/Java entspricht. Methoden mit doppeltem Unterstrich __ sind spezielle Methoden. Neben __init__ gibt es noch viele weitere, die später vorgestellt werden.

Der Parameter self entspricht diesem in C++ und gibt die aktuelle Instanz an. Alle Methoden verfügen über diesen Parameter, er muss jedoch beim Aufruf nicht angegeben werden.

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

Fast alle speziellen Methoden (einschließlich __init__) werden implizit aufgerufen (nicht direkt aufgerufen).

Für Python, wo alles ein Objekt ist, ist die Klasse selbst natürlich auch ein Objekt:

>>> 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 ist eine Instanz des Typs , was dasselbe ist wie p. Es ist eine Sache, eine Instanz von Point zu sein.

Jetzt Methodensatz hinzufügen:

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(... ) ist eigentlich nur ein syntaktischer Zucker. Sie können ihn auch als Point.set(p, ...) schreiben, sodass Sie deutlich sehen können, dass p der Selbstparameter ist:

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

Es ist erwähnenswert, dass self kein Schlüsselwort ist und sogar durch andere Namen ersetzt werden kann, wie zum Beispiel diesen:

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

Anders In C++ muss „Membervariable“ das Präfix „self“ voranstellen, andernfalls wird sie zu einem Attribut der Klasse (entspricht einem statischen C++-Member) und nicht zu einem Attribut des Objekts.

Zugriffskontrolle

Python verfügt nicht über eine Zugriffskontrolle wie öffentlich / geschützt / privat. Wenn Sie „privat“ ausdrücken müssen, ist es üblich, ein Doppeltes hinzuzufügen Unterstrich-Präfix.

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 und __f entsprechen privat:

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

_repr_

Versuchen Sie, die Punktinstanz zu drucken:

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

Normalerweise ist dies nicht die Ausgabe, die wir wollen, wir wollen, was Sie brauchen ist:

>>> p
Point(10, 10)

Fügen Sie die spezielle Methode __repr__ hinzu, um Folgendes zu erreichen:

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

Es ist Es ist nicht schwer zu erkennen, dass der interaktive Modus beim Drucken von p tatsächlich repr(p) aufruft:

>>>

'Point(10, 10)'

_str_

Wenn __str__ nicht bereitgestellt wird, verwendet str() standardmäßig das Ergebnis von repr().

Bei beiden handelt es sich um Zeichenfolgendarstellungen von Objekten, es gibt jedoch dennoch einige Unterschiede. Vereinfacht ausgedrückt sind die Ergebnisse von repr() für den Interpreter bestimmt und normalerweise legaler Python-Code, wie zum Beispiel Point(10, 10); während die Ergebnisse von str() für den Benutzer bestimmt sind und prägnanter sind, wie zum Beispiel ( 10, 10).

Nach diesem Prinzip stellen wir die Definition von __str__ für Point wie folgt bereit:

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

_add_

Das Hinzufügen von zwei Koordinatenpunkten ist eine sehr vernünftige Anforderung.

>>> 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;

Fügen Sie die spezielle Methode __add__ hinzu, um Folgendes zu tun:

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

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

Dies ist genau wie eine Operatorüberladung in C++.

Pythons integrierte Typen wie Strings und Listen „überlasten“ alle den +-Operator.

Es gibt viele spezielle Methoden, daher werde ich sie hier nicht einzeln vorstellen.

Vererbung

Nennen Sie eines der häufigsten Beispiele in Lehrbüchern. Kreis und Rechteck erben von Form. Verschiedene Formen haben unterschiedliche Berechnungsmethoden für die Fläche.

# 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

Die Verwendung ist relativ einfach:

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

Wenn Circle seine eigenen nicht definiert Bereich:

class Circle(Shape):
  pass

Dann erbt es den Bereich der übergeordneten Klasse Form:

>>> Shape.area is Circle.area
True

Sobald der Kreis Ihren eigenen Bereich definiert, wird der von Shape geerbte Bereich überschrieben:

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

Dies wird durch das Klassenwörterbuch deutlicher. Sehen Sie sich das an klar:

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

Wenn also eine Unterklasse die Methode der übergeordneten Klasse überschreibt, bindet sie tatsächlich nur denselben Eigenschaftsnamen an ein anderes Funktionsobjekt. Es ist ersichtlich, dass Python nicht über das Konzept der Überschreibung verfügt.

Ebenso ist es in Ordnung, auch wenn Shape den Bereich nicht als „Schnittstelle“ definiert, kann dies nicht durch die Grammatik garantiert werden.

Sie können Methoden sogar dynamisch hinzufügen:

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

Dynamische Sprachen sind im Allgemeinen sehr flexibel, und Python ist keine Ausnahme.

Der erste Satz des offiziellen Python-Tutorials „9. Klassen“ lautet:

Im Vergleich zu anderen Programmiersprachen fügt der Klassenmechanismus von Python Klassen mit einem Minimum an neuer Syntax und Semantik hinzu.

Python implementiert den Klassenmechanismus mit minimaler neuer Syntax und Semantik, was zwar erstaunlich ist, aber auch C++/Java-Programmierern ein ziemliches Unbehagen bereitet.

Polymorphismus

Wie bereits erwähnt, verfügt Python nicht über das Konzept der Überschreibung. Streng genommen unterstützt Python keinen „Polymorphismus“.

为了解决继承结构中接口和实现的问题，或者说为了更好的用 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的环境配置解析

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung von Klassen, Vererbung und Polymorphismus in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!