带你迅速搞定Python编程-第 9 章 类

带你迅速搞定Python编程-第 9 章　类

面向对象编程（object-oriented programming，OOP）是最有效的软件编写方法之一。在面向对象编程中，你编写表示现实世界中的事物和情景的类（class），并基于这些类来创建对象（object）。在编写类时，你要定义一批对象都具备的通用行为。在基于类创建对象时，每个对象都自动具备这种通用行为。然后，你可根据需要赋予每个对象独特的个性。使用面向对象编程可模拟现实情景，逼真程度到达了令人惊讶的地步。

根据类来创建对象称为实例化，这让你能够使用类的实例（instance）。在本章中，你将编写一些类并创建其实例。你将指定可在实例中存储什么信息，定义可对这些实例执行哪些操作。你还将编写一些类来扩展既有类的功能，让相似的类能够共享功能，从而使用更少的代码做更多的事情。你将把自己编写的类存储在模块中，并在自己的程序文件中导入其他程序员编写的类。

学习面向对象编程有助于你像程序员那样看世界，并且真正明白自己编写的代码：不仅是各行代码的作用，还有代码背后更宏大的概念。了解类背后的概念可培养逻辑思维能力，让你能够通过编写程序来解决遇到的几乎任何问题。

随着面临的挑战日益严峻，类还能减轻你以及与你合作的其他程序员的负担。如果你与其他程序员基于同样的逻辑来编写代码，你们就能明白彼此所做的工作。你编写的程序将能被合作者理解，每个人都能事半功倍。

9.1　创建和使用类

使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类 Dog——它表示的不是特定的小狗，而是任何小狗。对于大多数宠物狗，我们都知道些什么呢？它们都有名字和年龄。我们还知道，大多数小狗还会坐下和打滚。由于大多数小狗具备上述两项信息（名字和年龄）和两种行为（坐下和打滚），我们的 Dog 类将包含它们。这个类让 Python 知道如何创建表示小狗的对象。编写这个类后，我们将使用它来创建表示特定小狗的实例。

9.1.1　创建 Dog 类

根据 Dog 类创建的每个实例都将存储名字和年龄，而且我们会赋予每条小狗坐下（sit()）和打滚（roll_over()）的能力：

dog.py

❶ class Dog:
      """一次模拟小狗的简单尝试"""

❷     def __init__(self, name, age):
          """初始化属性 name 和 age"""
❸         self.name = name
          self.age = age

❹     def sit(self):
          """模拟小狗收到命令时坐下"""
          print(f"{self.name} is now sitting.")

      def roll_over(self):
          """模拟小狗收到命令时打滚"""

          print(f"{self.name} rolled over!")

虽然这里需要注意的地方很多，但也不用担心。这样的结构在本章随处可见，你有很多熟悉它的机会。首先，定义一个名为 Dog 的类（见❶）。根据约定，在 Python 中，首字母大写的名称指的是类。因为这是我们创建的全新的类，所以定义时不加括号。然后是一个文档字符串，对这个类的功能做了描述。

init() 方法

类中的函数称为方法。你在前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。init()（见❷）是一个特殊方法，每当你根据 Dog 类创建新实例时，Python 都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免 Python 默认方法与普通方法发生名称冲突。务必确保 init() 的两边都有两个下划线，否则当你使用类来创建实例时，将不会自动调用这个方法，进而引发难以发现的错误。

我们将 init() 方法定义成包含三个形参：self、name 和 age。在这个方法的定义中，形参 self 必不可少，而且必须位于其他形参的前面。为何必须在方法定义中包含形参 self 呢？因为当 Python 调用这个方法来创建 Dog 实例时，将自动传入实参 self。每个与实例相关联的方法调用都会自动传递实参 self，该实参是一个指向实例本身的引用，让实例能够访问类中的属性和方法。当我们创建 Dog 实例时，Python 将调用 Dog 类的 init() 方法。我们将通过实参向 Dog() 传递名字和年龄；self 则会自动传递，因此不需要我们来传递。每当我们根据 Dog 类创建实例时，都只需给最后两个形参（name 和 age）提供值。

在 init() 方法内定义的两个变量都有前缀 self（见❸）。以 self 为前缀的变量可供类中的所有方法使用，可以通过类的任意实例来访问。self.name = name 获取与形参 name 相关联的值，并将其赋给变量 name，然后该变量被关联到当前创建的实例。self.age = age 的作用与此类似。像这样可通过实例访问的变量称为属性（attribute）。

Dog 类还定义了另外两个方法：sit() 和 roll_over()（见❹）。由于这些方法执行时不需要额外的信息，因此只有一个形参 self。稍后将创建的实例能够访问这些方法，换句话说，它们都会坐下和打滚。当前，sit() 和 roll_over() 所做的有限，只是打印一条消息，指出小狗正在坐下或打滚。但是可以扩展这些方法以模拟实际情况：如果这个类属于一个计算机游戏，那么这些方法将包含创建小狗坐下和打滚动画效果的代码；如果这个类是用于控制机器狗的，那么这些方法将让机器狗做出坐下和打滚的动作。

9.1.2　根据类创建实例

可以将类视为有关如何创建实例的说明。例如，Dog 类就是一系列说明，让 Python 知道如何创建表示特定小狗的实例。

下面创建一个表示特定小狗的实例：

class Dog:
      --snip--

❶ my_dog = Dog('Willie', 6)

❷ print(f"My dog's name is {my_dog.name}.")
❸ print(f"My dog is {my_dog.age} years old.")

