python学习要点2

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__(): 每当根据类创建新实例时，Python会自动运行它，方法的名称中，开头和末尾各有两个下划线，这是一种约定，包含三个参数，self必不可少，还必须位于其它形参的前面。
通常可以认为首字母大写的名称指的是类，而小写的名称指的是根据类创建的事例。
访问属性
要访问实例的属性，可使用句点表示法。

9.2 使用类和实例

9.2.2 给属性指定默认值

类中的每个属性都必须有初始值，

9.2.3 修改属性的值

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

9.3 继承

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__init__()需要父类施以援手。
super().init();

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

9.3.3 给子类定义属性和方法

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

9.3.4 重写父类的方法

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

9.3.5 将实例用作属性

当类的属性和方法清单越来越多时，可能需要将类的一部分作为一个独立的类提取出来。

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

9.4 导入类

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

文档包含了一个模块级文档字符串，对该模块的内容做了简要的描述。应该为自己创建的每个模块都编写文档字符串
my_car.py

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

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

car.py

"""一组用于表示燃油汽车和电动汽车的类"""
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的文件，导入 ElectricCar 并创建一辆电动汽车了：
my_electric_car.py

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

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 导入整个模块

你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方法很简单，代码也易于阅读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称发生冲突。下面的代码导入整个 car 模块，并创建一辆普通汽车和一辆电动汽车：
my_cars.py

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

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

有时候，需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类。将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。
例如，下面将 Car 类存储在一个模块中，并将 ElectricCar 和 Battery 存储在另一个模块中。
我们将第二个模块命名为 electric_car.py （这将覆盖前面创建的文件 electric_car.py ），并将Battery 和 ElectricCar 类复制到这个模块中：
electric_car.py

"""一组可用于表示电动汽车的类"""
from car import Car
class Battery():
    -- snip --
class ElectricCar(Car):
    -- snip --

ElectricCar 类需要访问其父类 Car ，因此，我们直接将 Car 类导入该模块中。如果我们忘记了这行代码，Python将在我们试图创建 ElectricCar实例时引发错误。我们还需要更新模块car ，使其包含 Car 类：
car.py

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

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

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.6 类编码风格

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

第10章文件和异常

10.1 从文件中读取数据

10.1.1 读取整个文件

pi_digits.txt

3.1415926535
8979323846
2643383279

ile_reader.py

with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents)

关键字 with 在不再需要访问文件后将其关闭。在这个程序中，注意到我们调用了 open() ，但没有调用 close() ；你也可以调用 open() 和 close() 来打开和关闭文件，但这样做时，如果程序存在bug，导致 close() 语句未执行，文件将不会关闭。这看似微不足道，但未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用 close() ，你会发现需要使用文件时它已关闭（无法访问），这会导致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时机，但通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。
相比于原始文件，该输出唯一不同的地方是末尾多了一个空行。为何会多出这个空行呢？因为 read() 到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除多出来的空行，可在 print 语句中使用 rstrip() ：

with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents.rstrip())

本书前面说过，Python方法 rstrip() 删除（剥除）字符串末尾的空白。

10.1.2 文件路径

由于文件夹text_files位于文件夹python_work中，因此可使用相对文件路径来打开该文件夹中的文件。相对文件路径让Python到指定的位置去查找，而该位置是相对于当前运行的程序所在目录的。
这行代码让Python到文件夹python_work下的文件夹text_files中去查找指定的.txt文件。在Windows系统中，在文件路径中使用反斜杠（ \ ）而不是斜杠（ / ）：
with open('text_files\ filename .txt') as file_object:
绝对路径通常比相对路径更长，因此将其存储在一个变量中，再将该变量传递给 open() 会有所帮助。在Linux和OS X中，绝对路径类似于下面这样：

file_path = '/home/ehmatthes/other_files/text_files/ filename .txt'
with open(file_path) as file_object:

而在Windows系统中，它们类似于下面这样：

file_path = 'C:\Users\ehmatthes\other_files\text_files\ filename .txt'
with open(file_path) as file_object:

10.1.3 逐行读取

file_reader.py
filename = ‘pi_digits.txt’
with open(filename) as file_object:
for line in file_object:
print(line)

为何会出现 空白行呢？因为在这个文件中，每行的末尾都有一个看不见的换行符，而print 语句也会加上一个换行符，因此每行末尾都有两个换行符：一个来自文件，另一个来自 print语句。要消除这些多余的空白行，可在 print 语句中使用 rstrip() ：

