类

使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类Dog，他表示的不是特定的小狗，而是任何小狗。

创建Dog类

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

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!')

class Dog:定义了一个名为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 ）提供值。

        self.name = name
        self.age = age

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

根据类创建实例

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

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!')
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.")

:::tips 在这里，命名约定很有用：通常可认为首字母大写的名称（如：Dog）指的是类，而小写的名称（如：my_dog）指的是根据类创建的实例。 :::

1. 访问属性

要访问实例的属性，可使用句点表示法。

mydog.name

1. 调用方法

根据 Dog 类创建实例后，就能使用句点表示法来调用 Dog 类中定义的任何方法了。

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!')
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.")
my_dog.sit()
my_dog.roll_over()

1. 创建多个实例 ```python 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!')
   

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()

![image.png](https://cdn.nlark.com/yuque/0/2021/png/1277032/1633618689550-5f9e8207-fbbd-422c-922a-f7a62a2078d0.png#clientId=u87648efc-f333-4&from=paste&id=u5c3f8d84&margin=%5Bobject%20Object%5D&name=image.png&originHeight=142&originWidth=327&originalType=binary&ratio=1&size=7894&status=done&style=none&taskId=ub0de144d-6642-4216-b5a8-0ee46ebe168)
<a name="LZY7v"></a>
## 使用类和实例
<a name="I4mPl"></a>
### Car类
```python
class Car:
    '''一次模拟汽车的简单尝试'''

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

    def get_descriptive_name(self):
        '''返回整洁的描述信息。'''
        long_name = f"{self.year} {self.make} {self.modle}"
        return long_name.title()

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

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

给属性指定默认值

创建实例时，有些属性无需通过形参来定义，可在 方法__init__()中为其指定默认值。
下面来添加一个名为 odometer_reading的属性，其初始值总是0。 我们还添加了一个名为 read_odometer()的方法，用于读取汽车的里程表。

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

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

        ###
        self.odometer_reading = 0

    def get_descriptive_name(self):
        '''返回整洁的描述信息。'''
        long_name = f"{self.year} {self.make} {self.modle}"
        return long_name.title()

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

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

修改属性的值

能以三种方式修改属性的值：直接通过实例进行修改、通过方法进行设置、以及通过方法进行递增（增加特定的值）

1. 直接修改属性的值

通过实例直接访问它

my_new_car.odometer_reading = 23

1. 通过方法修改属性的值 ```python class Car: —snip—

   def update_odometer(self, mileage):

    '''将里程表读数设置为指定的值。'''
    self.odometer_reading = mileage
   

my_new_car = Car(‘audi’, ‘a4’, ‘2019’) print(my_new_car.get_descriptive_name()) my_new_car.read_odometer()

my_new_car.update_odometer(23) my_new_car.read_odometer()

可对方法 `update_odometer()`进行扩展，使其在修改里程表读数时做些额外的工作。下面来添加一些逻辑，禁止任何人将里程表数字往回调：
```python
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!")

1. 通过方法对属性的值进行递增 ```python class Car: —snip—

   def increment_odometer(self, miles):

    '''将里程表增加指定的量。'''
    self.odometer_reading += miles
   

my_new_car = Car(‘audi’, ‘a4’, ‘2019’) print(my_new_car.get_descriptive_name()) my_new_car.read_odometer()

my_new_car.update_odometer(23) my_new_car.read_odometer()

my_new_car.update_odometer(10) my_new_car.read_odometer()

> 你可以轻松地修改这个方法，以禁止增量为负值，从而防止有人利用它来回调里程表

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

<a name="xXqbk"></a>
## 继承
编写类时，并非总是要从空白开始。如果要编写的类是另一个现成类的特殊版本，可使用**继承**。一个类**继承**另一个类时，将自动获得另一个类的所有属性和方法。原有的类称为**父类**，而新的类称为**子类**。子类继承了父类所有的属性和方法，同时还可以定义自己的属性和方法。

<a name="shGrH"></a>
### 子类的方法`__init__()`
在既有类的基础上编写新类时，通常要调用父类的方法`__init__()`。这将初始化在父类`__init__()`方法中定义的所有属性，从而让子类包含这些属性。<br />例如，下面来模拟电动汽车。电动汽车是一种特殊的汽车，因此可在前面创建的Car类的及存储上创建新类 ElectricCar。这样就只需为电动汽车特有的属性和行为编写代码。<br />下面来创建一个 ElectricCar 类的一个简单版本，他具备 Car 类的所有功能：
```python
class Car:
    '''一次模拟汽车的简单尝试'''

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

    def get_descriptive_name(self):
        '''返回整洁的描述信息。'''
        long_name = f"{self.year} {self.make} {self.modle}"
        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_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())

class Car:创建子类时，父类必须包含在当前文件中，且位于子类前面

class ElectricCar(Car):定义了子类 ElectricCar。定义子类时，必须在圆括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息

super().__init__(make, model, year)处的super()是一个特殊函数，让你能够调用父类的方法。 这行代码让Python调用Car类的方法__intit__()，让 ElectricCar 实例包含这个方法中定义的所有属性。 父类也成为超类（ superclass ）名称super由此而来。

给子类定义属性和方法

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

class Car:
    --snip--

class ElectricCar(Car):
    '''电动汽车的独到之处'''

    def __init__(self, make, model, year):
        '''
        初始化父类的属性。
        再初始化电动汽车特有的属性
        '''
        super().__init__(make, model, year)
        self.battery_size = 75

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

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

self.battery_size = 75添加了新属性 self.battery_size， 并设置其初始值（75）。根据 ElectricCar 类创建的所有实例都将包含该属性， 但所有Car实例都不包含它。

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