这里使用的是上一个示例中编写的 Dog 类。我们让 Python 创建一条名字为 ‘Willie’、年龄为 6 的小狗（见❶）。在处理这行代码时，Python 调用 Dog 类的 init() 方法，并传入实参 ‘Willie’ 和 6。init() 方法创建一个表示特定小狗的实例，并且使用提供的值设置属性 name 和 age。接下来，Python 返回一个表示这条小狗的实例，而我们将这个实例赋给变量 my_dog。在这里，命名约定很有用：通常可以认为首字母大写的名称（如 Dog）指的是类，而全小写的名称（如 my_dog）指的是根据类创建的实例。

访问属性

要访问实例的属性，可使用点号。在❷处，编写如下代码来访问 my_dog 的属性 name 的值：

my_dog.name

点号在 Python 中很常用，这种语法演示了 Python 如何获取属性的值。在这里，Python 先找到实例 my_dog，再查找与这个实例相关联的属性 name。在 Dog 类中引用这个属性时，使用的是 self.name。在❸处，我们用同样的方法来获取属性 age 的值。

输出是有关 my_dog 的摘要：

My dog's name is Willie.
My dog is 6 years old.

调用方法

根据 Dog 类创建实例后，就能使用点号来调用 Dog 类中定义的任何方法了。下面让小狗坐下和打滚：

class Dog:
    --snip--

my_dog = Dog('Willie', 6)
my_dog.sit()
my_dog.roll_over()

要调用方法，需指定实例名（这里是 my_dog）和想调用的方法，并用句点分隔。在遇到代码 my_dog.sit() 时，Python 在类 Dog 中查找方法 sit() 并运行其代码。Python 还会以同样的方式解读代码 my_dog.roll_over()。

现在，Willie 按我们的命令做了：

Willie is now sitting.
Willie rolled over!

这种语法很有用。如果给属性和方法指定了合适的描述性名称，如 name、age、sit() 和 roll_over()，即便对于从未见过的代码块，我们也能够轻松地推断出它是做什么的。

创建多个实例

可按需求根据类创建任意数量的实例。下面再创建一个名为 your_dog 的小狗实例：

class Dog:
    --snip--

my_dog = Dog('Willie', 6)
your_dog = Dog('Lucy', 3)

print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")
my_dog.sit()

print(f"\nYour dog's name is {your_dog.name}.")
print(f"Your dog is {your_dog.age} years old.")
your_dog.sit()

我们在这个示例中创建了两条小狗，分别名为 Willie 和 Lucy。每条小狗都是一个独立的实例，有自己的一组属性，能够执行相同的操作：

My dog's name is Willie.
My dog is 6 years old.
Willie is now sitting.

Your dog's name is Lucy.
Your dog is 3 years old.
Lucy is now sitting.

即使给第二条小狗指定同样的名字和年龄，Python 也会根据 Dog 类创建另一个实例。你可以按需求根据一个类创建任意数量的实例，只要你能给每个实例起一个独特的变量名，或者让它在列表或字典中占有一席之地就行。

动手试一试

练习 9.1：餐馆　创建一个名为 Restaurant 的类，为其 init() 方法设置两个属性：restaurant_name 和 cuisine_type。创建一个名为 describe_restaurant() 的方法和一个名为 open_restaurant() 的方法，其中前者打印前述两项信息，而后者打印一条消息，指出餐馆正在营业。

根据这个类创建一个名为 restaurant 的实例，分别打印其两个属性，再调用前述两个方法。

练习 9.2：三家餐馆　根据为练习 9.1 编写的类创建三个实例，并对每个实例调用 describe_restaurant() 方法。

练习 9.3：用户　创建一个名为 User 的类，其中包含属性 first_name 和 last_name，还有用户简介中通常会有的其他几个属性。在类 User 中定义一个名为 describe_user() 的方法，用于打印用户信息摘要。再定义一个名为 greet_user() 的方法，用于向用户发出个性化的问候。

创建多个表示不同用户的实例，并对每个实例调用上述两个方法。

9.2　使用类和实例

可以使用类来模拟现实世界中的很多情景。类编写好后，你的大部分时间将花在使用根据类创建的实例上。你需要完成的首要任务之一是，修改实例的属性。既可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。

9.2.1　Car 类

下面编写一个表示汽车的类，它存储了有关汽车的信息，并提供了一个汇总这些信息的方法：

car.py

 class Car:
      """一次模拟汽车的简单尝试"""

❶     def __init__(self, make, model, year):
          """初始化描述汽车的属性"""
          self.make = make
          self.model = model
          self.year = year

❷     def get_descriptive_name(self):
          """返回格式规范的描述性信息"""
          long_name = f"{self.year} {self.make} {self.model}"
          return long_name.title()

❸ my_new_car = Car('audi', 'a4', 2024)
  print(my_new_car.get_descriptive_name())

在❶处，定义 init() 方法。与前面的 Dog 类中一样，这个方法的第一个形参为 self。此外，这个方法还包含三个形参：make、model 和 year。init() 方法接受这些形参的值，并将它们赋给根据这个类创建的实例的属性。在创建新的 Car 实例时，需要指定其制造商、型号和生产年份。

在❷处，定义一个名为 get_descriptive_name() 的方法，它使用属性 year、make 和 model 创建一个对汽车进行描述的字符串，让我们无须分别打印每个属性的值。为了在这个方法中访问属性的值，使用了 self.make、self.model 和 self.year。

在❸处，根据 Car 类创建一个实例，并将其赋给变量 my_new_car。接下来，调用 get_descriptive_ name() 方法，指出我们拥有一辆什么样的汽车：

2024 Audi A4

