第9章 类

9.1 创建和使用类

9.1.1 创建 Dog 类

类中的函数称为方法，前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。

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

    def sit(self):
        print(f"{self.name} is now sitting.")
1
2
3
4
5
6
7

9.1.2 根据类创建实例

1. 访问属性
2. 调用方法
3. 创建多个实例

mydog = Dog('zhouzhou', 3)  # 创建实例
print(f"{mydog.name} is {mydog.age} years old.")  # 访问属性
mydog.sit()  # 调用方法
herdog = Dog('maomao', 5)  # 创建多个实例
herdog.sit()  # 调用方法
1
2
3
4
5

9.2 使用类和实例

9.2.1 Car 类

编写一个表示汽车的类。它存储了有关汽车的信息，还有一个汇总这些信息的方法。

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def description(self):
        print(f"{self.make} {self.model} {self.year}")


mycar = Car(2024, 'Au', 'A7')  # 创建实例
mycar.description()
1
2
3
4
5
6
7
8
9
10
11
12

9.2.2 给属性指定默认值

创建实例时，有些属性无须通过形参来定义，可在方法__init__()中为其指定默认值。

9.2.3 修改属性的值

1. 直接修改属性的值
2. 通过方法修改属性的值
3. 通过方法对属性的值进行递增

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer = 0  # 给属性指定默认值

    def description(self):
        print(f"{self.make} {self.model} {self.year}")

    def read_odometer(self):
        print(f"This car has {self.odometer} miles on it.")

    def update_odometer(self, mile):  # 通过方法修改属性的值
        self.odometer = mile

    def add_odometer(self, miles):  # 通过方法对属性的值递增
        self.odometer += miles


mycar = Car(2024, 'Au', 'A7')  # 创建实例
mycar.description()  # 2024 Au A7
mycar.read_odometer()  # This car has 0 miles on it.
# 1、直接修改属性的值
mycar.odometer = 20
mycar.read_odometer()  # This car has 20 miles on it.
# 2、通过方法修改属性的值
mycar.update_odometer(30)
mycar.read_odometer()  # This car has 30 miles on it.

# 3、通过方法对属性的值递增
mycar.add_odometer(5)
mycar.read_odometer()  # This car has 35 miles on it.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

9.3 继承

9.3.1 子类的方法__init__()

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

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def description(self):
        print(f"{self.make} {self.model} {self.year}")


class ElectricCar(Car):  # 继承Car
    def __init__(self, make, model, year):
        super().__init__(make, model, year)

mycar = ElectricCar(2024, 'Au', 'A7')  # 创建实例
mycar.description()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

创建子类时，父类必须包含在当前文件中，且位于子类前面。定义子类ElectricCar时，必须在圆括号里指定父类的名称Car。

9.3.2 给子类定义属性和方法

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

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def description(self):
        print(f"{self.make} {self.model} {self.year}")
        
class ElectricCar(Car):  # 继承Car
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery = 85  # 新属性

    def prt_battery(self):
        print(f"{self.battery}%")

mycar = ElectricCar(2024, 'Au', 'A7')  # 创建实例
mycar.description()
mycar.prt_battery()  # 新方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

9.3.3 重写父类的方法

在子类中定义一个与要重写的父类方法同名的方法。

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def description(self):
        print(f"{self.make} {self.model} {self.year}")


class ElectricCar(Car):  # 继承Car
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery = 85

    def description(self):
        print(f"{self.make} {self.model} {self.year} {self.battery}")


mycar = ElectricCar(2024, 'Au', 'A7')  # 创建实例
mycar.description()  # 2024 Au A7 85

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

9.3.4 将实例用作属性

将类的一部分提取出来，作为一个独立的类。

9.3.5 模拟实物

解决问题时，从较高的逻辑层面考虑，考虑的不是 Python，而是如何使用代码来表示实物。

9.4 导入类

9.4.1 导入单个类

通过将这个类移到一个模块中并导入该模块，依然可以使用所有功能，但主程序文件变得整洁
而易于阅读了。
创建一个只包含Car类的模块，并命名为car.py。
然后创建另一个文件my_car.py，在其中导入Car类并创建实例。

from car import Car
my_car = Car(2024, 'Au', 'A7')  # 创建实例
my_car.description()
1
2
3

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

虽然同一个模块中的类之间应存在相关性，但可根据需要在一个模块中存储任意数量的类。

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

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

from car import Car, ElectricCar
1

9.4.4 导入整个模块

可以导入整个模块，再使用句点表示法访问需要的类。

import car
my_car = car.ElectricCar('tesla', 'r', 2024)
1
2

9.4.5 导入模块中的所有类

需要从一个模块中导入很多类时，最好导入整个模块 。

from module_name import *
1

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

将类分散到多个模块中，以免模块太大或在同一个模块中存储不相关的类。

9.4.7 使用别名

导入类时，也可为其指定别名。

9.4.8 自定义工作流程

熟悉Python 提供的选项，这样才能确定哪种组织方式是最佳的，并能理解别人开发的项目。

9.5 Python 标准库

类名应采用驼峰命名法.
每个类，都应紧跟在类定义后面包含一个文档字符串。
可使用空行来组织代码，但不要滥用。
需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的 import 语句

9.6 类编码风格

Python 标准库是一组模块，我们安装的 Python 都包含它。
可以使用标准库中的任何函数和类，只需在程序开头包含一条简单的 import 语句即可。