Python编程：从入门到实践（学习笔记-Charpter 9)

Python编程：从入门到实践（学习笔记-Charpter 9)

十月 17, 2019

Chapter 9 : 类

9.1创建和使用类

9.1.1创建Dog类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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!")

这里需要注意的地方很多，但你也不用担心，本章充斥着这样的结构，你有大把的机会熟悉它。在❶处，我们定义了一个名为 Dog 的类。根据约定，在 Python 中，首字母大写的名称指的是类。这个类定义中的括号是空的，因为我们要从空白创建这个类。在❷处，我们编写了一个文档字符串，对这个类的功能作了描述。

  1. 方法 __init__()

类中的函数称为方法

❸处的方法__init__()是一个特殊的方法，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

将方法__init__()定义成了包含三个参数：self、name和age。形参self必不可少，还必须位于其他形参的前面，Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self，每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。每当我们根据Dog类创建实例时，都需要给最后两个形参（ name 和 age ）提供值。

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

Dog定义了另外两个方法：sit( )和roll_over().由于这些地方不需要额外的信息，如名字或年龄，因此他们只有一个形参self。

9.1.2根据类创建实例
1
2
3
4
5
6
7
8
9
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.访问属性

要访问实例的属性，需要用句点表示法

1
2
3
my_dog.name

#句点表示法在 Python 中很常用,这种语法演示了 Python 如何获悉属性的值。在这里, Python 先找到实例 my_dog ,再查找与这个实例相关联的属性 name 。在 Dog 类中引用这个属性时,使用的是 self.name 。在❸处,我们使用同样的方法来获取属性 age 的值。在前面的第 1 条 print 语句中, my_dog.name.title() 将my_dog 的属性 name 的值 'willie' 改为首字母大写的;在第 2 条 print 语句中, str(my_dog.age) 将 my_dog 的属性 age 的值 6 转换为字符串。

2.调用方法 

1
2
3
4
5
6
7
8
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() 。

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

3.创建多个实例

1
2
3
4
5
6
7
8
9
10
11
12
13
class Dog():
    --snip--
    
my_dog = Dog('willie', 6)
your_dog = Dog('lucy', 3)

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

print("your dog's name is " + your_dog_name.title() + ".")
print("Your dog is " + str(your_dog.age) + " years old.")
your_dog.sit()

9.2使用类和实例

类编写好后，你的大部分时间都将花在使用根据类创建的实例上。你需要执行的一个重要任务是修改实例的属性，你可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。

9.2.1 Car类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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())
        
#在❶处,我们定义了方法 __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()，指出我们拥有的是一辆什么样的汽车:

2016 Audi A4
9.2.2给属性指定默认值

类的每个属性都必须有初始值，这个值可以是0或者空字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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('sudi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

#现在,当 Python 调用方法 __init__() 来创建新实例时,将像前一个示例一样以属性的方式存储制造商、型号和生产年份。接下来, Python 将创建一个名为 odometer_reading 的属性,并将其初始值设置为 0 (见❶)。在❷处,我们还定义了一个名为 read_odometer() 的方法,它让你能够轻松地获悉汽车的里程。
9.2.3 修改属性值

三种方式修改属性值：

  • 直接通过实例进行修改
  • 通过方法进行修改设置
  • 通过方法进行递增（增加特定的值）
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#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  #使用句点表示法直接访问并设置汽车的属性odometer_reading
my_new_car.read_odometer()

#2.通过方法修改属性的值
   #无需直接访问属性，而可将值传递给一个方法，由它在内部进行更新
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) 
	#调用了update_odometer(),并向它提供了实参23（实参对应于方法定义中的形参mileage)
my_new_car.read_odometer()

    #对方法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！")
            
#3.通过方法对属性的值进行递增
    #假设购买了一辆二手车，且从购买到登记期间增加了100英里的里程，下面的方法让我们能够传递这个增量
    
class Car():
    --snip--
    
    def update_odometer(self, mileage):
        --snip--
        
    def increment_odometer(self, miles):  
        #新增的方法increment_odometer()接受一个单位为英里的数字，存储到self.odometer_reading
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles
        
my_used_car = Car('subaru', 'outback', 2013)  #创建一个二手车
print(my_used_car.get_descriptive_name())

my_used_car.update_odometer(23500)      #调用方法update_odometer(),并传入23500
my_used_car.read_odometer()

my_used_car.increament_odometer(100)    #调用increment_odometer(), 并传入100
my_used_car.read_odometer()

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

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

9.3 继承

编写类时，并非总要从空白开始，如果你要编写的类是另一个现成类的特殊版本，可以使用继承

一个类继承另一类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类

子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

9.3.1 子类的方法__ init__()
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
34
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)    #super()将父类和子类关联起来，父类（超类）

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
9.3.3给子类定义属性和方法
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
#添加一个电动汽车特有的属性（电瓶），以及一个描述该属性的方法
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()

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

#如果一个属性或方法是任何汽车都有的，而不是电动汽车特有的，就应将其加入到Car类而不是ElectricCar类中
9.3.4 重写父类的方法

对于父类的方法，只有它不符合子类模拟的实物的行为，都可对其进行重写，为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。