filename = ‘pi_digits.txt’
with open(filename) as file_object:
for line in file_object:
print(line.rstrip())

#### 10.1.4 创建一个包含文件各行内容的列表
使用关键字 with 时， open() 返回的文件对象只在 with 代码块内可用。如果要在 with 代码块外访问文件的内容，可在 with 代码块内将文件的各行存储在一个列表中，并在 with 代码块外使用该列表：你可以立即处理文件的各个部分，也可推迟到程序后面再处理。
下面的示例在 with 代码块中将文件pi_digits.txt的各行存储在一个列表中，再在 with 码块外
打印它们：

filename = ‘pi_digits.txt’
with open(filename) as file_object:
lines = file_object.readlines()
for line in lines:
print(line.rstrip())

方法 readlines() 从文件中读取每一行，并将其存储在一个列表lines 中；在 with 代码块外，我们依然可以使用这个变量。我们使用一个简单的 for 循环来打印 lines 中的各行。由于列表 lines 的每个元素都对应于文件中的一行，因此输出与文件内容完全一致。
#### 10.1.5 使用文件的内容
注意 读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并要将其作为数值使用，就必须使用函数 int() 将其转换为整数，或使用函数 float() 将其转换为浮点数。
注意 要运行这个程序（以及后面的众多示例），你需要从https://www.nostarch.com/pythoncra-shcourse/下载相关的资源
#### 10.1.7 圆周率值中包含你的生日吗
我一直想知道自己的生日是否包含在圆周率值中。下面来扩展刚才编写的程序，以确定某个人的生日是否包含在圆周率值的前1 000 000位中。为此，可将生日表示为一个由数字组成的字符串，再检查这个字符串是否包含在 pi_string 中：

filename = ‘pi_million_digits.txt’
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = ‘’
for line in lines:
pi_string += line.rstrip()
birthday = input("Enter your birthday, in the form mmddyy: ")
if birthday in pi_string:
print(“Your birthday appears in the first million digits of pi!”)
else:
print(“Your birthday does not appear in the first million digits of pi.”)

### 10.2 写入文件
#### 10.2.1 写入空文件
将一条信息存储到文件中

filename = ‘programming.txt’
with open(filename, ‘w’) as file_object:
file_object.write(“I love programming.”)

调用 open() 时提供了两个实参。第一个实参也是要打开的文件的名称；第二个实参（ 'w' ）告诉Python，我们要以写入模式打开这个文件。打开文件时，可指定读取模式（ 'r' ）、写入模式（ 'w' ）、附加模式（ 'a' ）或让你能够读取和写入文件的模式（ 'r+' ）。如果你省略了模式实参，Python将以默认的只读模式打开文件。
如果你要写入的文件不存在，函数 open() 将自动创建它。然而，以写入（ 'w' ）模式打开文
件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。

**注意 Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数
str() 将其转换为字符串格式。**
#### 10.2.2 写入多行
函数write()不会再写入的文本末尾添加换行符。要让每个字符串都单独占一行，需添加：

file_obj.write(’\n’)

#### 10.2.3 附加到文件
如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。
下面来修改write_message.py，在既有文件programming.txt中再添加一些你酷爱编程的原因：
write_message.py

filename = ‘programming.txt’
with open(filename, ‘a’) as file_object:
file_object.write(“I also love finding meaning in large datasets.\n”)
file_object.write(“I love creating apps that can run in a browser.\n”)

### 10.3 异常
10.3 异常
Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知
所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行；
如果你未对异常进行处理，程序将停止，并显示一个traceback，其中包含有关异常的报告。
异常是使用 try-except 代码块处理的。 try-except 代码块让Python执行指定的操作，同时告
诉Python发生异常时怎么办。使用了 try-except 代码块时，即便出现异常，程序也将继续运行：
显示你编写的友好的错误消息，而不是令用户迷惑的traceback。
10.3.1 处理 ZeroDivisionError 异常
下面来看一种导致Python引发异常的简单错误。你可能知道不能将一个数字除以0，但我们还是让Python这样做吧：
division.py

print(5/0)

显然，Python无法这样做，因此你将看到一个traceback：

Traceback (most recent call last):
File “division.py”, line 1, in
print(5/0)
① ZeroDivisionError: division by zero