为了让这个类更有趣，下面给它添加一个随时间变化的属性，用于存储汽车的行驶里程。

9.2.2　给属性指定默认值

有些属性无须通过形参来定义，可以在 init() 方法中为其指定默认值。

下面来添加一个名为 odometer_reading 的属性，其初始值总是为 0。我们还添加了一个名为 read_odometer() 的方法，用于读取汽车的里程表：

 class Car:

      def __init__(self, make, model, year):
          """初始化描述汽车的属性"""
          self.make = make
          self.model = model
          self.year = year
❶         self.odometer_reading = 0

    def get_descriptive_name(self):
          --snip--

❷     def read_odometer(self):
          """打印一条指出汽车行驶里程的消息"""
          print(f"This car has {self.odometer_reading} miles on it.")

  my_new_car = Car('audi', 'a4', 2024)
  print(my_new_car.get_descriptive_name())
  my_new_car.read_odometer()

现在，当 Python 调用 init() 方法创建新实例时，将像上一个示例一样以属性的方式存储制造商、型号和生产年份。接下来，Python 创建一个名为 odometer_reading 的属性，并将其初始值设置为 0（见❶）。在❷处，定义一个名为 read_odometer() 的方法，让你能够轻松地知道汽车的行驶里程1。

1此处里程的单位为英里（mile），1 英里 ≈ 1.6 千米。——编者注

一开始，汽车的行驶里程为 0：

2024 Audi A4
This car has 0 miles on it.

出售时里程表读数为 0 的汽车不多，因此需要修改该属性。

9.2.3　修改属性的值

可以用三种不同的方式修改属性的值：直接通过实例修改，通过方法设置，以及通过方法递增（增加特定的值）。下面依次介绍这些方式。

直接修改属性的值

要修改属性的值，最简单的方式是通过实例直接访问它。下面的代码直接将里程表读数设置为 23：

class Car:
    --snip--

my_new_car = Car('audi', 'a4', 2024)
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading = 23
my_new_car.read_odometer()

这里使用点号直接访问并设置汽车的属性 odometer_reading。这行代码让 Python 在实例 my_new_car 中找到属性 odometer_reading，并将其值设置为 23：

2024 Audi A4
This car has 23 miles on it.

有时候需要像这样直接访问属性，但其他时候需要编写方法来替你更新属性。

通过方法修改属性的值

有一个替你更新属性的方法大有裨益。这样就无须直接访问属性了，而是可将值传递给方法，由它在内部进行更新。

下面的示例演示了一个名为 update_odometer() 的方法：

 class Car:
      --snip--

      def update_odometer(self, mileage):
          """将里程表读数设置为指定的值"""
          self.odometer_reading = mileage

  my_new_car = Car('audi', 'a4', 2024)
  print(my_new_car.get_descriptive_name())

❶ my_new_car.update_odometer(23)
  my_new_car.read_odometer()

对 Car 类所做的唯一修改是，添加了 update_odometer() 方法。这个方法接受一个里程值，并将其赋给 self.odometer_reading。在❶处，通过实例 my_new_car 调用 update_odometer()，并向它提供了实参 23（该实参对应于方法定义中的形参 mileage）。这将里程表读数设置为 23。read_odometer() 方法会打印该读数：

2024 Audi A4
This car has 23 miles on it.

还可以对 update_odometer() 方法进行扩展，使其在修改里程表读数时做些额外的工作。下面来添加一些逻辑，禁止将里程表读数往回调：

 class Car:
      --snip--

      def update_odometer(self, mileage):
          """
          将里程表读数设置为指定的值
          禁止将里程表读数往回调
          """
❶         if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
          else:
❷             print("You can't roll back an odometer!")

现在，update_odometer() 会在修改属性前检查指定的读数是否合理。如果给 mileage 指定的值大于或等于原来的行驶里程（self.odometer_reading），就将里程表读数改为新指定的行驶里程（见❶）；否则发出警告，指出不能将里程表往回调（见❷）。

通过方法让属性的值递增

有时候需要将属性值递增特定的量，而不是将其设置为全新的值。假设我们购买了一辆二手车，从购买到登记期间增加了 100 英里的里程。下面的方法让我们能够传递这个增量，并相应地增大里程表读数：

class Car:
      --snip--

      def update_odometer(self, mileage):
          --snip--

      def increment_odometer(self, miles):
          """让里程表读数增加指定的量"""
          self.odometer_reading += miles

❶ my_used_car = Car('subaru', 'outback', 2019)
  print(my_used_car.get_descriptive_name())

❷ my_used_car.update_odometer(23_500)
  my_used_car.read_odometer()

❸ my_used_car.increment_odometer(100)
  my_used_car.read_odometer()

新增的方法 increment_odometer() 接受一个单位为英里的数，并将其加到 self.odometer_reading 上。首先，创建一辆二手车 my_used_car（见❶）。然后，调用 update_odometer() 方法并传入 23_500，将这辆二手车的里程表读数设置为 23 500（见❷）。最后，调用 increment_odometer() 并传入 100，以增加从购买到登记期间行驶的 100 英里（见❸）：

2019 Subaru Outback
This car has 23500 miles on it.
This car has 23600 miles on it.

我们可以修改这个方法，以禁止增量为负值，从而防止有人利用它把里程表往回调。

注意：虽然可以使用类似于上面的方法来控制用户修改属性值（如里程表读数）的方式，但能够访问程序的人都能直接访问属性将里程表修改为任意的值。要确保安全，除了进行类似于前面的基本检查以外，还需要极度关注细节。

动手试一试

