类（python）
面向对象编程是最有效的软件编写方法之一。在面向对象编程中，你编写表示现实世界中的事物和情景类，并基于这些类来创建对象。编写类时，你定义一大类对象都有的通用行为。基于类创建对象时，每个对象都自动具备这种通用欣慰，然后可根据需要赋予每个对象独特的个性。使用面向对象编程可模拟现实场景，其逼真程度达到了令人惊讶的地步。
根据类来创建对象称为实例化，这让你能够使用类的实例。
创建和使用类
使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类，他表示的不是特定的小狗，而是任何小狗。对于大多数宠物狗，由于大多数小狗都具备名字和年龄，还有两种行为（蹲下和打滚)，我们的Dog类将包含它们。这个类让python指导如何创建表示小狗的对象。编写这个类后，我们将使用它来创建表示特定小狗的实例。
创建 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!")
这里定义了一个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 的作用与此类似。像这样可通过实例访问的变量称为属性。
Dog 类还定义了另外两个方法：sit() 和 roll_over()。这些方法执行时不需要额外的信息，因此它们只有一个形参 self。我们随后将创建的实例能够访问这些方法，换句话说，它们都会蹲下和打滚。当前， sit() 和 roll_over() 所做的有限，只是打印一条信息，指出小狗正在蹲下或打滚。但可以扩展这些方法以模拟实际情况：如果这个类包含在一个计算机游戏中，这些方法将包含创建小狗蹲下和打滚动画效果的代码；如果这个类是用于控制机器狗的，这些方法将让机器狗做出蹲下和打滚的动作。
根据类创建实例
可将类视为有关如何创建实例的说明。Dog 类是一系列说明，让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)
>>> print(f"My dog's name is {my_dog.name}.")
>>> print(f"My dog is {my_dog.age} years old.")
这里使用的是前一个示例中编写的 Dog 类。Dog(‘Willie’, 6) 让python创建一条名字为 ‘Willie’，年龄为6的小狗。遇到这行代码时，python使用实参 ‘Willie’ 和6调用 Dog类的方法 __init__()。方法 __init__() 创建一个表示特定小狗的实例，并使用提供的值来设置属性 name 和 age。接下来，python返回一个表示这条小狗的实例，而我们将这个实例付给了变量 my_dog。在这里，命名约定很有用：通常认为首字母大写的名称（如 Dog）指的是类，而小写的名称（如my_dog）指的是根据类创建的实例。
1. 访问属性
要访问实例的属性，可使用句点表示法。如访问 my_dog 的属性 name 的值:
my_dog.name
句点表示法在 python 中很常用，这种语法演示了 python 如何获悉属性的值。在这里，python先找到实例 my_dog，在查找与该实例相关联的属性 name。在 Dog 类中引用这个属性时，使用的是 self.name。同样的方法来获取属性 age 的值。
2. 调用方法
根据 Dog 类创建实例后，就能使用句点表示法来调用 Dog 类中的任何方法了。下面来让小狗蹲下和打滚：
>>> my_dog = Dog('Willie', 6)
>>> my_dog.sit()
Willie is now sitting.
>>> my_dog.roll_over()
Willie rolled over!
要调用方法，可指定实例的名称（这里是my_dog）和要调用的方法，并用句点分隔。遇到代码 my_dog.sit() 时，python在类 Dog 中查找方法 sit() 并运行其代码。python以同样的方式解读代码 my_dog.roll_over()。
3. 创建多个实例
可按需求根据类创建任意数量的实例：
>>> 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()
My dog's name is Willie.
My dog is 6 years old.
Willie is now sitting.
>>> print(f"Your dog's name is {your_dog.name}.")
>>> print(f"Your dog is {your_dog.age} years old.")
>>> your_dog.sit()
Your dog's name is Lucy.
Your dog is 6 years old.
Lucy is now sitting.
即使给第二条小狗指定同样的名字和年龄，python 依然会根据 Dog 类创建另一个实例。你可以按需求根据一个类创建任意数量的实例，条件是将每个实例都存储在不同的变量中，或者占用列表或字典的不同位置。
使用类和实例
可使用类来模拟现实世界中的很多情景。类编写好后，你的大部分时间将花在根据类创建的实例上。你需要执行的一个重要任务时修改实例的属性。可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。
car 类
下面编写一个表示汽车的类。它存储了有关汽车的信息，还有一个汇总这些信息的方法：
>>> 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', 2019)
>>> print(my_new_car.get_descriptive_name())
2019 Audi A4
init()方法的第一个形参为 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()，指出我们拥有一辆什么样的汽车。
给属性指定默认值
创建实例时，有些属性无需通过形参来定义，可在方法 __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):
>>> """返回整洁的描述性信息。"""
>>> 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.")
>>>
>>> my_new_car = Car('audi', 'a4', 2019)
>>> print(my_new_car.get_descriptive_name())
>>> my_new_car.read_odometer()
2019 Audi A4
This car has 0 miles on it.
修改属性的值
我们能以三种方式修改属性的值：直接通过实例进行修改，通过方法进行设置，以及通过方法递增（增加特定的值)。
1. 直接修改属性的值
要修改属性的值，最简单的方式时通过实例直接访问它。下面的代码直接将里程表读数设置为23：
>>> my_new_car = Car('audi', 'a4', 2019)
>>> print(my_new_car.get_descriptive_name())
2019 Audi A4
>>> my_new_car.odometer_reading = 23
>>> my_new_car.read_odometer()
This car has 23 miles on it.
使用句点表示法可以直接访问并设置汽车的属性 odometer_reading。这行代码让 python 在实例 my_new_car 中找到属性 odometer_reading，并将其值设置为23。
有时候需要像这样直接访问属性，但其他时候需要编写对属性进行更新的方法。
2. 通过方法修改属性的值
如果有方法能替你更新属性，将大有裨益。这样就无须直接访问属性，而可将值传递给方法，由它在内部进行更新。
下面的示例演示了一个名为 update_odometer() 的方法：
>>> 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.update_odometer(23)
>>> my_new_car.read_odometer()
对 Car 类所做的唯一修改是添加了方法 update_odometer()。这个方法接受一个里程值，并将其赋给 self.odometer_reading。调用 update_odometer()，并向它提供了实参 23（该实参对应于方法定义中的形参 mileage。它将里程表读数设置为 23，而方法 read_odometer() 打印该读数。
可对方法 update_odometer() 进行扩展，使其在修改里程表读数时做些额外的工作。下面来添加一些逻辑，禁止任何人将里程表读数往回调：
>>> class Car:
>>> --snip--
>>> def update_odometer(self, mileage):
>>> """
>>> 将里程表读数设置为指定的值。
>>> 禁止将里程表读数往回调。
>>> """
>>> if self.odometer_reading <= mileage:
>>> self.odometer_reading = mileage
>>> else:
>>> print("You can't roll back an odometer!"
现在，update_odometer() 在修改属性前检查指定的读数是否合理，如果新制定的里程（mileage）大于或等于原来的里程（self.odometer_reading），就将里程表读数改为新指定的里程；否则发出警告，指出不能将里程表往回调。
3. 通过方法对属性的值进行递增
有时候需要将属性值递增特定的量，而不是将其设置为全新的值。假设我们购买了一辆二手车，且从购买到登记期间增加了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', 2015)
>>> print(my_used_car.get_descriptive_name())
2015 Subaru Outback
>>> my_used_car.update_odometer(23_500)
>>> my_used_car.read_odometer()
This car has 23500 miles on it.
>>> my_used_car.increment_odometer(100)
>>> my_used_car.read_odometer()
This car has 23600 miles on it.
新增的方法 increment_odometer() 接受一个单位为英里的数，并将其加入 self.odometer_reading 中。
注意 你可以使用类似于上面的方法来控制用户修改属性（如里程表读数）的方式，但能够访问程序的人都可以通过直接访问属性来将里程表修改为任何值。要确保安全，除了进行类似于前面的基本检查外，还需特别注意细节。
继承
编写类时，并非总是要从空白开始。如果要编写的类是另一个现成类的特殊版本，可使用继承。一个类继承另一个类时，将自动获得另一个类的所有属性和方法。原有的类称为父类，而新类称为子类。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。
子类的方法 __init__()
在既有类的基础上编写新类时，通常要调用父类的方法 __init__()。这将初始化在父类 __init__() 方法中定义的所有属性，从而让子类包含这些属性。例如，下面来模拟电动汽车。电动汽车是一种特殊的汽车，因此可在前面创建的 Car 类的基础上创建新类 ElectricCar。这样就只需为电动汽车特有的属性和行为编写代码。
下面来创建 ElectricCar 类的一个简单版本，它具备 Car 类的所有功能：
>>> 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_tesla = ElectricCar('tesla', 'model s', 2019)
>>> print(my_tesla.get_descriptive_name)
2019 Tesla Model S
首先是 Car 类的代码。创建子类时，父类必须包含在当前文件夹中，且位于子类前面。定义 ElectricCar 子类时，必须在圆括号内指定父类的名称。方法 __init__() 接受创建 Car 实例所需的信息。
suer() 是一个特殊函数，让你能够调用父类的方法。这行代码让 python 调用 Car 类的方法 __init__() ，让 ElectricCar 实例包含这个方法中定义的所有属性。父类也称为超类 super(class)，名称 super 由此而来。
为测试继承能够正确地发挥作用，我们尝试创建一辆电动汽车，但提供的信息与创建普通汽车时相同。创建 ElectricCar 类的一个实例，并将其赋给变量 my_tesla。这行代码调用 ElectricCar 类中定义的方法 __init__()，后者让 python 调用父类 Car 中定义的方法 __init__()。我们提供了参数 ‘tesla’、’model s‘ 和 2019。
给子类定义属性和方法
让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。
下面来添加一个电动汽车特有的属性（电瓶），以及一个描述该属性的方法。我们将存储电瓶容量，并编写一个打印电瓶描述的方法：
>>> 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）。根据 ElectricCar 类创建的所有实例都将包含该属性，但所有 Car 实例都不包含它。还添加了一个名为 descriptive_battery() 的方法，打印有关电瓶的信息。调用这个方法时，将看到一条电动汽车特有的描述：
2019 Tesla Model S
This car has a 75-kWh battery.
对于 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:
>>> --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.")
>>>
>>> class ElectricCar(Car):
>>> """电动车的独特之处。"""
>>>
>>> def __init__(self, make, model, year):
>>> """
>>> 初始化父类的属性。
>>> 再初始化电动汽车特有的属性。
>>> """
>>> super().__init__(make, model, year)
>>> self.battety = Battery()
>>>
>>> my_tesla = ElectricCar('tesla', 'model s', 2019)
>>> print(my_tesla.get_descriptive_name())
2019 Tesla Model S
>>> my_tesla.battery.describe_battery()
This car has a 75-kWh battery.
本例中定义了一个名为 Battery 的新类，它没有继承任何类。Battery 类中除了 self 外，还有另外一个形参 battery_size。这个形参是可选的：如果没有给它提供值，电瓶容量将被设置为 75。方法 describe_battery() 也已到了这个类中。
在 ElectricCar 类中，添加了一个名为 self.battery 的属性。这行代码让 python 创建一个新的 Battery 实例（因为没有指定容量，所以默认值 75），并将该实例赋给属性 self.battery。每当方法 __init__() 被调用时，都将执行该操作，因此现在每个 ElectricCar 实例都包含一个自动创建的 Battery 实例。
我们创建一辆电动汽车，并将其赋给变量 my_tesla。描述电瓶时，需要使用电动汽车的属性 battery：
my_tesla.battery.describe_battery()
这行代码让 python 在实例 my_tesla 中查找属性 battery，并对存储在该属性中的 Battery 实例调用方法 describe_battery()。
这看似做了很多额外的工作，但是现在想多详细地描述电瓶都可以，且不会导致 ElectricCar 类混乱不堪。下面再给 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', 'models s', 2019)
>>> print(my_tesla.get_descriptive_name())
>>> my_tesla.battery.describe_battery()
>>> my_tesla.battery.get_range()
如果电瓶的容量为 75-kWh，就将续航里程设置为 260 英里；如果容量为 100-kWh，就将续航里程设置为315英里，然后报告这个值。为使用这个方法，也需要通过汽车的属性 battery 来调用。
模拟实物
模拟较复杂的物件（如电动汽车）时，需要解决一些有趣的问题。续航里程时电瓶的属性还是汽车的属性？如果只描述一辆汽车，将方法 get_range() 放在 Battery 类中也许是合适的，但如果要描述一家汽车制造商的整个产品线，也许应该将方法 get_range() 移到 ElectricCar 类中。在这种情况下，get_range() 依然根据电瓶容量来确定续航里程，但报告的是一款汽车的续航里程。也可以这样做：仍将方法 get_range() 留在 Battery 类中，但向它传递一个参数，如 car_model。在这种情况下，方法 get_range() 将根据电瓶容量和汽车型号报告续航里程。
这让你进入了程序员的另一个境界：解决上述问题时，从较高的逻辑层面（而不是语法层面）考虑；考虑的不是 python，而是如何使用代码来表示实物。达到这种境界后，你会经常发现，对现实世界的建模方法没有对错之分。有些方法的效率更高，但要找出效率最高的表示法，需要经过一定的实践。只要代码像你希望的那样运行，就说明你做的很好！
导入类
随着不断给类添加功能，文件可能变得很长，即便妥善地使用了继承亦是如此。为遵循 python 总体理念，应让文件尽可能整洁。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.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 on 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()
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()
现在可以创建一个名为 my_electric_car.py 的文件，导入 ElectricCar 类，并创建一辆电动汽车了：
>>> from car import ElectricCar
>>> my_tesla = ElectricCar('tesla', 'model s', 2019)
>>> print(my_tesla.get_descriptive_name())
2019 Tesla Model S
>>> my_tesla.battery.describe_battery()
This car has a 75-kWh battery.
>>> my_tesla.battery.get_range()
This car can go about 260 miles on a full charge.
输出与我们前面看到的相同，但大部分逻辑隐藏在一个模块中。
从一个模块中导入多个类
可根据需要在程序文件夹中导入任意数量的类。如果要在同一个程序中创建普通汽车和电动汽车，就需要将 Car 类和 ElectricCar 类都导入：
>>> from car import Car, ElectricCar
>>> my_bettle = Car('volkswagen', 'beetle', 2019)
>>> print(my_bettle.get_descriptive_name())
>>> my_tesla = Electric('tesla', 'roadster', 2019)
>>> print(my_tesla.get_desctiptive_name())
从一个模块中导入多个类时，用逗号分隔了各个类。导入必要的类后，就可根据需要创建每个类的任意数量实例。
导入整个模块（推荐）
还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方式很简单，代码也易于阅读。因为创建类实例的代码都包含模块名，所以不会与当前文件使用的任何名称发生冲突。
下面的代码导入整个 car 模块，并创建一辆普通汽车和一辆电动汽车：
>>> import car
>>> my_bettle = car.Car('volkswagen', 'bettle', 2019)
>>> print(my_bettle.get_descriptive_name())
>>> my_tesla = car.ElectricCar('tesla', 'roadster', 2019)
>>> print(my_tesla.get_descriptive_name())
先导入整个 car 模块，接下来，使用语法 module.Classname 访问需要的类。
导入模块中的所有类（不推荐使用）
要导入模块中的每个类，可使用下面的语法：
from module_name import *
不推荐使用这种导入方式，原因有二。第一，如果只看文件开头的 import 语句，就能清楚地知道程序使用了哪些类，将大有裨益。然而这种导入方式没有明确地指出使用了模块中的哪些类。第二，这种方式还可能引发名称方面的迷惑。如果不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐使用，但你可能在别人编写的代码中见到它。
需要从一个模块中导入很多类时，最好导入整个模块，并使用 module_name.ClassName 语法来访问。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道程序的哪些地方使用了导入的模块。这也避免了导入模块中的每个类可能引发的名称冲突。
在一个模块中导入另一个模块
有时候，需要将类分散到多个模块中，以免模块太大或在同意模块中存储不相关的类。将类存储再多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。
下面将 Car 类存储在一个模块中，并将 ElectricCar 类和 Battery 类存储在另一个模块中。将第二个模块命名为 electric_car.py，并将 Battery 类和 ElectricCar 类复制到这个模块中：
from car import Car
class Battery:
--snip--
class Electric(Car):
--snip--
ElectricCar 类需要访问其父类 Car，因此直接将 Car 类导入该模块中。如果忘记了这行代码，python 将在我们试图创建 ElectricCar 实例时引发错误。还需要更新模块 car，使其只包含 Car 类：
"""一个可用于表示汽车的类。"""
class Car:
--snip--
现在可以分别从每个模块中导入类，可以根据需要创建任何类型的汽车了：
from car import Car
from electric_car import ElectricCar
my_bettle = Car('volkswagen', 'beetle', 2019)
print(my_bettle.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2019)
print(my_tesla.get_descriptive_name())
使用别名
导入类时，也可为其指定别名。例如，要在程序中创建大量电动汽车实例，需要反复输入 ElectricCar，非常繁琐。为避免这种烦恼，可在 import 语句中给 ElectricCar 指定一个别名：
from electric_car import ElectricCar as EC
现在每当需要创建电动汽车实例时，都可使用这个别名：
my_tesla = EC('tesla', 'roadster', 2019)
自定义工作流程
如你所见，在组织大型项目的代码方面，python 提供了很多选项。熟悉所有这些选项很重要，这样你才能确定哪种项目组织方式是最佳的，并能理解别人开发的项目。
一开始应让代码结构尽可能简单。先尽可能在一个文件中完成所有的工作，确定一切都能正常运行后，再将类移到独立的模块中。如果你喜欢模块和文件的交互方式，可在项目开始时久长时将类存储到模块中。先找出让你能够写出可行代码的方式，再尝试改进代码。
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，但该模块可以很好地用于创建众多有趣的项目。
类编码风格
你必须书写有些与类相关的编码风格问题，在编写的程序比较复杂时尤其如此。
类名应采用驼峰命名法，即将类名中的每个单词和首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应该包含一个文档字符串，对其中的类可用于做什么进行描述。
可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。
需要同时导入标准库中的模块和你编写的模块时，先编写标准库模块的 import 语句，再添加一个空行，然后编写导入你自己编写的模块的 import 语句。在包含多条 import 语句的程序中，这种做法让人更容易明白程序的各个模块都来自何处。
|