在上述traceback中，①处指出的错误 ZeroDivisionError 是一个异常对象。Python无法按你的要求做时，就会创建这种对象。在这种情况下，Python将停止运行程序，并指出引发了哪种异常，而我们可根据这些信息对程序进行修改。下面我们将告诉Python，发生这种错误时怎么办；这样，如果再次发生这样的错误，我们就有备无患了。
#### 10.3.2 使用 try-except 代码块
当你认为可能发生了错误时，可编写一个 try-except 代码块来处理可能引发的异常。你让Python尝试运行一些代码，并告诉它如果这些代码引发了指定的异常，该怎么办。处理 ZeroDivisionError 异常的 try-except 代码块类似于下面这样：

try:
print(5/0)
except ZeroDivisionError:
print(“You can’t divide by zero!”)

我们将导致错误的代码行 print(5/0) 放在了一个 try 代码块中。如果 try 代码块中的代码运行起来没有问题，Python将跳过 except 代码块；如果 try 码块中的代码导致了错误，Python将查找这样的 except 代码块，并运行其中的代码，即其中指定的错误与引发的错误相同。
在这个示例中， try 代码块中的代码引发了 ZeroDivisionError 异常，因此Python指出了该如何解决问题的 except 代码块，并运行其中的代码。这样，用户看到的是一条友好的错误消息，而不是 traceback ：

You can’t divide by zero!

如果 try-except 代码块后面还有其他代码，程序将接着运行，因为已经告诉了Python如何处理这种错误。下面来看一个捕获错误后程序将继续运行的示例。
#### 10.3.3 使用异常避免崩溃
发生错误时，如果程序还有工作没有完成，妥善地处理错误就尤其重要。这种情况经常会出现在要求用户提供输入的程序中；如果程序能够妥善地处理无效输入，就能再提示用户提供有效输入，而不至于崩溃。
下面来创建一个只执行除法运算的简单计算器：
division.py

print(“Give me two numbers, and I’ll divide them.”)
print(“Enter ‘q’ to quit.”)
while True:
first_number = input("\nFirst number: ")
if first_number == ‘q’:
break
second_number = input("Second number: ")
if second_number == ‘q’:
break
answer = int(first_number) / int(second_number)
print(answer)

#### 10.3.4 else 代码块
通过将可能引发错误的代码放在 try-excep t代码块中，可提高这个程序抵御错误的能力。错误是执行除法运算的代码行导致的，因此我们需要将它放到 try-except 代码块中。这个示例还包含一个 else 代码块；依赖于 try 代码块成功执行的代码都应放到 else 代码块中：

print(“Give me two numbers, and I’ll divide them.”)
print(“Enter ‘q’ to quit.”)
while True:
first_number = input("\nFirst number: ")
if first_number == ‘q’:
break
second_number = input("Second number: ")
try:
answer = int(first_number) / int(second_number)
except ZeroDivisionError:
print(“You can’t divide by 0!”)
else:
print(answer)

我们让Python尝试执行 try 代码块中的除法运算，这个代码块只包含可能导致错误的代码。依赖于 try 代码块成功执行的代码都放在 else 代码块中；在这个示例中，如果除法运算成功，我们就使用 else 代码块来打印结果。
except 代码块告诉Python，出现 ZeroDivisionError 异常时该怎么办。如果 try 代码块因除零错误而失败，我们就打印一条友好的消息，告诉用户如何避免这种错误。
try-except-else 代码块的工作原理大致如下：Python尝试执行 try 代码块中的代码；只有可能引发异常的代码才需要放在 try 语句中。有时候，有一些仅在 try 代码块成功执行时才需要运行的代码；这些代码应放在 else 代码块中。 except 代码块告诉Python，如果它尝试运行 try 代码块中的代码时引发了指定的异常，该怎么办。
通过预测可能发生错误的代码，可编写健壮的程序，它们即便面临无效数据或缺少资源，也能继续运行，从而能够抵御无意的用户错误和恶意的攻击。
#### 10.3.5 处理 FileNotFoundError 异常
使用文件时，一种常见的问题是找不到文件：你要查找的文件可能在其他地方、文件名可能不正确或者这个文件根本就不存在。对于所有这些情形，都可使用 try-except 代码块以直观的方式进行处理。
我们来尝试读取一个不存在的文件。下面的程序尝试读取文件alice.txt的内容，但我没有将这个文件存储在alice.py所在的目录中：
alice.py

filename = ‘alice.txt’
with open(filename) as f_obj:
contents = f_obj.read()

Python无法读取不存在的文件，因此它引发一个异常：

