Python面向对象编程第01篇 OOP简介

Posted 2022-03-26 不剪发的Tony老师

本文是 Python 面向对象编程（object-oriented programming、OOP）的第一篇，简单介绍一下基本的概念，包括对象、类、属性、方法、继承以及方法的覆盖等。

在 Python 中，一切皆对象。对象拥有状态（属性）和行为（方法）。创建对象之前需要定义一个类（class），然后可以基于该类创建一个或多个对象，对象是类的实例。

定义类

如果需要定义一个类，可以使用关键字 class 加上类的名称。例如，以下代码定义了一个 Person 类：

class Person:
    pass

如果想要创建一个 Person 类的对象，可以使用类名加上括号，就像调用函数一样：

person = Person()

以上示例中，person 是 Person 类的一个实例。
In this example, the person is an instance of the Person class. 显然，类属于可调用的对象。

定义实例属性

Python 是一种动态编程语言，意味着我们可以在运行时动态为类的实例增加属性。

例如，以下示例为 person 对象增加了一个 name 属性：

person.name = 'John'

不过，如果我们再创建一个 Person 对象，新的对象不会拥有 name 属性。

如果想要为类的所有实例定义和初始化属性，可以使用 __init__ 方法。以下示例定义的 Person 类包含两个属性（name 和 age）：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

当我们创建一个 Person 对象时，Python 自动调用 __init__ 方法为实例初始化属性。在 __init__ 方法中，self 代表了当前实例。

以下示例创建了一个名为 person 的 Person 类对象：

person = Person('John', 25)

person 对象拥有 name 和 age 属性。访问实例属性时使用点号（.）表记法，例如以下代码返回了 person 对象的 name 属性：

person.name

定义实例方法

以下代码为 Person 类增加了一个实例方法 greet()：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"Hi, it's self.name."

调用实例方法同样使用点号（.）表记法，例如：

person = Person('John', 25)
print(person.greet())

输出结果如下：

Hi, it's John

定义类属性

类属性与实例属性不同，它们被类的所有实例共享。类属性通常用于定义常量，或者用于记录类的实例数量。

例如，以下代码在 Person 类中定义了一个类属性 counter：

class Person:
    counter = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"Hi, it's self.name."

我们可以通过 Person 类访问 counter 属性：

Person.counter

或者也可以通过任何 Person 类的实例访问该属性：

person = Person('John',25)
person.counter

为了让 counter 变量更实用，我们可以在创建对象时将其加 1：

class Person:
    counter = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Person.counter += 1

    def greet(self):
        return f"Hi, it's self.name."

以下代码创建了两个 Person 类的实例，然后显示 counter 变量的值：

p1 = Person('John', 25)
p2 = Person('Jane', 22)
print(Person.counter)

输出结果如下：

2

定义类方法

类方法和类属性一样被所有实例共享。类方法的第一个参数是类自身，按照惯例，该参数的名称为 cls。Python 自动将该参数传递给类方法。另外，我们可以使用类装饰器 @classmethod 装饰一个类方法。

以下示例定义了一个返回匿名 Person 对象的类方法：

class Person:
    counter = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Person.counter += 1

    def greet(self):
        return f"Hi, it's self.name."

    @classmethod
    def create_anonymous(cls):
        return Person('Anonymous', 22)

下面的代码演示了如何调用类方法 create_anonymous()：

anonymous = Person.create_anonymous()
print(anonymous.name)  # Anonymous

定义静态方法

静态方法不会和类或者任何实例绑定，Python 中的静态方法用于将逻辑相关的功能进行分组。创建静态方法需要使用 @staticmethod 装饰器。

例如，以下示例定义了一个类 TemperatureConverter，包含了两个静态方法，用于华氏温度和摄氏温度的相互转换：

class TemperatureConverter:
    @staticmethod
    def celsius_to_fahrenheit(c):
        return 9 * c / 5 + 32

    @staticmethod
    def fahrenheit_to_celsius(f):
        return 5 * (f - 32) / 9

调用静态方法直接使用 ClassName.static_method_name() ，例如：

f = TemperatureConverter.celsius_to_fahrenheit(30)
print(f)  # 86

Python 不会默认将实例（self）或者类（cls）作为静态方法的第一个参数。

单重继承

一个类可以通过继承重用另一个类。当一个子类继承父类时，子类可以访问父类的属性和方法。

例如，我们定义一个类 Employee，它继承了类 Person：

class Employee(Person):
    def __init__(self, name, age, job_title):
        super().__init__(name, age)
        self.job_title = job_title

在 Employee 类的 __init__ 方法中调用了 Person 类的 __init__方法初始化 name 和 age 属性。super() 可以用于从子类中访问父类的方法。

Employee 类 Person 类进行可扩展，增加了一个属性 job_title。

Person 是父类，Employee 是子类。如果想要覆盖 Person 类中的 greet() 方法，可以在 Employee 类中重新定义该方法：

class Employee(Person):
    def __init__(self, name, age, job_title):
        super().__init__(name, age)
        self.job_title = job_title

    def greet(self):
        return super().greet() + f" I'm a self.job_title."

Employee 类中的 greet() 方法调用了 Person 类中的 greet() 方法。

以下示例创建了一个 Employee 类的实例并调用了 greet() 方法：

employee = Employee('John', 25, 'Python Developer')
print(employee.greet())

输出结果如下：

Hi, it's John. I'm a Python Developer.

总结

本篇我们简要描述了 Python 面向对象编程的基本概念，包括对象、类、属性、方法、继承以及方法的覆盖等。