python print(len(pi_string))_Python基础3

Python基础：介绍文件和异常、测试代码

从文件中读取数据

1.读取整个文件

eg: with open('pi_digits.txt') as file_object:

contents = file_object.read()

print(contents)

要以任何方式使用文件——哪怕仅仅是打印其内容，都得先打开文件，这样才能访问它。函数open()接受一个参数：要打开的文件的名称。Python在当前执行的文件所在的目录中查找指定的文件。函数open()返回一个表示文件的对象。

关键字with在不再需要访问文件后将其关闭。也可以调用open()和close()来打开和关闭文件，但这样做时，如果程序存在bug，导致close()语句未执行，文件将不会关闭。未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用close()，你会发现需要使用文件时它已关闭(无法访问)，这会导致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时机，但通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。

方法read()读取这个文件的全部内容，并将其作为一个长长的字符串存储在变量contents中。

相比于原始文件，该输出唯一不同的地方是末尾多了一个空行。因为read()到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除多出来的空行，可在print语句中使用rstrip()：

eg: with open('pi_digits.txt') as file_object:

contents = file_object.read()

print(contents.rstrip())

2.文件路径

要让Python打开不与程序文件位于同一个目录中的文件，需要提供 文件路径 ，它让Python到系统的特定位置去查找。

相对文件路径让Python到指定的位置去查找，而该位置是相对于当前运行的程序所在目录的。

在LinuxOS X中，可以这样编写代码：

with open('text_files/filename.txt') as file_object:

这行代码让Python到程序所在文件夹下的text_files中去查找指定的.txt文件。在Windows系统中，在文件路径中使用反斜杠(\)而不是斜杠(/)：

with open('text_files\filename.txt') as file_object:

还可将文件在计算机中的准确位置告诉Python，这样就不用关心当前运行的程序存储在什么地方了。这称为绝对文件路径。

绝对路径通常比相对路径更长，因此将其存储在一个变量中，再将该变量传递给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:

注意Windows系统有时能够正确地解读文件路径中的斜杠。如果你使用的是Windows系统，且结果不符合预期，请确保在文件路径中使用的是反斜杠。

3.逐行读取

eg: filename = 'pi_digits.txt'

with open(filename) as file_object:

for line in file_object:

print(line)

变量filename表示的并非实际文件——它只是一个让Python知道到哪里

去查找文件的字符串，调用open()后，将一个表示文件及其内容的对象存储到了变file_object中。

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

print(line.rstrip())

4.创建一个包含文件各行内容的列表

使用关键字with时，open()返回的文件对象只在with代码块内可用。如果要在with代码块外访问文件的内容，可在with代码块内将文件的各行存储在一个列表中，并在with代码块外使用该列表：你可以立即处理文件的各个部分，也可推迟到程序后面再处理。

eg: filename = 'pi_digits.txt'

with open(filename) as file_object:

lines = file_object.readlines()方法readlines()从文件中读取每一行，并将其存储在一个列表中；接下来，该列表被存储到变量lines中

pi_string = ''

for line in lines:

pi_string += line.strip()

print(pi_string)

print(len(pi_string))

注意 读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并要将其作为数值使用，就必须使用函数int()将其转换为整数，或使用函数float()将其转换为浮点数。

写入文件

1.写入空文件

eg: 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将在返回文件对象前清空该文件。使用文件对象的方法write()将一个字符串写入文件。

注意Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str()将其转换为字符串格式。

2.写入多行

函数write()不会在写入的文本末尾添加换行符，要让每个字符串都单独占一行，需要在write()语句中包含换行符：

eg: filename = 'programming.txt'

with open(filename, 'w') as file_object:

file_object.write("I love programming.\n")

file_object.write("I love creating new games.\n")

3.附加到文件

如果要给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将创建一个空文件。

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

异常

Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果编写了处理该异常的代码，程序将继续运行；如果未对异常进行处理，程序将停止，并显示一个traceback，其中包含有关异常的报告。

异常是使用try-except代码块处理的。try-except代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except代码块时，即便出现异常，程序也将继续运行：显示已编写的友好的错误消息，而不是令用户迷惑的traceback。

1.处理ZeroDivisionError异常

eg: print(5/0)

代码结果：Traceback (most recent call last):

File "division.py", line 1, in

print(5/0)

ZeroDivisionError: division by zero

在上述traceback中，错误ZeroDivisionError是一个异常对象。Python无法按你的要求做时，就会创建这种对象。在这种情况下，Python将停止运行程序，并指出引发了哪种异常，而我们可根据这些信息对程序进行修改。

2.使用try-except代码块