Traceback (most recent call last):
File “alice.py”, line 3, in
with open(filename) as f_obj:
FileNotFoundError: [Errno 2] No such file or directory: ‘alice.txt’

在上述traceback中，最后一行报告了 FileNotFoundError 异常，这是Python找不到要打开的文件时创建的异常。在这个示例中，这个错误是函数 open() 导致的，因此要处理这个错误，必须将try 语句放在包含 open() 的代码行之前：
filename = 'alice.txt'
try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except FileNotFoundError:
    msg = "Sorry, the file " + filename + " does not exist."
print(msg)
在这个示例中， try 代码块引发 FileNotFoundError 异常，因此Python找出与该错误匹配的except 代码块，并运行其中的代码。最终的结果是显示一条友好的错误消息，而不是 traceback ：

Sorry, the file alice.txt does not exist.

如果文件不存在，这个程序什么都不做，因此错误处理代码的意义不大。下面来扩展这个示例，看看在你使用多个文件时，异常处理可提供什么样的帮助。
#### 10.3.6 分析文本
你可以分析包含整本书的文本文件。很多经典文学作品都是以简单文本文件的方式提供的，因为它们不受版权限制。本节使用的文本来自项目Gutenberg（http://gutenberg.org/），这个项目提供了一系列不受版权限制的文学作品，如果你要在编程项目中使用文学文本，这是一个很不错的资源。
下面来提取童话Alice in Wonderland的文本，并尝试计算它包含多少个单词。我们将使用方法 split() ，它根据一个字符串创建一个单词列表。

方法 split() 以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。结果是一个包含字符串中所有单词的列表，虽然有些单词可能包含标点。为计算Alice in Wonderland包含多少个单词，我们将对整篇小说调用 split() ，再计算得到的列表包含多少个元素，从而确定整篇童话大致包含多少个单词：

filename = ‘alice.txt’
try:
with open(filename) as f_obj:
contents = f_obj.read()
except FileNotFoundError:
msg = “Sorry, the file " + filename + " does not exist.”
print(msg)
else:
# 计算文件大致包含多少个单词
words = contents.split()
num_words = len(words)
print(“The file " + filename + " has about " + str(num_words) + " words.”)

我们把文件alice.txt移到了正确的目录中，让 try 代码块能够成功地执行。我们对变
量 contents （它现在是一个长长的字符串，包含童话Alice in Wonderland的全部文本）调用方法split() ，以生成一个列表，其中包含这部童话中的所有单词。当我们使用 len() 来确定这个列表的长度时，就知道了原始字符串大致包含多少个单词。我们打印一条消息，指出文件包含多少个单词。这些代码都放在 else 代码块中，因为仅当 try 代码块成功执行时才执行它们。输出指出了文件alice.txt包含多少个单词：
The file alice.txt has about 29461 words.
这个数字有点大，因为这里使用的文本文件包含出版商提供的额外信息，但与童话Alice in Wonderland的长度相当一致。
#### 10.3.7 使用多个文件
下面多分析几本书。这样做之前，我们先将这个程序的大部分代码移到一个名为count_words() 的函数中，这样对多本书进行分析时将更容易：
word_count.py

def count_words(filename):
“”“计算一个文件大致包含多少个单词”""
try:
with open(filename) as f_obj:
contents = f_obj.read()
except FileNotFoundError:
msg = “Sorry, the file " + filename + " does not exist.”
print(msg)
else:
# 计算文件大致包含多少个单词
words = contents.split()
num_words = len(words)
print(“The file " + filename + " has about " + str(num_words) + " words.”)

filename = ‘alice.txt’
count_words(filename)

这些代码大都与原来一样，我们只是将它们移到了函数 count_words() 中，并增加了缩进量。
修改程序的同时更新注释是个不错的习惯，因此我们将注释改成了文档字符串，并稍微调整了一
下措辞。
现在可以编写一个简单的循环，计算要分析的任何文本包含多少个单词了。为此，我们将要分析的文件的名称存储在一个列表中，然后对列表中的每个文件都调用 count_words() 。我们将尝试计算Alice in Wonderland、Siddhartha、Moby Dick和Little Women分别包含多少个单词，它们都不受版权限制。我故意没有将siddhartha.txt放到word_count.py所在的目录中，让你能够看到这个程序在文件不存在时处理得有多出色：