练习 9.4：就餐人数　在为练习 9.1 编写的程序中，添加一个名为 number_served 的属性，并将其默认值设置为 0。根据这个类创建一个名为 restaurant 的实例。打印有多少人在这家餐馆就餐过，然后修改这个值并再次打印。

添加一个名为 set_number_served() 的方法，用来设置就餐人数。调用这个方法并向它传递新的就餐人数，然后再次打印这个值。

添加一个名为 increment_number_served() 的方法，用来让就餐人数递增。调用这个方法并向它传递一个这样的值：你认为这家餐馆每天可能接待的就餐人数。

练习 9.5：尝试登录次数　在为练习 9.3 编写的 User 类中，添加一个名为 login_attempts 的属性。编写一个名为 increment_login_attempts() 的方法，用来将属性 login_attempts 的值加 1。再编写一个名为 reset_login_attempts() 的方法，用来将属性 login_attempts 的值重置为 0。

根据 User 类创建一个实例，再调用 increment_login_attempts() 方法多次。打印属性 login_attempts 的值，确认它正确地递增了。然后，调用方法 reset_login_attempts()，并再次打印属性 login_attempts 的值，确认它被重置为 0。

9.3　继承

在编写类时，并非总是要从头开始。如果要编写的类是一个既有的类的特殊版本，可使用继承（inheritance）。当一个类继承另一个类时，将自动获得后者的所有属性和方法。原有的类称为父类（parent class），而新类称为子类（child class）。子类不仅继承了父类的所有属性和方法，还可定义自己的属性和方法。

9.3.1　子类的 init() 方法

在既有的类的基础上编写新类，通常要调用父类的 init() 方法。这将初始化在父类的 init() 方法中定义的所有属性，从而让子类也可以使用这些属性。

例如，下面来模拟电动汽车。电动汽车是一种特殊的汽车，因此可在之前 Car 类的基础上创建新类 ElectricCar。这样，只需为电动汽车特有的属性和行为编写代码即可。

下面创建 ElectricCar 类的一个简单版本，它具备 Car 类的所有功能：

electric_car.py

❶ class Car:
      """一次模拟汽车的简单尝试"""

      def __init__(self, make, model, year):
          """初始化描述汽车的属性"""
          self.make = make
          self.model = model
          self.year = year
          self.odometer_reading = 0

      def get_descriptive_name(self):
          """返回格式规范的描述性名称"""
          long_name = f"{self.year} {self.make} {self.model}"
          return long_name.title()

      def read_odometer(self):
          """打印一个句子，指出汽车的行驶里程"""
          print(f"This car has {self.odometer_reading} miles on it.")

      def update_odometer(self, mileage):
          """将里程表读数设置为给定的值"""
          if mileage >= self.odometer_reading:
              self.odometer_reading = mileage
          else:
              print("You can't roll back an odometer!")

      def increment_odometer(self, miles):
          """让里程表读数增加给定的量"""
          self.odometer_reading += miles

❷ class ElectricCar(Car):
      """电动汽车的独特之处"""

❸     def __init__(self, make, model, year):
          """初始化父类的属性"""
❹         super().__init__(make, model, year)


❺ my_leaf = ElectricCar('nissan', 'leaf', 2024)
  print(my_leaf.get_descriptive_name())

首先是 Car 类的代码（见❶）。在创建子类时，父类必须包含在当前文件中，且位于子类前面。接下来，定义子类 ElectricCar（见❷）。在定义子类时，必须在括号内指定父类的名称。init() 方法接受创建 Car 实例所需的信息（见❸）。

super() 是一个特殊的函数，让你能够调用父类的方法（见❹）。这行代码让 Python 调用 Car 类的 init() 方法，从而让 ElectricCar 实例包含这个方法定义的所有属性。父类也称为超类（superclass），函数名 super 由此得名。

为了测试继承能够正确地发挥作用，我们尝试创建一辆电动汽车，但提供的信息与创建燃油汽车时相同。在❺处，创建 ElectricCar 类的一个实例，并将其赋给变量 my_leaf。这行代码调用 ElectricCar 类中定义的 init() 方法，后者让 Python 调用父类 Car 中定义的 init() 方法。我们提供了实参 ‘nissan’、‘leaf’ 和 2024。

除了 init() 方法以外，电动汽车还没有特有的属性和方法。当前，我们只想确认电动汽车的一些行为与燃油汽车一致：

2024 Nissan Leaf

ElectricCar 实例的行为与 Car 实例一样，现在可以开始定义电动汽车特有的属性和方法了。

9.3.2　给子类定义属性和方法

让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。

下面添加一个电动汽车特有的属性（电池），以及一个描述该属性的方法。我们将存储电池容量，并编写一个方法打印对电池的描述：

 class Car:
      --snip--

  class ElectricCar(Car):
      """电动汽车的独特之处"""

      def __init__(self, make, model, year):
          """
          先初始化父类的属性，再初始化电动汽车特有的属性
          """
          super().__init__(make, model, year)
❶         self.battery_size = 40

❷     def describe_battery(self):
          """打印一条描述电池容量的消息"""
          print(f"This car has a {self.battery_size}-kWh battery.")

  my_leaf = ElectricCar('nissan', 'leaf', 2024)
  print(my_leaf.get_descriptive_name())
  my_leaf.describe_battery()

在❶处，添加新属性 self.battery_size，并设置其初始值（40）。根据 ElectricCar 类创建的所有实例都将包含这个属性，但所有的 Car 实例都不包含它。在❷处，还添加了一个名为 describe_battery() 的方法，用来打印有关电池的信息。在调用这个方法时，可以看到一条电动汽车特有的描述：

