现如今面向对象编程的使用非常广泛，本文我们就来探讨一下Python中的面向对象编程。

作者 | Radek Fabisiak

译者 | 弯月，责编 | 郭芮

出品 | CSDN（ID：CSDNnews）

以下为译文：

Python支持多种类型的编程范式，例如过程式编程、函数式编程、面向对象编程，而且还可以融合多种类型的范式。

现如今面向对象编程的使用非常广泛。面向对象编程的基本元素是对象，其包含的数据成员称为属性，函数（例程、过程）称为方法。

对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。

本文我们来探讨一下Python中的面向对象编程。我们将演示如何创建类，并使用类来实例化对象。本文的主要内容如下：

本文无法涵盖这些主题的所有详细信息。Python中的面向对象编程还包含其他很多方面。希望本文能够为你学习Python及实现面向对象提供一个良好的开端。

创建Python类

我们可以使用关键字class定义Python类，关键字后面紧跟类的名称、分号和类的实现：

>>> class MyClass:
...     pass
...

现在让我们创建这个新类的一个实例，名为MyClass：

>>> a = MyClass()
>>> a
<__main__.MyClass object at 0x7f32ef3deb70>

我们可以通过Python内置的函数type()或直接通过属性.__class__来获取类型（即对象的类）。在拿到类（类型）之后，我们就可以利用属性.__ name__获取类的名字：

>>> type(a)
<class '__main__.MyClass'>
>>> a.__class__
<class '__main__.MyClass'>
>>> a.__class__.__name__
'MyClass'

>>> type(MyClass)
<class 'type'>

Python中每个实例方法的第一个参数必须对应于该实例，即该对象本身。按照惯例，这个参数名为self。后面是其他参数（如果有需要的话）。在调用方法时，我们无需明确提供与参数self相对应的参数。

通常，我们需要定义的一个最重要的方法是.__init__()。在类的实例创建后就会调用这个方法。该方法负责初始化类成员。我们定义的.__init__()如下：

>>> class MyClass:
...     def __init__(self, arg_1, arg_2, arg_3):
...         print(f'an instance of {type(self).__name__} created')
...         print(f'arg_1: {arg_1}, arg_2: {arg_2}, arg_3: {arg_3}')
...

>>> a = MyClass(2, 4, 8)
an instance of MyClass created
arg_1: 2, arg_2: 4, arg_3: 8

现在我们得到了一个类，它有一个方法.__init__()，以及这个类的一个实例。

数据属性

下面我们来修改MyClass，增加一些数据属性。

我们利用.__init__()初始化和定义了实例，我们还可以在这个方法或其他实例方法中，通过给某个数据属性赋值的方式改变属性值：

>>> class MyClass:
...     def __init__(self, arg_1, arg_2, arg_3):
...         self.x = arg_1
...         self._y = arg_2
...         self.__z = arg_3
...

我们可以利用Python的解包机制，用更紧凑的形式编写这段代码：

>>> class MyClass:
...     def __init__(self, arg_1, arg_2, arg_3):
...         self.x, self._y, self.__z = arg_1, arg_2, arg_3
...

Python对象的数据属性通常存储在名为.__ dict__的字典中，它也是对象的属性之一。但是，你也可以将数据属性存储在其他地方。我们可以直接访问__dict__，或利用Python的内置函数vars()获取.__ dict__：

>>> a = MyClass(2, 4, 8)
>>> vars(a)
{'x': 2, '_y': 4, '_MyClass__z': 8}
>>> a.__dict__
{'x': 2, '_y': 4, '_MyClass__z': 8}

我们可以把.__ dict__当成普通的Python字典使用。

获取和修改与数据属性关联的值的常规方法如下：

>>> a.x
2
>>> a._y
4
>>> a.__z
Traceback (most recent call last):File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute '__z'
>>> a.x = 16
>>> a.x
16
>>> vars(a)
{'x': 16, '_y': 4, '_MyClass__z': 8}

实例方法

下面，我们来创建两个实例方法：

●.set_z()：修改.__ z。

●.get_z()：返回.__ z的值。

请记住，每个实例方法的第一个参数（按照约定名为self）引用对象本身，但我们无需在调用方法时指定这个参数：

>>> class MyClass:
...     def __init__(self, arg_1, arg_2, arg_3):
...         self.x, self._y, self.__z = arg_1, arg_2, arg_3
...
...     def set_z(self, value):
...         self.__z = value
...
...     def get_z(self):
...         return self.__z
...
>>> b = MyClass(2, 4, 8)

>>> b.get_z()
8
>>> b.set_z(16)
>>> vars(b)
{'x': 2, '_y': 4, '_MyClass__z': 16}

属性

还有一种方法（一种更Python的方式）访问和修改数据属性是使用属性。属性封装了一系列方法：getter、setter和deleter，但其行为与普通的数据属性相同。

下面的代码实现了属性.z，其中还包含.get_z()和.set_z()的功能：

>>> class MyClass:
...     def __init__(self, arg_1, arg_2, arg_3):
...         self.x, self._y, self.__z = arg_1, arg_2, arg_3
...
...     @property
...     def z(self):
...         return self.__z
...
...     @z.setter
...     def z(self, value):
...         self.__z = value
...
>>> b = MyClass(2, 4, 8)