def count_words(filename):
– snip –
filenames = [‘alice.txt’, ‘siddhartha.txt’, ‘moby_dick.txt’, little_women.txt’]
for filename in filenames:
count_words(filename)

文件siddhartha.txt不存在，但这丝毫不影响这个程序处理其他文件

#### 10.3.8 失败时一声不吭
在前一个示例中，我们告诉用户有一个文件找不到。但并非每次捕获到异常时都需要告诉用户，有时候你希望程序在发生异常时一声不吭，就像什么都没有发生一样继续运行。要让程序在失败时一声不吭，可像通常那样编写 try 代码块，但在 except 代码块中明确地告诉Python什么都不要做。Python有一个 pass 语句，可在代码块中使用它来让Python什么都不要做：

def count_words(filename):
“”“计算一个文件大致包含多少个单词”""
try:
–snip–
except FileNotFoundError:
pass
else:
–snip–
filenames = [‘alice.txt’, ‘siddhartha.txt’, ‘moby_dick.txt’, little_women.txt’]
for filename in filenames:

相比于前一个程序，这个程序唯一不同的地方是 pass 语句。现在，出现FileNotFoundError 异常时，将执行 except 代码块中的代码，但什么都不会发生。这种错误发生时，不会出现 traceback ，也没有任何输出。用户将看到存在的每个文件包含多少个单词，但没有任何迹象表明有一个文件未找到：
The file alice.txt has about 29461 words.
The file moby_dick.txt has about 215136 words.
The file little_women.txt has about 189079 words.
pass 语句还充当了占位符，它提醒你在程序的某个地方什么都没有做，并且以后也许要在这里做些什么。例如，在这个程序中，我们可能决定将找不到的文件的名称写入到文件missing_files.txt中。用户看不到这个文件，但我们可以读取这个文件，进而处理所有文件找不到的问题。
#### 10.3.9 决定报告哪些错误
在什么情况下该向用户报告错误？在什么情况下又应该在失败时一声不吭呢？如果用户知道要分析哪些文件，他们可能希望在有文件没有分析时出现一条消息，将其中的原因告诉他们。如果用户只想看到结果，而并不知道要分析哪些文件，可能就无需在有些文件不存在时告知他们。向用户显示他不想看到的信息可能会降低程序的可用性。Python的错误处理结构让你能够细致地控制与用户分享错误信息的程度，要分享多少信息由你决定。
编写得很好且经过详尽测试的代码不容易出现内部错误，如语法或逻辑错误，但只要程序依赖于外部因素，如用户输入、存在指定的文件、有网络链接，就有可能出现异常。凭借经验可判断该在程序的什么地方包含异常处理块，以及出现错误时该向用户提供多少相关的信息。
### 10.4 存储数据
模块json让你能够将python数据结构数据存储到文件中，并在程序再次运行时加载该文件中的数据。
#### 使用json.dump()和json.load()
函数 json.dump() 接受两个实参：要存储的数据以及可用于存储数据的文件对象。
number_writer.py
```python
import json
numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json'
with open(filename, 'w') as f_obj:
    json.dump(numbers, f_obj)

使用json.load()将这个列表读取到内存中
number_reader.py

import json
filename = 'numbers.json'
with open(filename) as f_obj:
numbers = json.load(f_obj)
print(numbers)

10.4.2 保存和读取用户生成的数据

程序运行时，我们将尝试从文件username.json中获取用户名，因此我们首先编写一个尝试恢复用户名的 try 代码块。如果这个文件不存在，我们就在 except 代码块中提示用户输入用户名，并将其存储在username.json中，以便程序再次运行时能够获取它：
remember_me.py

import json
# 如果以前存储了用户名，就加载它

# 否则，就提示用户输入用户名并存储它
filename = 'username.json'
try:
    with open(filename) as f_obj:
        username = json.load(f_obj)
except FileNotFoundError:
    username = input("What is your name? ")
    with open(filename, 'w') as f_obj:
        json.dump(username, f_obj)
        print("We'll remember you when you come back, " + username + "!")
else:
    print("Welcome back, " + username + "!")

10.4.3 重构

你经常会遇到这样的情况：代码能够正确地运行，但可做进一步的改进——将代码划分为一系列完成具体工作的函数。这样的过程被称为重构。重构让代码更清晰、更易于理解、更容易扩展。
要重构remember_me.py，可将其大部分逻辑放到一个或多个函数中。remember_me.py的重点是问候用户，因此我们将其所有代码都放到一个名为 greet_user() 的函数中：
remember_me.py

import json
def greet_user():
    """问候用户，并指出其名字"""
    filename = 'username.json'
    try:
        with open(filename) as f_obj:
        username = json.load(f_obj)
    except FileNotFoundError:
        username = input("What is your name? ")
        with open(filename, 'w') as f_obj:
            json.dump(username, f_obj)
            print("We'll remember you when you come back, " + username + "!")
    else:
        print("Welcome back, " + username + "!")

greet_user()

考虑到现在使用了一个函数，我们删除了注释，转而使用一个文档字符串来指出程序是做什么的。这个程序更清晰些，但函数 greet_user() 所做的不仅仅是问候用户，还在存储了用户名时获取它，而在没有存储用户名时提示用户输入一个。
下面来重构 greet_user() ，让它不执行这么多任务。为此，我们首先将获取存储的用户名的代码移到另一个函数中：

import json
def get_stored_username():
    """如果存储了用户名，就获取它"""
    filename = 'username.json'
    try:
        with open(filename) as f_obj:
            username = json.load(f_obj)
    except FileNotFoundError:
        return None
    else:
        return username
def greet_user():
    """问候用户，并指出其名字"""
    username = get_stored_username()
    if username:
        print("Welcome back, " + username + "!")
    else:
        username = input("What is your name? ")
        filename = 'username.json'
        with open(filename, 'w') as f_obj:
            json.dump(username, f_obj)
            print("We'll remember you when you come back, " + username + "!")
greet_user()

新增的函数 get_stored_username() 目标明确，Ø处的文档字符串指出了这一点。如果存储了用户名，这个函数就获取并返回它；如果文件username.json不存在，这个函数就返回 None。这是一种不错的做法：函数要么返回预期的值，要么返回 None ；这让我们能够使用函数的返回值做简单测试。如果成功地获取了用户名，就打印一条欢迎用户回来的消息，否则就提示用户输入用户名。
我们还需将 greet_user() 中的另一个代码块提取出来：将没有存储用户名时提示用户输入的代码放在一个独立的函数中：

import json
def get_stored_username():
    """如果存储了用户名，就获取它"""
    -- snip --
def get_new_username():
    """提示用户输入用户名"""
    username = input("What is your name? ")
    filename = 'username.json'
    with open(filename, 'w') as f_obj:
        json.dump(username, f_obj)
    return username
def greet_user():
    """问候用户，并指出其名字"""
    username = get_stored_username()
    if username:
        print("Welcome back, " + username + "!")
    else:
        username = get_new_username()
        print("We'll remember you when you come back, " + username + "!")

greet_user()

在remember_me.py的这个最终版本中，每个函数都执行单一而清晰的任务。我们调用greet_user() ，它打印一条合适的消息：要么欢迎老用户回来，要么问候新用户。为此，它首先调用 get_stored_username() ，这个函数只负责获取存储的用户名（如果存储了的话），再在必要时调用 get_new_username() ，这个函数只负责获取并存储新用户的用户名。要编写出清晰而易于维护和扩展的代码，这种划分工作必不可少。

第11章测试代码

11.1 测试函数

11.1.1 单元测试与测试用例

单元测试： python标准库中的模块unittest提供了代码测试工具，单元测试用于核实函数的某个方面没有问题；测试用例是一组单元测试，这些单元测试一起核实函数在各种情况下的行为都符合要求，
**全覆盖式测试用例：**包含一整套单元测试，涵盖了各种可能的函数使用方式。

11.1.2 可通过的测试

要为函数编写测试用例，可先导入模块unittest以及要测试的函数，在创建一个继承unittest.TextCase的类，并编写一系列方法对函数行为的不同方面进行测试。

子类中所有以test_打头的方法都将自动运行。
**断言方法：**用来核实得到的结果是否与期望的结果一致。 assertEqual()

11.1.3 不能通过的测试

11.1.4 测试未通过时怎么办

11.1.5 添加新测试

11.2 测试类

编写针对类的测试。

11.2.1 各种断言方法

表11-1 unittest Module的断言方法

方法	用途
assertEqual(a, b)	核实a==b
assertNotEqual(a, b)	核实a != b
assertTrue(x)	核实x 为True
assertFalse(x)	核实x 为 False
assertIn(item, list)	核实item在list中
assertNotIn(item, list)	核实item不在list中

python学习记录

第9章 类

9.1 创建和使用类

9.1.1 创建Dog类