2024 Nissan Leaf
This car has a 40-kWh battery.

对于 ElectricCar 类的特殊程度没有任何限制，在模拟电动汽车时，可根据所需的准确程度添加任意数量的属性和方法。如果一个属性或方法是所有汽车都有的，而不是电动汽车特有的，就应将其加入 Car 类而不是 ElectricCar 类。这样，使用 Car 类的成员将获得相应的功能，而 ElectricCar 类只包含处理电动汽车特有属性和行为的代码。

9.3.3　重写父类中的方法

在使用子类模拟的实物的行为时，如果父类中的一些方法不能满足子类的需求，就可以用下面的办法重写：在子类中定义一个与要重写的父类方法同名的方法。这样，Python 将忽略这个父类方法，只关注你在子类中定义的相应方法。

假设 Car 类有一个名为 fill_gas_tank() 的方法，它对电动汽车来说毫无意义，因此你可能想重写它。下面演示了一种重写方式：

class ElectricCar(Car):
    --snip--

    def fill_gas_tank(self):
        """电动汽车没有油箱"""
        print("This car doesn't have a gas tank!")

现在，如果有人对电动汽车调用 fill_gas_tank() 方法，Python 将忽略 Car 类中的 fill_gas_tank() 方法，转而运行上述代码。在使用继承时，可让子类保留从父类那里继承的“精华”，重写不需要的“糟粕”。

9.3.4　将实例用作属性

在使用代码模拟实物时，你可能会发现自己给类添加了太多细节：属性和方法越来越多，文件越来越长。在这种情况下，可能需要将类的一部分提取出来，作为一个独立的类。将大型类拆分成多个协同工作的小类，这种方法称为组合（composition）。

例如，在不断给 ElectricCar 类添加细节时，我们可能会发现其中包含很多专门针对汽车电池的属性和方法。在这种情况下，可将这些属性和方法提取出来，放到一个名为 Battery 的类中，并将一个 Battery 实例作为 ElectricCar 类的属性：

class Car:
      --snip--

  class Battery:
      """一次模拟电动汽车电池的简单尝试"""

❶     def __init__(self, battery_size=40):
          """初始化电池的属性"""
          self.battery_size = battery_size

❷     def describe_battery(self):
          """打印一条描述电池容量的消息"""
          print(f"This car has a {self.battery_size}-kWh battery.")


  class ElectricCar(Car):
      """电动汽车的独特之处"""

      def __init__(self, make, model, year):
          """
          先初始化父类的属性，再初始化电动汽车特有的属性
          """
          super().__init__(make, model, year)
❸         self.battery = Battery()

  my_leaf = ElectricCar('nissan', 'leaf', 2024)
  print(my_leaf.get_descriptive_name())
  my_leaf.battery.describe_battery()

我们定义了一个名为 Battery 的新类，它没有继承任何类（见❶）。init() 方法在 self 之外还有一个形参 battery_size。这个形参是可选的：如果没有给它提供值，电池容量将被设置为 40。describe_battery() 方法也被移到了这个类中（见❷）。

在 ElectricCar 类中，添加一个名为 self.battery 的属性（见❸）。这行代码让 Python 创建一个新的 Battery 实例（因为没有指定容量，所以为默认值 40），并将该实例赋给属性 self.battery。每当 init() 方法被调用时，都将执行该操作，因此现在每个 ElectricCar 实例都包含一个自动创建的 Battery 实例。

我们创建一辆电动汽车，并将其赋给变量 my_leaf。在描述电池时，需要使用电动汽车的属性 battery：

my_leaf.battery.describe_battery()

这行代码让 Python 在实例 my_leaf 中查找属性 battery，并对存储在该属性中的 Battery 实例调用 describe_battery() 方法。

输出与你在前面看到的相同：

2024 Nissan Leaf
This car has a 40-kWh battery.

这看似做了很多额外的工作，但是现在想多详细地描述电池都可以，且不会导致 ElectricCar 类混乱不堪。下面再给 Battery 类添加一个方法，它根据电池容量报告汽车的续航里程：

  class Car:
      --snip--

  class Battery:
      --snip--

      def get_range(self):
          """打印一条消息，指出电池的续航里程"""
          if self.battery_size == 40:
              range = 150
          elif self.battery_size == 65:
              range = 225

          print(f"This car can go about {range} miles on a full charge.")

  class ElectricCar(Car):
      --snip--

  my_leaf = ElectricCar('nissan', 'leaf', 2024)
  print(my_leaf.get_descriptive_name())
  my_leaf.battery.describe_battery()
❶ my_leaf.battery.get_range()

新增的方法 get_range() 做了一些简单的分析：如果电池的容量为 40 千瓦时，就将续航里程设置为 150 英里；如果容量为 65 千瓦时，就将续航里程设置为 225 英里。然后，它会报告这个值。为了使用这个方法，也需要通过汽车的属性 battery 来调用（见❶）。

输出已经可以根据电池的容量显示对应的续航里程了：

2024 Nissan Leaf
This car has a 40-kWh battery.
This car can go about 150 miles on a full charge.

9.3.5　模拟实物

在模拟较复杂的事物（如电动汽车）时，需要思考一些有趣的问题。续航里程是电池的属性还是汽车的属性呢？如果只描述一辆汽车，将 get_range() 方法放在 Battery 类中也许是合适的，但如果要描述一家汽车制造商的整条产品线，也许应该将 get_range() 方法移到 ElectricCar 类中。在这种情况下，get_range() 依然根据电池容量来确定续航里程，但报告的是一款汽车的续航里程。也可以这样做：仍将 get_range() 方法留在 Battery 类中，但向它传递一个参数，如 car_model。此时，get_range() 方法将根据电池容量和汽车型号报告续航里程。

