Python의 클래스, 상속 및 다형성에 대한 자세한 예

이 기사에서는 Python 클래스의 정의와 사용법, 상속 및 다형성을 예제를 통해 자세히 설명합니다. 도움이 필요한 친구들은

클래스 정의

를 참조하세요. 2차원 좌표점을 의미합니다:

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

가장 기본적인 것은 init 메소드로 C++/Java의 constructor와 동일합니다. 이중 밑줄이 있는 메소드는 init 외에도 나중에 소개될 더 많은 메소드가 있습니다.

매개변수 self는 C++에서 이 매개변수와 동일하며, 모든 메소드에 이 매개변수가 있지만 호출 시 지정할 필요가 없습니다.

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

거의 모든 특수 메서드(init 포함)는 암시적으로(직접 호출되지 않음) 호출됩니다.

모든 것이 객체인 Python의 경우 클래스 자체도 물론 객체입니다.

>>> 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는 유형의 인스턴스이며 p가 Point의 인스턴스인 것과 같습니다.

이제 메소드 set을 추가하세요.

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(...)는 실제로 구문상의 설탕일 뿐입니다. Point.set(p, ...)로 작성할 수도 있으므로 이를 명확하게 볼 수 있습니다. p는 self 매개변수입니다. :

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

self는 키워드가 아니며 다음과 같이 다른 이름으로 대체될 수도 있다는 점은 주목할 가치가 있습니다.

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

C++와의 차이점은 "멤버 변수" 앞에 self., 그렇지 않으면 개체 속성이 아닌 클래스 속성(C++ 정적 멤버와 동일)이 됩니다.

액세스 제어

Python에는 공개/보호/비공개 액세스 제어가 없습니다. "비공개"를 표현해야 하는 경우 이중 밑줄 접두사를 추가하는 것이 일반적입니다.

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 및 f는 private과 동일합니다.

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

_repr_

Point 인스턴스를 인쇄해 보세요.

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

일반적으로 이것은 우리가 원하는 출력이 아니며 원하는 것은 다음과 같습니다.

>>> p
Point(10, 10)

이것은 다음과 같습니다. 특별한 메소드인 repr을 추가하면 달성됩니다:

class Point:
  def repr(self):
    return 'Point({}, {})'.format(self.x, self.y)

p를 인쇄할 때 대화형 모드가 실제로 repr(p)를 호출하는 것을 보는 것은 어렵지 않습니다:

>>> repr(p)
'Point(10, 10 ) '

_str_

str이 제공되지 않으면 str()은 기본적으로 repr()의 결과를 사용합니다.
둘 다 string 형식의 객체를 표현한 것이지만 여전히 약간의 차이점이 있습니다. 간단히 말해서, repr()의 결과는 인터프리터를 위한 것이며 일반적으로 Point(10, 10)과 같은 합법적인 Python 코드인 반면, str()의 결과는 사용자를 위한 것이며 다음과 같이 더 간결합니다. 10, 10).

이 원칙에 따라 Point에 대한 str의 정의를 다음과 같이 제공합니다.

class Point:
  def str(self):
    return '({}, {})'.format(self.x, self.y)

_add_

두 개의 좌표 점을 추가하는 것은 매우 합리적인 요구 사항입니다.

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

특별 메소드 add to do를 추가하세요:

class Point:
  def add(self, other):
    return Point(self.x + other.x, self.y + other.y)

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

이것은 C++의 operator오버로딩과 같습니다.
문자열 및 목록과 같은 Python의 내장 유형은 모두 + 연산자를 "오버로드"합니다.

특별한 방법이 많아서 여기서는 하나씩 소개하지 않겠습니다.

상속

교과서에 나오는 가장 일반적인 예 중 하나를 들어보세요. Circle 및 Rectangle은 Shape에서 상속됩니다. 모양마다 면적 계산 방법이 다릅니다.

# 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

사용법은 비교적 간단합니다:

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

Circle이 자체 영역을 정의하지 않는 경우:

class Circle(Shape):
  pass

그러면 상위 클래스 Shape의 영역을 상속받습니다.

>>> Shape.area is Circle.area
True

Circle이 자체 영역을 정의하면 해당 영역이 상속됩니다. from Shape 덮어쓰기되었습니다:

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

이는 클래스 사전을 통해 더 명확하게 볼 수 있습니다:

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

따라서 하위 클래스가 상위 클래스의 메서드를 재정의하면 실제로는 동일한 속성 이름을 다른 함수 개체에 바인딩합니다. Python에는 재정의 개념이 없음을 알 수 있습니다.

마찬가지로 Shape는 "인터페이스"로서 영역을 정의하지 않아도 괜찮습니다.

메서드를 동적으로 추가할 수도 있습니다.

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

동적 언어는 일반적으로 매우 유연하며 Python도 예외는 아닙니다.

공식 Python 튜토리얼 "9. 클래스"의 첫 번째 문장은 다음과 같습니다.

다른 프로그래밍 언어와 비교하여 Python의 클래스 메커니즘은 최소한의 새로운 구문과 의미로 클래스를 추가합니다.

Python은 최소한의 새로운 구문으로 구현됩니다. 클래스 메커니즘은 정말 놀랍지만 C++/Java 프로그래머에게는 상당히 불편함을 줍니다.

다형성

앞서 언급했듯이 Python에는 재정의 개념이 없습니다. 엄밀히 말하면 Python은 "다형성"을 지원하지 않습니다.

상속 구조의 인터페이스 및 구현 문제를 해결하거나 인터페이스 지향 프로그래밍에 Python을 더 잘 사용하려면(Design Pattern에서 옹호) 몇 가지 인위적인 표준을 설정해야 합니다.

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의 클래스, 상속 및 다형성에 대한 자세한 예의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!