当认为可能发生了错误时，可编写一个try-except代码块来处理可能引发的异常。让Python尝试运行一些代码，并告诉它如果这些代码引发了指定的异常，该怎么办。

eg: try:

print(5/0)

except ZeroDivisionError:

print("You can't divide by zero!")

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

如果try-except代码块后面还有其他代码，程序将接着运行，因为已经告诉了Python如何处理这种错误。

3.使用异常避免崩溃

发生错误时，如果程序还有工作没有完成，妥善地处理错误就尤其重要。这种情况经常会出现在要求用户提供输入的程序中；如果程序能够妥善地处理无效输入，就能再提示用户提供有效输入，而不至于崩溃。

4 .else代码块

通过将可能引发错误的代码放在try-except代码块中，可提高这个程序抵御错误的能力。依赖于try代码块成功执行的代码都应放到else代码块中：

eg: 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)

try-except-else代码块的工作原理大致如下：Python尝试执行try代码块中的代码；只有可能引发异常的代码才需要放在try语句中。有时候，有一些仅在try代码块成功执行时才需要运行的代码；这些代码应放在else代码块中。except代码块告诉Python，如果它尝试运行try代码块中的代码时引发了指定的异常，该怎么办。

5.处理FileNotFoundError异常

使用文件时，一种常见的问题是找不到文件：你要查找的文件可能在其他地方、文件名可能不正确或者这个文件根本就不存在。对于所有这些情形，都可使用try-except代码块以直观的方式进行处理。

eg: 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)

6.分析文本

方法split()以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。结果是一个包含字符串中所有单词的列表，虽然有些单词可能包含标点。

eg: 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.")

7.使用多个文件

eg: 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.")

filenames = ['alice.txt', 'siddhartha.txt', 'moby_dick.txt', 'little_women.txt']

for filename in filenames:

count_words(filename)

8.失败时一声不吭

要让程序在失败时一声不吭，可像通常那样编写try代码块，但在except代码块中明确地告诉Python什么都不要做。Python有一个pass语句，可在代码块中使用它来让Python什么都不要做：

eg: 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:

count_words(filename)

pass语句还充当了占位符，它提醒你在程序的某个地方什么都没有做，并且以后也许要在这里做些什么。例如，在这个程序中，我们可能决定将找不到的文件的名称写入到文件missing_files.txt中。用户看不到这个文件，但我们可以读取这个文件，进而处理所有文件找不到的问题。

编写得很好且经过详尽测试的代码不容易出现内部错误，如语法或逻辑错误，但只要程序依赖于外部因素，如用户输入、存在指定的文件、有网络链接，就有可能出现异常。凭借经验可判断该在程序的什么地方包含异常处理块，以及出现错误时该向用户提供多少相关的信息。

可以使用方法count()来确定特定的单词或短语在字符串中出现了多少次。

eg: line = "Row, row, row your boat"

line.count('row')

line.lower().count('row')

4.存储数据

很多程序都要求用户输入某种信息，如让用户存储游戏首选项或提供要可视化的数据。程序都把用户提供的信息存储在列表和字典等数据结构中。用户关闭

程序时，你几乎总是要保存他们提供的信息；一种简单的方式是使用模块json来存储数据。

模块json让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。你还可以使用json在Python程序之间分享数据。更重要的是，JSON数据格式并非Python专用的，这让你能够将以JSON格式存储的数据与使用其他编程语言的人分享。

注意JSON(JavaScript Object Notation)格式最初是为JavaScript开发的，但随后成了一种常见格式，被包括Python在内的众多语言采用。

使用json.dump()和json.load()

编写一个存储一组数字的简短程序，再编写一个将这些数字读取到内存中的程序。第一个程序将使用json.dump()来存储这组数字，而第二个程序将使用json.load()。

函数json.dump()接受两个实参：要存储的数据以及可用于存储数据的文件对象。下面演示了如何使用json.dump()来存储数字列表：

eg: import json

numbers = [2, 3, 5, 7, 11, 13]

filename = 'numbers.json'通常使用文件扩展名.json来指出文件存储的数据为JSON格式

with open(filename, 'w') as f_obj:

json.dump(numbers, f_obj)使用函数json.dump()将数字列表存储到文件numbers.json中

下面再编写一个程序，使用json.load()将这个列表读取到内存中：

eg: import json

filename = 'numbers.json'

with open(filename) as f_obj:

numbers = json.load(f_obj)

print(numbers)

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

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

eg: 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 + "!")

重构

你经常会遇到这样的情况：代码能够正确地运行，但可做进一步的改进——将代码划分为一系列完成具体工作的函数。这样的过程被称为重构。

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

测试代码