这让你进入了程序员的另一个境界：在解决上述问题时，从较高的逻辑层面（而不是语法层面）思考。你考虑的不是 Python，而是如何使用代码来表示实际事物。达到这种境界后，你会经常发现，对现实世界的建模方法没有对错之分。有些方法的效率更高，但要找出效率最高的表示法，需要一定的实践。只要代码能够像你希望的那样运行，就说明你已经做得很好了！即便发现自己不得不多次尝试使用不同的方法来重写类，也不必气馁。要编写出高效、准确的代码，这是必经之路。

动手试一试

练习 9.6：冰激凌小店　冰激凌小店是一种特殊的餐馆。编写一个名为 IceCreamStand 的类，让它继承你为练习 9.1 或练习 9.4 编写的 Restaurant 类。这两个版本的 Restaurant 类都可以，挑选你更喜欢的那个即可。添加一个名为 flavors 的属性，用于存储一个由各种口味的冰激凌组成的列表。编写一个显示这些冰激凌口味的方法。创建一个 IceCreamStand 实例，并调用这个方法。

练习 9.7：管理员　管理员是一种特殊的用户。编写一个名为 Admin 的类，让它继承你为练习 9.3 或练习 9.5 完成编写的 User 类。添加一个名为 privileges 的属性，用来存储一个由字符串（如 “can add post”、“can delete post”、“can ban user” 等）组成的列表。编写一个名为 show_privileges() 的方法，显示管理员的权限。创建一个 Admin 实例，并调用这个方法。

练习 9.8：权限　编写一个名为 Privileges 的类，它只有一个属性 privileges，其中存储了练习 9.7 所述的字符串列表。将方法 show_privileges() 移到这个类中。在 Admin 类中，将一个 Privileges 实例用作其属性。创建一个 Admin 实例，并使用方法 show_privileges() 来显示权限。

练习 9.9：电池升级　在本节最后一个 electric_car.py 版本中，给 Battery 类添加一个名为 upgrade_battery() 的方法。这个方法检查电池容量，如果电池容量不是 65，就设置为 65。创建一辆电池容量为默认值的电动汽车，调用方法 get_range()，然后对电池进行升级，并再次调用 get_range()。你将看到这辆汽车的续航里程增加了。

9.4　导入类

随着不断地给类添加功能，文件可能变得很长，即便妥善地使用了继承和组合亦如此。遵循 Python 的整体理念，应该让文件尽量整洁。Python 在这方面提供了帮助，允许你将类存储在模块中，然后在主程序中导入所需的模块。

9.4.1　导入单个类

下面创建一个只包含 Car 类的模块。有一个微妙的命名问题：在本章中，已经有一个名为 car.py 的文件，但这个模块也应命名为 car.py，因为它包含表示汽车的代码。我们将这样解决这个命名问题：将 Car 类存储在一个名为 car.py 的模块中，该模块将覆盖前面的文件 car.py。从现在开始，使用该模块的程序都必须使用更具体的文件名，如 my_car.py。下面是模块 car.py，其中只包含 Car 类的代码：

car.py

❶ """一个用来表示汽车的类"""

  class Car:
      """一次模拟汽车的简单尝试"""

      def __init__(self, make, model, year):
          """初始化描述汽车的属性"""
          self.make = make
          self.model = model
          self.year = year
          self.odometer_reading = 0

      def get_descriptive_name(self):
          """返回格式规范的描述性名称"""
          long_name = f"{self.year} {self.make} {self.model}"
          return long_name.title()

      def read_odometer(self):
          """打印一条消息，指出汽车的行驶里程"""
          print(f"This car has {self.odometer_reading} miles on it.")

      def update_odometer(self, mileage):
          """
          将里程表读数设置为指定的值
          拒绝将里程表往回调
          """
          if mileage >= self.odometer_reading:
              self.odometer_reading = mileage
          else:
              print("You can't roll back an odometer!")

      def increment_odometer(self, miles):
          """让里程表读数增加指定的量"""
          self.odometer_reading += miles

❶处是一个模块级文档字符串，对该模块的内容做了简要的描述。你应该为自己创建的每个模块编写文档字符串。

下面来创建另一个文件——my_car.py，在其中导入 Car 类并创建其实例：

my_car.py

❶ from car import Car

  my_new_car = Car('audi', 'a4', 2024)
  print(my_new_car.get_descriptive_name())

  my_new_car.odometer_reading = 23
  my_new_car.read_odometer()

import 语句（见❶）让 Python 打开模块 car 并导入其中的 Car 类。这样，我们就可以使用 Car 类，就像它是在当前文件中定义的一样。输出与你在前面看到的一样：

2024 Audi A4
This car has 23 miles on it.

导入类是一种高效的编程方式。如果这个程序包含整个 Class 类，它该有多长啊！通过将这个类移到一个模块中并导入该模块，依然可使用其所有功能，但主程序文件变得整洁易读了。这还让你能够将大部分逻辑存储在独立的文件中。在确定类能像你希望的那样工作后，就可以不管这些文件，专注于主程序的高级逻辑了。

9.4.2　在一个模块中存储多个类

尽管同一个模块中的类之间应该存在某种相关性，但其实可以根据需要在一个模块中存储任意数量的类。Battery 类和 ElectricCar 类都可帮助模拟汽车，下面将它们都加入模块 car.py：

car.py

"""一组用于表示燃油汽车和电动汽车的类"""

