Python - 类

这节将带你了解面向对象编程。

1. 创建和使用类

1.1 创建Dog 类        

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

❶ class Dog(): 
❷     """一次模拟小狗的简单尝试"""
❸     def __init__(self, name, age):
          """初始化属性name和age""" 
❹         self.name = name
          self.age = age
❺     def sit(self):
          """模拟小狗被命令时蹲下"""
          print(self.name.title() + " is now sitting.")
      def roll_over(self):
          """模拟小狗被命令时打滚"""
          print(self.name.title() + " rolled over!")

类中的函数称为方法 ；你前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。❸处的方法__init__() 是一个特殊的方法，每当你根 据Dog 类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

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

1.2 根据类创建实例

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

#基于1.1创建的Dog类
class Dog():
    --snip--
my_dog = Dog('willie', 6)

print("My dog's name is " + my_dog.name.title() + ".") 
print("My dog is " + str(my_dog.age) + " years old.")

1.2.1 访问属性

前面我们创建了一个实例my_dog，现在我们用这个实例来访问属性name。

my_dog.name

1.2.2 访问方法

class Dog():
    --snip--

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


结果：
Willie is now sitting.
Willie rolled over!

注：实例可以创建多个。

2. 使用类和实例

编写一个Car类，它存储了有关汽车的信息，还有一个汇总这些信息的方法，根据Car 类创建了一个实例，并将其存储到变量my_new_car中。接下来，我们调用方法get_descriptive_name() ，指出我们拥有的是一辆什么样的汽车：

class Car():
"""一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
    """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
    def get_descriptive_name(self):
    """返回整洁的描述性信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

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


结果：
2016 Audi A4

2.1 给属性指定默认值

在Car类中来添加一个名为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("This car has " + str(self.odometer_reading) + " miles on it.")

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


结果：
2016 Audi A4
This car has 0 miles on it.

2.2 修改属性的值

实际上，出售时里程表读数为0的汽车并不多，因此我们需要一个修改该属性的值的途径。

2.2.1 直接修改属性的值

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

class Car():
    --snip--

my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()


结果：
2016 Audi A4
This car has 23 miles on it.

2.2.2 通过方法修改属性的值

如果有替你更新属性的方法，将大有裨益。这样，你就无需直接访问属性，而可将值传递给一个方法，由它在内部进行更新。 下面的示例演示了一个名为update_odometer() 的方法：

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

my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23)
my_new_car.read_odometer()


结果：
2016 Audi A4
This car has 23 miles on it.

3. 继承

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

3.1 子类的方法__init__()

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__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 = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()
    def read_odometer(self):
        print("This car has " + str(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', 2016)
print(my_tesla.get_descriptive_name())


结果：
2016 Tesla Model S

注：创建子类时，父类必须包含在当前文件中，且位于子类前面。定义子类时，必须在括号内指定父类的名称。super() 是一个特殊函数，帮助Python将父类和子类关联起来。

3.2 给子类定义属性和方法

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

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

class Car():
    --snip--
class ElectricCar(Car):
    """Represent aspects of a car, specific to electric vehicles."""
    def __init__(self, make, model, year):
    """ 电动汽车的独特之处
    初始化父类的属性，再初始化电动汽车特有的属性
    """
        super().__init__(make, model, year) 
        self.battery_size = 70
    def describe_battery(self):
    """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

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


结果：
2016 Tesla Model S
This car has a 70-kWh battery.

3.3 重写父类的方法

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

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

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

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

3.4 将实例用作属性

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

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

class Car():
    --snip--
class Battery():
"""一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=70):
    """初始化电瓶的属性"""
        self.battery_size = battery_size
    def describe_battery(self):
    """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")
class ElectricCar(Car):
"""电动汽车的独特之处"""
    def __init__(self, make, model, year):
    """ 初始化父类的属性，再初始化电动汽车特有的属性"""
        super().__init__(make, model, year) ❹ self.battery = Battery()

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


结果：
2016 Tesla Model S
This car has a 70-kWh battery.

我们定义了一个名为Battery 的新类，它没有继承任何类，方法__init__() 除self 外，还有另一个形参battery_size 。这个形参是可选的：如果没有给 它提供值，电瓶容量将被设置为70。方法describe_battery() 也移到了这个类中。在ElectricCar 类中，我们添加了一个名为self.battery 的属性，这行代码让Python创建一个新的Battery 实例（由于没有指定尺寸，因此为默认值70 ），并将 该实例存储在属性self.battery 中。每当方法__init__() 被调用时，都将执行该操作；因此现在每个ElectricCar 实例都包含一个自动创建的Battery 实例。

4. 导入类

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

4.1 导入单个类

# car.py文件

class Car():
    --snip--

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

# my_car.py文件

from car import Car
# import 语句让Python打开模块car ，并导入其中的Car 类。这样我们就可以使用Car 类了，就像它是在这个# 文件中定义的一样。
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

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

# car.py文件

class Car():
    --snip--
class Battery():
    --snip--
class ElectricCar(Car):
    --snip--
# 可根据需要在程序文件中导入任意数量的类。如果我们要在同一个程序中创建普通汽车和电动汽车，就需要将
# Car 和ElectricCar 类都导入：

# my_cars.py文件

from car import Car, ElectricCar

5. 类编码风格

类名应采用驼峰命名法 ，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文 档字符串，对其中的类可用于做什么进行描述。

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

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