编写函数或类时，还可为其编写测试。通过测试，可确定代码面对各种输入都能够按要求的那样工作。在程序中添加新代码时，也可以对其进行测试，确认它们不会破坏程序既有的行为。

测试函数

eg: name_function.py接受名和姓并返回整洁的姓名

def get_formatted_name(first, last):

"""Generate a neatly formatted full name."""

full_name = first + ' ' + last

return full_name.title()

为核实get_formatted_name()像期望的那样工作，我们来编写一个使用这个函数的程序。程序names.py让用户输入名和姓，并显示整洁的全名：

eg: from name_function import get_formatted_name

print("Enter 'q' at any time to quit.")

while True:

first = input("\nPlease give me a first name: ")

if first == 'q':

break

last = input("Please give me a last name: ")

if last == 'q':

break

formatted_name = get_formatted_name(first, last)

print("\tNeatly formatted name: " + formatted_name + '.')

1.单元测试和测试用例

Python标准库中的模块unittest提供了代码测试工具。单元测试用于核实函数的某个方面没有问题；测试用例是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合要求。良好的测试用例考虑到了函数可能收到的各种输入，包含针对所有这些情形的测试。全覆盖式测试用例包含一整套单元测试，涵盖了各种可能的函数使用方式。对于大型项目，要实现全覆盖可能很难。通常，最初只要针对代码的重要行为编写测试即可，等项目被广泛使用时再考虑全覆盖。

2.可通过的测试

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

下面是一个只包含一个方法的测试用例，它检查函数get_formatted_name()在给定名和姓时能否正确地工作：

eg: test_name_function.py运行testname_function.py时，所有以test打头的方法都将自动运行。

import unittest

from name_function import get_formatted_name

class NamesTestCase(unittest.TestCase):创建了一个名为NamesTestCase的类，用于包含一系列针对get_formatted_name()的单元测试。这个类必须继承unittest.TestCase类，这样Python才知道如何运行你编写的测试。

"""测试name_function.py"""

def test_first_last_name(self):

"""能够正确地处理像Janis Joplin这样的姓名吗？"""

formatted_name = get_formatted_name('janis', 'joplin')

self.assertEqual(formatted_name, 'Janis Joplin')使用了unittest类最有用的功能之一：一个断言方法。断言方法用来核实得到的结果是否与期望的结果一致。

unittest.main()代码行unittest.main()让Python运行这个文件中的测试。

运行test_name_function.py时，得到的输出如下：

.

----------------------------------------------------------------------

Ran 1 test in 0.000s

OK

第1行的句点表明有一个测试通过了。接下来的一行指出Python运行了一个测试，消耗的时间不到0.001秒。最后的OK表明该测试用例中的所有单元测试都通过了。

3.不能通过的测试

测试未通过时结果:

E一个字母E，它指出测试用例中有一个单元测试导致了错误。

=============================================================

ERROR: test_first_last_name (__main__.NamesTestCase)    NamesTestCase中的test_first_last_name()导致了错误。测试用例包含众多单元测试时，知道哪个测试未通过至关重要。

----------------------------------------------------------------------

Traceback (most recent call last):

File "test_name_function.py", line 8, in test_first_last_name

formatted_name = get_formatted_name('janis', 'joplin')

TypeError: get_formatted_name() missing 1 required positional argument: 'last'

----------------------------------------------------------------------

Ran 1 test in 0.000s

FAILED (errors=1)指出整个测试用例都未通过，因为运行该测试用例时发生了一个错误。

4.测试未通过时怎么办

如果检查的条件没错，测试通过了意味着函数的行为是对的，而测试未通过意味着编写的新代码有错。因此，测试未通过时，不要修改测试，而应修复导致测试不能通过的代码：检查刚对函数所做的修改，找出导致函数行为不符合预期的修改。

5.添加新测试

eg: import unittest

from name_function import get_formatted_name

class NamesTestCase(unittest.TestCase):

"""测试name_function.py """

def test_first_last_name(self):

"""能够正确地处理像Janis Joplin这样的姓名吗？"""

formatted_name = get_formatted_name('janis', 'joplin')

self.assertEqual(formatted_name, 'Janis Joplin')

def test_first_last_middle_name(self):

"""能够正确地处理像Wolfgang Amadeus Mozart这样的姓名吗？"""

formatted_name = get_formatted_name(

'wolfgang', 'mozart', 'amadeus')

self.assertEqual(formatted_name, 'Wolfgang Amadeus Mozart')

unittest.main()

方法名必须以test_打头，这样它才会在运行test_name_function.py时自动运行。在TestCase类中使用很长的方法名是可以的；这些方法的名称必须是描述性的，这才能让你明白测试未通过时的输出；这些方法由Python自动调用，不用编写调用它们的代码。