重写父类的方法

对于父类的方法，只要它不符合子类模拟的实物的行为，都可以进行重写。 为此，可在子类中定义一个与要重写的父类方法同名的方法。 这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。

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

class ElectricCar(Car):
    --snip--

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

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

将实例用作属性

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

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

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

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

    def get_descriptive_name(self):
        '''返回整洁的描述信息。'''
        long_name = f"{self.year} {self.make} {self.modle}"
        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 Battery:
    """一次模拟电动汽车电池的简单尝试。"""

    def __init__(self, battery_size = 75):
        '''初始化电瓶的属性'''
        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()

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

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

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

下面再给 Battery 类添加一个方法，他根据电瓶容量报告汽车的续航里程：

class Car:
    --snip--

class Battery:
   --snip--

    def get_range(self):
        '''打印一条消息，指出电瓶的续航里程。'''
        if self.battery_size == 75:
            range = 260
        elif self.battery_size == 100:
            range = 315

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

class ElectricCar(Car):
    --snip--

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

模拟实物

模拟较复杂的物件（如电动汽车）时，需要解决一些有趣的问题。续航里程时电瓶的属性还是汽车的属性呢？如果只描述一辆汽车，将方法 get_range() 放在 Battery 类中也许时合适的，但如果要描述一家汽车制造商的整个产品线，也许应该将方法 get_range() 移到 ElectricCar 类中。在这种情况下， get_range()依然根据电瓶容量来确定续航里程，但报告的时一款汽车的续航里程。 也可以这样做：仍将方法 get_range() 留在 Battery 类中，但向它传递一个参数， 如 car_model。在这种情况下，方法 get_range()将根据电瓶容量和汽车型号报告续航里程。 这让你进入了程序员的另一个境界：解决上述问题时，从较高的逻辑层面（而不是语法层面）考虑；考虑的不是Python，二十如何使用代码来表示实物。达到这种境界后，你会经常发现，对现实世界的建模方法没有对错之分。有些方法的效率更高，但要找出效率最高的表示法，需要经过一定的实践。只要代码像你希望的那样运行，就说明你做得很好！即便发现自己不得不多次尝试使用不同的方法来重写类，也不必气馁。要编写出高效、准确的代码，都得经过这样的过程。

导入类

导入单个类

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

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

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

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

    def get_descriptive_name(self):
        '''返回整洁的描述信息。'''
        long_name = f"{self.year} {self.make} {self.modle}"
        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 类并创建其实例：

from car import Car

my_new_car = Car('audi', 'A4', 2019)
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading = 23
my_new_car.read_odometer()

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

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

在一个模块中存储多个类

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

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

class Car:
    --snip--

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

    def __init__(self, battery_size = 75):
        '''初始化电瓶的属性'''
        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 == 75:
            range = 260
        elif self.battery_size == 100:
            range = 315

        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()

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

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

from car import ElectricCar

my_tesla = ElectricCar('tesla', 'modle s', 2019)

print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

从一个模块中导入多个类

可根据需要在程序中导入任意数量的类。

from car import Car, ElectricCar

my_new_car = Car('audi', 'A4', 2019)
print(my_new_car.get_descriptive_name())

my_tesla = ElectricCar('tesla', 'modle s', 2019)
print(my_tesla.get_descriptive_name())

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

导入整个模块

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

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

import car

my_beetle = car.Car('volkswagen', 'beetle', 2019)
print(my_beetle.get_descriptive_name())

my_tesla = car.ElectricCar('tesla', 'roadster', 2019)
print(my_tesla.get_descriptive_name())

导入模块中的所有类

from module_name import *

:::tips 不推荐这种方法，原因有二。第一，如果只看文件开头的 import 语句， 就能清楚地知道程序使用了哪些类，将大有裨益。然而这种导入方式没有明确地指出使用了模块中的那些类。第二，这种方式还可能引发名称发面的迷惑。如果一不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐使用，但你可能在别人编写的代码中见到它。
需要从一个模块中导入很多类时，最好导入整个模块，并使用module_name.ClassName语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块。这也避免了导入模块中的每个类可能引发的程序冲突。 :::

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

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

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

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

from car import Car

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

    def __init__(self, battery_size = 75):
        '''初始化电瓶的属性'''
        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 == 75:
            range = 260
        elif self.battery_size == 100:
            range = 315

        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()

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

还需更新模块 car,使其只包含 Car 类：

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

class Car:
    --snip--

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

from car import Car
from electric_car import ElectricCar

my_beetle = Car('volkswagen', 'beetle', 2019)
print(my_beetle.get_descriptive_name())

my_tesla = ElectricCar('tesla', 'roadster', 2019)
print(my_tesla.get_descriptive_name())

使用别名

前面说过，使用模块来组织项目代码时，别名大有裨益。导入类时，也可为其指定别名。

from car import Car
from electric_car import ElectricCar as EC

my_beetle = Car('volkswagen', 'beetle', 2019)
print(my_beetle.get_descriptive_name())

my_tesla = EC('tesla', 'roadster', 2019)
print(my_tesla.get_descriptive_name())

自定义工作流程

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

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

Python标准库

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

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

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

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

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

:::info 创建与安全相关的应用程序时，请不要使用模块 random， 但该模块可以很好地用于创建众多有趣的项目。 ::: :::tips Python Module of the Week 要了解Python标准库，一个很不错的资源是网站 Python 3 Module of the Week 。 请访问该网站并查看其中的目录，找一个你感兴趣的模块进行探索。从模块random开始可能是个不错的选择。 ::: 👇附翻译版

类编码风格

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

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

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

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

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