class Car:
    --snip--

class Battery:
    """一次模拟电动汽车电瓶的简单尝试"""

    def __init__(self, battery_size=40):
        """初始化电池的属性"""
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电池容量的消息"""
        print(f"This car has a {self.battery_size}-kWh battery.")

    def get_range(self):
        """打印一条描述电池续航里程的消息"""
        if self.battery_size == 40:
            range = 150
        elif self.battery_size == 65:
            range = 225

        print(f"This car can go about {range} miles on a full charge.")

class ElectricCar(Car):
    """模拟电动汽车的独特之处"""

    def __init__(self, make, model, year):
        """
        先初始化父类的属性，再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)
        self.battery = Battery()

现在，可以新建一个名为 my_electric_car.py 的文件，导入 ElectricCar 类，并创建一辆电动汽车了：

my_electric_car.py

from car import ElectricCar

my_leaf = ElectricCar('nissan', 'leaf', 2024)
print(my_leaf.get_descriptive_name())
my_leaf.battery.describe_battery()
my_leaf.battery.get_range()

输出与你在前面看到的相同，但大部分逻辑隐藏在一个模块中：

2024 Nissan Leaf
This car has a 40-kWh battery.
This car can go about 150 miles on a full charge.

9.4.3　从一个模块中导入多个类

可以根据需要在程序文件中导入任意数量的类。如果要在同一个程序中创建燃油汽车和电动汽车，就需要将 Car 类和 ElectricCar 类都导入：

my_cars.py

❶ from car import Car, ElectricCar

❷ my_mustang = Car('ford', 'mustang', 2024)
  print(my_mustang.get_descriptive_name())
❸ my_leaf = ElectricCar('nissan', 'leaf', 2024)
  print(my_leaf.get_descriptive_name())

当从一个模块中导入多个类时，用逗号分隔各个类（见❶）。导入必要的类后，就可根据需要创建每个类的任意数量的实例了。

在这个示例中，创建了一辆福特野马燃油汽车（见❷）和一辆日产聆风电动汽车（见❸）：

2024 Ford Mustang
2024 Nissan Leaf

9.4.4　导入整个模块

还可以先导入整个模块，再使用点号访问需要的类。这种导入方法很简单，代码也易读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称发生冲突。

下面的代码导入整个 car 模块，并创建一辆燃油汽车和一辆电动汽车：

my_cars.py

❶ import car

❷ my_mustang = car.Car('ford', 'mustang', 2024)
  print(my_mustang.get_descriptive_name())

❸ my_leaf = car.ElectricCar('nissan', 'leaf', 2024)
  print(my_leaf.get_descriptive_name())

首先，导入整个 car 模块（见❶）。接下来，使用语法 module_name.classname 访问需要的类。像前面一样，我们创建了一辆福特野马燃油汽车（见❷）和一辆日产聆风电动汽车（见❸）。

9.4.5　导入模块中的所有类

要导入模块中的每个类，可使用下面的语法：

from module_name import *

不推荐这种导入方式，原因有二。第一，最好只需要看一下文件开头的 import 语句，就能清楚地知道程序使用了哪些类。但这种导入方式没有明确地指出使用了模块中的哪些类。第二，这种导入方式还可能引发名称方面的迷惑。如果不小心导入了一个与程序文件中的其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐，但你可能在别人编写的代码中见到它。

当需要从一个模块中导入很多类时，还是最好在导入整个模块之后使用 module_name.classname 语法来访问这些类。这样，虽然文件开头并没有列出用到的所有类，但是你清楚地知道在程序的哪些地方使用了导入的模块。此外，这还避免了导入模块中的每个类可能引发的名称冲突。

9.4.6　在一个模块中导入另一个模块

有时候，需要将类分散到多个模块中，以免模块太大或者在同一个模块中存储不相关的类。在将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。

下面将 Car 类存储在一个模块中，并将 ElectricCar 和 Battery 类存储在另一个模块中。将第二个模块命名为 electric_car.py（这将覆盖前面创建的文件 electric_car.py），并将 Battery 类和 ElectricCar 类复制到这个模块中：

electric_car.py

"""一组可用于表示电动汽车的类"""

from car import Car

class Battery:
    --snip--

class ElectricCar(Car):
    --snip--

ElectricCar 类需要访问其父类 Car，因此直接将 Car 类导入该模块。如果忘记了这行代码，Python 将在我们试图创建 ElectricCar 实例时报错。还需更新 car 模块，使其只包含 Car 类：

car.py

"""一个可用于表示汽车的类"""

class Car:
    --snip--

现在可分别从每个模块中导入类，以根据需要创建任意类型的汽车了：

my_cars.py

from car import Car
from electric_car import ElectricCar

my_mustang = Car('ford', 'mustang', 2024)
print(my_mustang.get_descriptive_name())

my_leaf = ElectricCar('nissan', 'leaf', 2024)
print(my_leaf.get_descriptive_name())

我们从 car 模块中导入了 Car 类，并从 electric_car 模块中导入了 ElectricCar 类。接下来，创建一辆燃油汽车和一辆电动汽车。这两种汽车都被正确地创建了：

2024 Ford Mustang
2024 Nissan Leaf

9.4.7　使用别名

第 8 章说过，当使用模块来组织项目代码时，别名能发挥很大的作用。在导入类时，也可以给它指定别名。

假设要在程序中创建大量电动汽车实例，需要反复输入 ElectricCar，非常烦琐。为了避免这种烦恼，可在 import 语句中给 ElectricCar 指定一个别名：

from electric_car import ElectricCar as EC

现在每当需要创建电动汽车实例时，都可使用这个别名：