测试类

1.各种断言方法

Python在unittest.TestCase类中提供了很多断言方法。断言方法检查你认为应该满足的条件是否确实满足。如果该条件确实满足，你对程序行为的假设就得到了确认，你就可以确信其中没有错误。如果你认为应该满足的条件实际上并不满足，Python将引发异常。

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中

上表描述了6个常用的断言方法。使用这些方法可核实返回的值等于或不等于预期的值、返回的值为True或False、返回的值在列表中或不在列表中。只能在继承unittest.TestCase的类中使用这些方法，

2.一个要测试的类

类的测试与函数的测试相似，但存在一些不同之处，

eg: class AnonymousSurvey():

"""收集匿名调查问卷的答案"""

def __init__(self, question):

"""存储一个问题，并为存储答案做准备"""

self.question = question

self.responses = []

def show_question(self):

"""显示调查问卷"""

print(question)

def store_response(self, new_response):

"""存储单份调查答卷"""

self.responses.append(new_response)

def show_results(self):

"""显示收集到的所有答卷"""

print("Survey results:")

for response in responses:

print('- ' + response)

要创建这个类的实例，只需提供一个问题即可。有了表示调查的实例后，就可使用show_question()来显示其中的问题，可使用store_response()来存储答案，并使用show_results()来显示调查结果。

测试程序：

eg: from survey import AnonymousSurvey

#定义一个问题，并创建一个表示调查的AnonymousSurvey对象

question = "What language did you first learn to speak?"

my_survey = AnonymousSurvey(question)

#显示问题并存储答案

my_survey.show_question()

print("Enter 'q' at any time to quit.\n")

while True:

response = input("Language: ")

if response == 'q':

break

my_survey.store_response(response)

#显示调查结果

print("\nThank you to everyone who participated in the survey!")

my_survey.show_results()

3.测试AnonymousSurvey类

要测试类的行为，需要创建其实例。

eg: import unittest

from survey import AnonymousSurvey

class TestAnonymousSurvey(unittest.TestCase):

"""针对AnonymousSurvey类的测试"""

def test_store_single_response(self):

"""测试单个答案会被妥善地存储"""

question = "What language did you first learn to speak?"

my_survey = AnonymousSurvey(question)

my_survey.store_response('English')

self.assertIn('English', my_survey.responses)

def test_store_three_responses(self):

"""测试三个答案会被妥善地存储"""

question = "What language did you first learn to speak?"

my_survey = AnonymousSurvey(question)

responses = ['English', 'Spanish', 'Mandarin']

for response in responses:

my_survey.store_response(response)

for response in responses:

self.assertIn(response, my_survey.responses)

unittest.main()

4.方法setUp()

unittest.TestCase类中包含了方法setUp()，Python将先运行它，再运行各个以test_打头的方法。这样，在编写的每个测试方法中都可使用在方法setUp()中创建的对象了。

eg: import unittest

from survey import AnonymousSurvey

class TestAnonymousSurvey(unittest.TestCase):

"""针对AnonymousSurvey类的测试"""

def setUp(self):方法setUp()做了两件事情：创建一个调查对象；创建一个答案列表。存储这两样东西的变量名包含前缀self即存储在属性中)，因此可在这个类的任何地方使用。

"""

创建一个调查对象和一组答案，供使用的测试方法使用

"""

question = "What language did you first learn to speak?"

self.my_survey = AnonymousSurvey(question)

self.responses = ['English', 'Spanish', 'Mandarin']

def test_store_single_response(self):

"""测试单个答案会被妥善地存储"""

self.my_survey.store_response(self.responses[0])

self.assertIn(self.responses[0], self.my_survey.responses)

def test_store_three_responses(self):

"""测试三个答案会被妥善地存储"""

for response in self.responses:

self.my_survey.store_response(response)

for response in self.responses:

self.assertIn(response, self.my_survey.responses)

unittest.main()

测试自己编写的类时，方法setUp()让测试方法编写起来更容易：可在setUp()方法中创建一系列实例并设置它们的属性，再在测试方法中直接使用这些实例。相比于在每个测试方法中都创建实例并设置其属性，这要容易得多。

注意 运行测试用例时，每完成一个单元测试，Python都打印一个字符：测试通过时打印一个句点；测试引发错误时打印一个E；测试导致断言失败时打印一个F。这就是运行测试用例时，在输出的第一行中看到的句点和字符数量各不相同的原因。如果测试用例包含很多单元测试，需要运行很长时间，就可通过观察这些结果来获悉有多少个测试通过了。