>>> b.z
8
>>> b.z = 16
>>> vars(b)
{'x': 2, '_y': 4, '_MyClass__z': 16}

类与静态方法

除了实例方法和属性之外，类还可以拥有类方法和静态方法。

下面让我们为MyClass添加三个方法：

>>> class MyClass:
...     def __init__(self, arg_1, arg_2, arg_3):
...         self.x, self._y, self.__z = arg_1, arg_2, arg_3
...
...     def f(self, arg):
...         print('instance method f called')
...         print(f'instance: {self}')
...         print(f'instance attributes:\n{vars(self)}')
...         print(f'class: {type(self)}')
...         print(f'arg: {arg}')
...
...     @classmethod
...     def g(cls, arg):
...         print('class method g called')
...         print(f'cls: {cls}')
...         print(f'arg: {arg}')
...
...     @staticmethod
...     def h(arg):
...         print('static method h called')
...         print(f'arg: {arg}')
...
>>> c = MyClass(2, 4, 8)

方法.g()的开头包含修饰器@classmethod，表明这是一个类方法。每个类方法的第一个参数都会指向类本身，按照约定该参数名为cls。与实例方法的情况一样，我们不需要明确提供与cls对应的参数。而类方法可以利用cls和自己的参数访问类本身。

方法.h()的开头包含修饰器@staticmethod，表明这是一个静态方法。静态方法只能访问自己的参数。

Python中常见的调用实例方法的方法如下：

>>> c.f('my-argument')
instance method f called
instance: <__main__.MyClass object at 0x7f32ef3def98>
instance attributes:
{'x': 2, '_y': 4, '_MyClass__z': 8}
class: <class '__main__.MyClass'>
arg: my-argument

>>> MyClass.g('my-argument')
class method g called
cls: <class '__main__.MyClass'>
arg: my-argument
>>> MyClass.h('my-argument')
static method h called
arg: my-argument

但是，我们可以像下面这样调用类方法和静态方法：

>>> c.g('my-argument')
class method g called
cls: <class '__main__.MyClass'>
arg: my-argument
>>> c.h('my-argument')
static method h called
arg: my-argument

继承

继承是面向对象编程的另一个重要特性。在这个概念中，类（称为子类或派生类）会继承其他类（称为超类或基类）的数据和函数成员。

在Python中，所有类都会默认继承Python自带的类对象。但是，我们可以根据需要定义合适的类继承层次结构。

例如，我们可以创建一个名为MyOtherClass的新类，该类继承了MyClass：

>>> class MyOtherClass(MyClass):
...     def __init__(self, u, v, w, x, y, z):
...         super().__init__(x, y, z)
...         self.__u, self.__v, self.__w = u, v, w
...
...     def f_(self, arg):
...         print('instance method f_ called')
...         print(f'instance: {self}')
...         print(f'instance attributes:\n{vars(self)}')
...         print(f'class: {type(self)}')
...         print(f'arg: {arg}')
...
>>> d = MyOtherClass(1, 2, 4, 8, 16, 32)

除此之外，MyOtherClass还有自己的成员：.__u、.__v、.__w和.f_()。

下面，我们通过vars()获取数据成员：

>>> vars(d)
{'x': 8,'_y': 16,'_MyClass__z': 32,'_MyOtherClass__u': 1,'_MyOtherClass__v': 2,'_MyOtherClass__w': 4}

>>> d.f('some-argument')
instance method f called
instance: <__main__.MyOtherClass object at 0x7f32ef3e7048>
instance attributes:
{'x': 8,'_y': 16,'_MyClass__z': 32,'_MyOtherClass__u': 1,'_MyOtherClass__v': 2,'_MyOtherClass__w': 4}
class: <class '__main__.MyOtherClass'>
arg: some-argument
>>> d.f_('some-argument')
instance method f_ called
instance: <__main__.MyOtherClass object at 0x7f32ef3e7048>
instance attributes:
{'x': 8,'_y': 16,'_MyClass__z': 32,'_MyOtherClass__u': 1,'_MyOtherClass__v': 2,'_MyOtherClass__w': 4}
class: <class '__main__.MyOtherClass'>
arg: some-argument

总结

面向对象编程是Python支持的编程范式之一。面向对象蕴含的抽象以及表征的现实世界行为在某些时候会非常有帮助性。然而，有时也可能会违反直觉，并为开发过程带来不必要的麻烦。

在本文中，我们介绍了如何利用Python编写基本的面向对象程序。Python中还有很多类和面向对象的功能，例如：

等等……

现如今面向对象是非常流行的编程方式。如果你立志做一名Python开发人员，那么就应该学习面向对象编程。但请不要忘记，Python还支持其他编程范式，例如过程式编程、函数式编程等，在某些情况下也许选用这些范例更为合适。

尽情享受编程的快乐！

原文：https://www.blog.duomly.com/object-oriented-programming-in-python/

本文为 CSDN 翻译，转载请注明来源出处。

阿里云边缘计算三年，都为开发者带来了什么？

☞

点击阅读原文，即刻阅读《程序员大本营》最新期刊。