1
2
3
4
5
6
7
#使用继承时，可让子类保留从父类那里继承而来的精华，并剔除不需要的糟粕。
def ElectricCar(Car):
    --snip--
    
    def fill_gas_tank():
        """电动汽车没有油箱"""
        print("This car doesn't need a gas tank!")
9.3.5 将实例用作属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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()                    #❹
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
class Car():
    --snip--
    
class Battery():
    --snip--
    
   def get_range(self):     #❶
    """ 打印一条消息,指出电瓶的续航里程 """
    if self.battery_size == 70:
        range = 240
    elif self.battery_size == 85:
        range = 270
    
    message = "This car can go approximately " + str(range)
    message += " miles on a full charge."
    print(message)
    
class ElectricCar(Car):
--snip--

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

#❶处新增的方法get_range()做了一些简单的分析:如果电瓶的容量为70kWh，它就将续航里程设置为240英里；如果容量为85kWh，就将续航里程设置为270英里，然后报告这个值。为使用这个方法,我们也通过汽车的属性 battery 来调用它(见❷)。
9.3.6 模拟实物 （略）

9.4 导入类

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

car.py (包含了一个模块级文档字符串，对该模块的内容做了简要的描述)

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
34
""" 一个可用于表示汽车的类 """

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

my_car.py

1
2
3
4
5
6
7
8
9
from car import 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()

# import 语句让 Python 打开模块 car ,并导入其中的 Car 类。
9.4.2 在一个模块中存储多个类

car.py

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
34
""" 一组用于表示燃油汽车和电动汽车的类 """
class Car():
    --snip--
class Battery():
    """ 一次模拟电动汽车电瓶的简单尝试 """
    
    def __init__(self, battery_size=60):
        """ 初始化电瓶的属性 """
        self.battery_size = battery_size
        
    def describe_battery(self):
        """ 打印一条描述电瓶容量的消息 """
        print("This car has a " + str(self.battery_size) + "-kWh battery.")
        
    def get_range(self):
        """ 打印一条描述电瓶续航里程的消息 """
        if self.battery_size == 70:
            range = 240
        elif self.battery_size == 85:
            range = 270
            
            message = "This car can go approximately " + str(range)
            message += " miles on a full charge."
            print(message)
            
class ElectricCar(Car):
    """ 模拟电动汽车的独特之处 """
    
    def __init__(self, make, model, year):
        """
        初始化父类的属性,再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)
        self.battery = Battery()

my_electric_car.py (可以新建一个名为 my_electric_car.py 的文件,导入 ElectricCar 类,并创建一辆电动汽车了)

1
2
3
4
5
6
7
from car import ElectricCar

my_tesla = ElectricCar('tesla', 'model s', 2016)

print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
9.4.3 从一个模块中导入多个类

my_cars.py

1
2
3
4
5
6
7
8
9
from car import Car, ElectricCar

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

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

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

my_cars.py

1
2
3
4
5
6
7
8
9
10
11
12
13
#可以导入整个模块,再使用句点表示法访问需要的类
#❶
import car

#❷ 
my_beetle = car.Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())

#❸ 
my_tesla = car.ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())

#在❶处,我们导入了整个 car 模块。接下来,我们使用语法 module_name.class_name 访问需要的类。像前面一样,我们在❷处创建了一辆大众甲壳虫汽车,并在❸处创建了一辆特斯拉 Roadster 汽车。
9.4.5 导入模块中的所有类
1
2
3
4
5
from module_name import *

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

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

electric_car.py

1
2
3
4
5
6
7
8
9
""" 一组可用于表示电动汽车的类 """

from car import Car

class Battery():
    --snip--
    
class ElectricCar(Car):
    --snip--

car.py

1
2
3
""" 一个可用于表示汽车的类 """
class Car():
    --snip--

my_cars.py

1
2
3
4
5
6
7
8
from car import Car
from electric_car import ElectricCar

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

my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())
9.4.7 自定义工作流程

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

9.5 Python 标准库

https://pymotw.com/3/ 资源

Python标准库 是一组模块，可以使用其他程序员编写好的模块，想要使用标准库中的任何函数和类，只需在程序开头包含一条简单的import语句，下面来看模块collections中的一个类——OrderedDict。

字典能够将信息关联起来，但不记录添加键—值对的顺序，要创建字典并记录其中的键——值对的添加顺序，可使用模块collections 中的OrderedDict类，OrderedDict实例的行为几乎与字典相同，区别只在于记录了键——值对的添加顺序。

OrderedDict类:它兼具列表和字典的主要优点（在将信息关联起来的同时保留原来的顺序）

1
2
3
4
5
6
7
8
9
10
from collections import OrderedDict

favorite_language['jen'] = 'python'
favorite_language['sarah'] = 'c'
favorite_language['edward'] = 'ruby'
favorite_language['phil'] = 'python'

for name, language in favorite_language.items():
    print(name.title() + "'s favorite language is " + 
         language.title() + ".")

9.6类编码风格

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

  • 驼峰命名法：即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
  • 对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
  • 可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔
  • 需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import语句，再添加一个空行，然后编写导入你自己编写的模块的import语句。在包含多条import语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。