my_leaf = EC('nissan', 'leaf', 2024)

还可以给模块指定别名。下面导入模块 electric_car 并给它指定了别名：

import electric_car as ec

现在可以结合使用模块别名和完整的类名了：

my_leaf = ec.ElectricCar('nissan', 'leaf', 2024)

9.4.8　找到合适的工作流程

如你所见，在组织大型项目的代码方面，Python 提供了很多选项。熟悉所有这些选项很重要，这样才能确定哪种项目组织方式是最佳的，才能理解别人开发的项目。

一开始应让代码结构尽量简单。首先尝试在一个文件中完成所有的工作，确定一切都能正确运行后，再将类移到独立的模块中。如果你喜欢模块和文件的交互方式，可在项目开始时就尝试将类存储到模块中。先找出让你能够编写出可行代码的方式，再尝试让代码更加整洁。

动手试一试

练习 9.10：导入 Restaurant 类　将最新的 Restaurant 类存储在一个模块中。在另一个文件中导入 Restaurant 类，创建一个 Restaurant 实例，并调用 Restaurant 的一个方法，以确认 import 语句正确无误。

练习 9.11：导入 Admin 类　以为完成练习 9.8 而做的工作为基础。将 User 类、Privileges 类和 Admin 类存储在一个模块中，再创建一个文件，在其中创建一个 Admin 实例并对其调用 show_privileges() 方法，以确认一切都能正确地运行。

练习 9.12：多个模块　将 User 类存储在一个模块中，并将 Privileges 类和 Admin 类存储在另一个模块中。再创建一个文件，在其中创建一个 Admin 实例并对其调用 show_privileges() 方法，以确认一切依然能够正确地运行。

9.5　Python 标准库

Python 标准库是一组模块，在安装 Python 时已经包含在内。你现在已经对函数和类的工作原理有了大致的了解，可以开始使用其他程序员编写好的模块了。你可以使用标准库中的任何函数和类，只需在程序开头添加一条简单的 import 语句即可。下面来看看模块 random，它在你模拟很多现实情况时很有用。

在这个模块中，一个有趣的函数是 randint()。它将两个整数作为参数，并随机返回一个位于这两个整数之间（含）的整数。下面演示了如何生成一个位于 1 和 6 之间的随机整数：

>>> from random import randint
>>> randint(1, 6)
3

在模块 random 中，另一个很有用的函数是 choice()。它将一个列表或元组作为参数，并随机返回其中的一个元素：

>>> from random import choice
>>> players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>> first_up = choice(players)
>>> first_up
'florence'

在创建与安全相关的应用程序时，不要使用模块 random，但它能用来创建众多有趣的项目。

注意：还可以从其他地方下载外部模块。第二部分的每个项目都需要使用外部模块，届时你将看到很多这样的示例。

动手试一试

练习 9.13：骰子　创建一个 Die 类，它包含一个名为 sides 的属性，该属性的默认值为 6。编写一个名为 roll_die() 的方法，它打印位于 1 和骰子面数之间的随机数。创建一个 6 面的骰子并掷 10 次。

创建一个 10 面的骰子和一个 20 面的骰子，再分别掷 10 次。

练习 9.14：彩票　创建一个列表或元素，其中包含 10 个数和 5 个字母。从这个列表或元组中随机选择 4 个数或字母，并打印一条消息，指出只要彩票上是这 4 个数或字母，就中大奖了。

练习 9.15：彩票分析　可以使用一个循环来理解中前述彩票大奖有多难。为此，创建一个名为 my_ticket 的列表或元组，再编写一个循环，不断地随机选择数或字母，直到中大奖为止。请打印一条消息，报告执行多少次循环才中了大奖。

练习 9.16：Python 3 Module of the Week　要了解 Python 标准库，一个很不错的资源是网站 Python 3 Module of the Week。请访问该网站并查看其中的目录，找一个你感兴趣的模块进行探索，从模块 random 开始可能是个不错的选择。

9.6　类的编程风格

你必须熟悉有些与类相关的编程风格问题，在编写的程序较复杂时尤其如此。

类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，并且不使用下划线。实例名和模块名都采用全小写格式，并在单词之间加上下划线。

对于每个类，都应在类定义后面紧跟一个文档字符串。这种文档字符串简要地描述类的功能，你应该遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用来做什么进行描述。

可以使用空行来组织代码，但不宜过多。在类中，可以使用一个空行来分隔方法；而在模块中，可以使用两个空行来分隔类。

当需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的 import 语句，再添加一个空行，然后编写导入你自己编写的模块的 import 语句。在包含多条 import 语句的程序中，这种做法让人更容易明白程序使用的各个模块来自哪里。

9.7　小结

在本章中，你首先学习了如何编写类，如何使用属性在类中存储信息，以及如何编写方法让类具备所需的行为。然后学习了如何编写 init() 方法，以便根据类创建包含所需属性的实例。你了解了如何修改实例的属性，包括直接修改以及通过方法修改。你还了解到，使用继承可简化相关类的创建工作，将一个类的实例用作另一个类的属性能让类更简洁。

接着，你明白了，通过将类存储在模块中，并在需要使用这些类的文件中导入它们，可让项目变得整洁。你开始了解 Python 标准库，还看到了一个使用 random 模块的示例。最后，你学习了在编写类时应遵循的 Python 约定。

在第 10 章中，你将学习如何使用文件，从而保存你在程序中所做的工作，以及你让用户做的工作。你还将学习（捕获并处理）异常，这是一种特殊的 Python 类，可帮助你在错误发生时采取相应的措施。