AutomateTheBoringStuffWithPython

第一部分 Python编程基础

第 1 章 Python 基础

1.1 在交互式环境中输入表达式

操作符	**	%	//	/	*	-	+
操作	指数	取模/取余数	整除/商数取整	除	乘	减	加

增强的赋值语句	等价的赋值语句
spam += 1	spam = spam + 1
spam -= 1	spam = spam - 1
spam *= 1	spam = spam * 1
spam /= 1	spam = spam / 1
spam %= 1	spam = spam % 1

1.2 整型、浮点型和字符串数据类型

int float char

1.3 字符串连接和复制

连接：+

>>>'Hello' + ',' + 'World'
'Hello,World'

复制：*

>>>'hello' * 3
hellohellohello

1.4 在变量中保存值

1.4.1 赋值语句

赋值语句包含一个变量名、一个等号（称为赋值操作符），以及要存储的值。

>>>apple = 520
>>>apple
520
>>>apple=apple + 1
>>>apple
521

1.4.2 变量名

1．只能是一个词。

2．只能包含字母、数字和下划线。

3．不能以数字开头。

1.5 程序剖析

# This is annotation. This program says hello and asks for my name.
print('Hello world!')	# print()函数将括号内的字符串显示在屏幕上。
print('What is your name?') # ask for their name
myName = input()
print('It is good to meet you, ' + myName)	# 打印用户名字
print('The length of your name is:')
print(len(myName))
print('What is your age?') # ask for their age 
myAge = input()	# 函数等待用户在键盘上输入一些文本，并按下回车键。
print('You will be ' + str(int(myAge) + 1) + ' in a year.')

第 2 章 控制流

2.1 操作符类型

类型	内容
Boolean(布尔)值	True、False
比较操作符	==、!=、<、>、<=、>=
布尔操作符	and、or、not

2.2 控制流的元素

2.2.1 if/else/elif

if name == 'Alice': 
 print('Hi, Alice.')
elif age < 12:
 print('You are not Alice, kiddo.')
else:
 print('You are neither Alice nor a little kid.')

2.2.2 while 循环语句

在代码中，while 语句总是包含下面几部分：

• 关键字；
• 条件（求值为 True 或 False 的表达式）；
• 冒号；
• 从新行开始，缩进的代码块（称为 while 子句）。

# 当n<5时，输出Hello, world.
n = 0
while n < 5:
 print('Hello, world.')
 n = n + 1

2.2.2.1 break语句

# 让执行提前跳出 while 循环子句
while True:
	print('Please type your name.')
	name = input() 
	if name == 'your name': 
		break 
print('Thank you!')

2.2.2.2 continue语句

# 像 break 语句一样，continue 语句用于循环内部。如果程序执行遇到 continue 语句，就会马上跳回到循环开始处，重新对循环条件求值
while True:
	print('Who are you?')
	name = input()
	if name != 'Joe': 
		continue 
	print('Hello, Joe. What is the password? (It is a fish.)') 
	password = input() 
	if password == 'swordfish':
		break 
print('Access granted.')

2.2.3 for 循环语句

在代码中，for 语句总是包含以下部分：

• for 关键字；
• 一个变量名；
• in 关键字；
• 调用 range()方法，最多传入 3 个参数；
• 冒号；
• 从下一行开始，缩退的代码块（称为 for 子句）。

# 计算55-99之间奇数的和
total = 0
for num in range(55, 100, 2) # range()取值 -> [,)
	total = total + num

2.4 导入模块

在开始使用一个模块中的函数之前，必须用 import 语句导入该模块。在代码中，

import 语句包含以下部分：

• import 关键字；
• 模块的名称；
• 可选的更多模块名称，之间用逗号隔开。

# 连续5次输出1~10之间任意的数字
import random
for i in range(5):
	print(random.randint(1, 10))

# 导入不同的模块
import random, sys, os, math

from import 语句包含以下部分

• from关键字；
• 模块的名称；
• import关键字和一个*。

from random import*

使用这种形式的 import 语句，调用 random模块中的函数时不需要 random.前缀。但是，使用完整的名称会让代码更可读，所以最好是使用普通形式的 import 语句。

2.5 用 sys.exit()提前结束程序

当程序执行到指令的底部时，总是会终止。但是，通过调用 sys.exit()函数，可以让程序终止或退出。因为这个函数在 sys 模块中，所以必须先导入 sys，才能使用它。

import sys
while True:
	print('Type exit to exit.')
	response = input()
	if response == 'exit':
		sys.exit() 
	print('You typed ' + response + '.')

第 3 章 函数

3.1 def 语句和return语句

import random
def getAnswer(answerNumber):
	if answerNumber == 1: 
		return 'apple' 
	elif answerNumber == 2:
		return 'egg' 
	elif answerNumber == 3 or answerNumber == 4:
		return 'Yes' 
	elif answerNumber == 5:
		print('hello, ', end = '')
		print('world')
		return 'hello, world'
	elif answerNumber == 6:
		print('hello,')
		print('world')
		return 'hello, \nworld'
	else:
		return None # NoneType
for i in range(1, 11):
	print(getAnswer(random.randint(1, 9)))
	print('\n\n')

3.2 局部和全局作用域

在被调用函数内赋值的变元和变量，处于该函数的“局部作用域”。在所有函数之外赋值的变量，属于“全局作用域”。处于局部作用域的变量，被称为“局部变量”。处于全局作用域的变量，被称为“全局变量”。一个变量必是其中一种，不能既是局部的又是全局的。

作用域很重要，理由如下：

• 全局作用域中的代码不能使用任何局部变量；

  def sum(i):
  	other = 2
  	return i + other
  print(sum(1))
  print(other)
  
  ========================= RESTART: M:/python/test003.py ========================
  3
  Traceback (most recent call last):
    File "M:/python/test003.py", line 5, in <module>
      print(other)
  NameError: name 'other' is not defined
  

• 但是，局部作用域可以访问全局变量；

• 一个函数的局部作用域中的代码，不能使用其他局部作用域中的变量。

  def one():
  	a = 1
  	print(a)
  	
  def two():
  	b = 2
  	one()
  	print(b)
  	print(b + a)
  	
  two()
  
  ========================= RESTART: M:/python/test004.py ========================
  1
  2
  Traceback (most recent call last):
    File "M:/python/test004.py", line 11, in <module>
      two()
    File "M:/python/test004.py", line 9, in two
      print(b + a)
  NameError: name 'a' is not defined
  

  def one():
  	a = 1
  	print(a)
  	
  def two():
  	b = 2
  	one()
  	print(b)
  	
  two()
  
  ========================= RESTART: M:/python/test004.py ========================
  1
  2
  

• (尽量避免)如果在不同的作用域中，你可以用相同的名字命名不同的变量。也就是说，可以有一个名为 one 的局部变量，和一个名为 one 的全局变量。

  def test1():
  	one = 'local1' 
  	print(one) # prints 'local1'
  def test2():
  	one = 'local2' 
  	print(one) # prints 'local2'
  	test1()
  	print(one) # prints 'local2'
  one = 'global'
  test2()
  print(one) # prints 'global'
  
  ========================= RESTART: M:\python\test005.py ========================
  local2
  local1
  local2
  global
  

• 全局变量可以在局部作用域中读取

  def test():
  	print(eggs)
  eggs = 42
  test()
  print(eggs)
  

• global 语句

  def localProcess():
  	global apple
  	apple = 520
  apple = 1314
  localProcess()
  print(apple)
  
  ========================= RESTART: M:\python\test006.py ========================
  520
  

3.3 异常处理

到目前为止，在 Python 程序中遇到错误，或“异常”，意味着整个程序崩溃。错误可以由 try 和 except 语句来处理。那些可能出错的语句被放在 try 子句中。如果错误发生，程序执行就转到接下来的 except 子句开始处。

def test(divideBy):
	try:
		return 42 / divideBy 
	except ZeroDivisionError:
		print('Error: Invalid argument.') 
print(test(2))
print(test(12))
print(test(0))
print(test(1))

========================= RESTART: M:\python\test007.py ========================
21.0
3.5
Error: Invalid argument.
None
42.0

第 4 章 列表、字符串、元组

4.1 列表数据类型

“列表”是一个值，它包含多个字构成的序列。术语“列表值”指的是列表本身（它作为一个值，可以保存在变量中，或传递给函数，像所有其他值一样），而不是指列表值之内的那些值。列表中的值也称为“表项”。表项用逗号分隔，以方括号结束。

test = ['cat', 'bat', 'rat', 'elephant']

# 用下标取得列表中的单个值
test[0] # 'cat'
test[3] # 'elephant'
test[4] # IndexError
test[0.5] # TypeError

# 负数下标
test[-1] # 'elelhant'
test[-4] # 'cat'

# 利用切片取得子列表 [,)
test[0:2] # ['cat', 'bat']
test[0:-1] # ['cat', 'bat', 'rat']
spam[1:] # ['bat', 'rat', 'elephant']
spam[:] # ['cat', 'bat', 'rat', 'elephant']

# 用 len()取得列表的长度
len(test) # 4

# 用下标改变列表中的值
test[0] = 'apple'
test # ['apple', 'bat', 'rat', 'eleplant']

# 列表连接和列表复制
add = ['add']
total = test + add
total # ['apple', 'bat', 'rat', 'eleplant', 'add']
add * 3 # ['add', 'add', 'add']

# 用 del 语句从列表中删除值
del total[4]
total == test # true

4.2 使用列表

当你第一次开始编程时，很容易会创建许多独立的变量，来保存一组类似的值。实际上，不必使用多个重复的变量，你可以使用单个变量，包含一个列表值。

catNames = []
while True:
	print('Enter the name of cat ' + str(len(catNames) + 1) + ' (Or enter nothing to stop.):') 
	name = input()
	if name == '':
		break 
	catNames = catNames + [name] # list concatenation
print('The cat names are:')
for name in catNames:
	print(' ' + name)

# 列表用于循环
for i in range(len(catNames)):
	print('Index ' + str(i) + ' in catNames is: ' +  catNames[i])
    
# in 和 not in 操作符
'AAA' in catNames
'AAA' not in catNames

# 多重赋值
cat = ['fat', 'black', 'loud']
size, color, disposition = cat

# 增强赋值
cat += 'rap'
cat # ['fat', 'black', 'loud', 'rap']

变量的数目和列表的长度必须严格相等，否则 Python 将给出 ValueError

4.3 方法

方法和函数是一回事，只是它是调用在一个值上。方法部分跟在这个值后面，以一个句点分隔。每种数据类型都有它自己的一组方法。例如，列表数据类型有一些有用的方法，用来查找index、添加append/insert、删除remove/del或操作sort列表中的值。

# 用 index()方法在列表中查找值
test = ['aa', 'bb', 'cc', 'cc']
test.index['aa'] # 0
test.index['cc'] # 2
test.index['dd'] # ValueRError

# 用 append()和 insert()方法在列表中添加值
test.append('ee')
test # ['aa', 'bb', 'cc', 'cc', 'ee']

test.insert(0, '00')
test # ['00', 'aa', 'bb', 'cc', 'cc', 'ee']

# 用 remove()方法从列表中删除值
test.remove('00')
test # ['aa', 'bb', 'cc', 'cc', 'ee']
test.remove('00') # ValueError

test.remove('cc')
test # ['aa', 'bb', 'cc', 'ee'] remove the first

# 用 del()方法从列表中删除值
del(test[0])
test # ['bb', 'cc', 'ee']

# 用 sort()方法将列表中的值按 ASCII 字符顺序排序
test.sort(reverse=True) # 逆序
test # ['ee', 'cc', 'bb']
test.sort() # 顺序
test # ['bb', 'cc', 'ee']

test0 = [1, 2, 3, 'a', 'b', 'c'] # 对既有数字又有字符串值的列表
test.sort() # TypeError

# 按照普通的字典顺序排序
test1 = ['a', 'x', 'B', 'M']
test1.sort()
test1 # ['B', 'M', 'a', 'x']
test1.sort(key=str.lower)
test1 # ['a', 'B', 'M', 'x']

4.4 字符串

列表并不是唯一表示序列值的数据类型。例如，字符串和列表实际上很相似，只要你认为字符串是单个文本字符的列表。对列表的许多操作，也可以作用于字符串：按下标取值、切片、用于 for 循环、用于 len()，以及用于 in 和 not in 操作符。

>>> name = 'Zophie'
>>> name[0]
'Z'
>>> name[-2]
'i'
>>> name[0:4]
'Zoph'
>>> 'Zo' in name
True
>>> 'z' in name
False
>>> 'p' not in name
False
>>> for i in name:
		print('* * * ' + i + ' * * *') 
* * * Z * * * 
* * * o * * *
* * * p * * *
* * * h * * *
* * * i * * *
* * * e * * *

但列表和字符串在一个重要的方面是不同的。**列表是“可变的”数据类型，它的值可以添加、删除或改变。 ** 但是，字符串是“不可变的”，它不能被更改。 尝试对字符串中的一个字符重新赋值，将导致 TypeError 错误。

>>> name = 'Zophie a cat'
>>> name[7] = 'the'
Traceback (most recent call last):
	File "<pyshell#50>", line 1, in <module>
		name[7] = 'the'
TypeError: 'str' object does not support item assignment

>>> name = 'Zophie a cat'
>>> newName = name[0:7] + 'the' + name[8:12]
>>> name
'Zophie a cat'
>>> newName
'Zophie the cat'

4.5 元组

除了两个方面，“元组”数据类型几乎与列表数据类型一样。首先，元组输入时用圆括号()，而不是用方括号[]。但元组与列表的主要区别还在于，元组像字符串一样，是不可变的。元组不能让它们的值被修改、添加或删除。

>>> eggs = ('hello', 42, 0.5)
>>> eggs[0]
'hello'
>>> eggs[1:3]
(42, 0.5)
>>> len(eggs)
3

如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，表明这种情况。

>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>

你可以用元组告诉所有读代码的人，你不打算改变这个序列的值。如果需要一个永远不会改变的值的序列，就使用元组。使用元组而不是列表的第二个好处在于，因为它们是不可变的，它们的内容不会变化，Python 可以实现一些优化，让使用元组的代码比使用列表的代码更快。

4.6 类型转换与引用

4.6.1 类型转换

函数 str()、 list()、 tuple()将返回传递给它们的值的字符串、列表、元组版本。

4.6.2 引用

变量保存字符串或整数值，如将 42 赋给 spam 变量，然后拷贝 spam 中的值，将它赋给变量 cheese。当稍后将 spam 中的值改变为 100 时，这不会影响 cheese 中的值。这是因为 spam 和 heese是不同的变量，保存了不同的值。

>>> spam = 42
>>> cheese = spam
>>> spam = 100
>>> spam
100
>>> cheese
42

但列表不是这样的。当你将列表赋给一个变量时，实际上是将列表的“引用”赋给了该变量。引用是一个值，指向某些数据。列表引用是指向一个列表的值。

>>> spam = [0, 1, 2, 3, 4, 5] 
>>> cheese = spam 
>>> cheese[1] = 'Hello!' 
>>> spam
[0, 'Hello!', 2, 3, 4, 5]
>>> cheese
[0, 'Hello!', 2, 3, 4, 5]

4.6.2.1 传递引用

def eggs(someParameter):
	someParameter.append('Hello')
spam = [1, 2, 3]
eggs(spam)
print(spam)

4.6.2.2 copy 模块的 copy()和deepcopy()函数

>>> import copy
>>> spam = ['A', 'B', 'C', 'D']
>>> cheese = copy.copy(spam)
>>> cheese[1] = 42
>>> spam
['A', 'B', 'C', 'D']
>>> cheese
['A', 42, 'C', 'D']

如果要复制的列表中包含了列表，那就使用 copy.deepcopy()函数来代替。deepcopy()函数将同时复制它们内部的列表。

第 5 章 字典和结构化数据

5.1 字典数据类型

像列表一样，“字典”是许多值的集合。但不像列表的下标，字典的索引可以使用许多不同数据类型，不只是整数。字典不是只能使用整数下标，而是可以用各种数据类型作为键：整型、浮点型、字符串或元组。 字典的索引被称为“键”，键及其关联的值称为“键-值”对。在代码中，字典输入时带花括号{}。字典方法**keys()、values()和 items()**将返回类似列表的值，分别对应于字典的键、值和键-值对。这些数据类型（分别是 dict_keys、dict_values 和 dict_items）可以用于for 循环。

>>> myCat = {'size': 'fat', 'color': 'gray'}
>>> myCat['size']
'fat'
>>> 'My cat has ' + myCat['color'] + ' fur.'
'My cat has gray fur.'

>>> for k in myCat.keys():
    	print(k)
size
color
>>> for i in myCat.items():
    	print(i)
('size', 'fat')
('color', 'gray')

# 检查字典中是否存在键或值'
>>> 'color' in myCat
True
>>> 'gray' not in myCat.keys()
False

# get()
>>> 'This is a ' + str(myCat.get('color', 0)) + ' cat'
'This is a gray cat'

# setdefault() -> 为字典中某个键设置一个默认值，当该键没有任何值时使用它
>>> myCat.setdefault('name', 'Tony')
'Tony'
>>> myCat
{'size': 'fat', 'color': 'gray', 'name': 'Tony'}
>>> myCat.setdefault('color', 'white')
'gray'
>>> myCat
{'size': 'fat', 'color': 'gray', 'name': 'Tony'}

5.2 漂亮打印

import pprint
message = 'It was a bright cold day in April, and the clocks were striking
thirteen.'
count = {}

for character in message:
	count.setdefault(character, 0)
	count[character] = count[character] + 1
    
# 显示在屏幕上
pprint.pprint(count) # (1)
print(pprint.pformat(myCat)) # (2)

# 得到漂亮打印的文本作为字符串
pprint.pformat(myCat)

5.3 使用数据结构对真实世界建模

5.3.1 井字棋盘.88

5.3.2 嵌套的字典和列表91

5.4 小结92

5.5 习题93

5.6 实践项目 93

5.6.1 好玩游戏的物品清单93

5.6.2 列表到字典的函数，针对

好玩游戏物品清单94

第 6 章 字符串操作

6.1 处理字符串

>>> myCat = "Tis is Tony's cat" # 双引号中可使用单引号
>>> myCat
"Tis is Tony's cat"
>>> myCat = 'This is Tony\'s cat' # 转义字符 倒斜杠\
>>> myCat
"Tis is Tony's cat"
>>> myCat = r'This is Tony\'s cat' # 原始字符串
>>> myCat
"This is Tony\\'s cat"

# 用三重引号的多行字符串
# 多行注释
“”“This is a letter to my son.
Please send to he.
”“”

>>> print('''Dear Son,
	Nice to meet you!
Yours trutly
Tiny''')
Dear Son,
	Nice to meet you!
Yours trutly
Tiny

# 字符串下标和切片
>>> helloWorld = 'Hello World'
>>> helloWorld[:]
'Hello World'
>>> len(helloWorld)
11
>>> helloWorld[0:6]
'Hello '
>>> helloWorld[5:]
' World'
>>> fizz = helloWorld[4:10]
>>> fizz = helloWorld[4:10]
>>> fizz
'o Worl'

# 字符串的 in 和 not in 操作符
>>> 'hello' in helloWorld
False
>>> 'Hello' in helloWorld
True
>>> 'world' not in helloWorld
True

6.2 有用的字符串方法

6.2.1 字符串方法 upper()、lower()、isX()

test = 'Hello, World!'
>>> test.upper()
'HELLO, WORLD!'
>>> test.lower()
'hello, world!'
>>> test
'Hello, World!'
>>> test.isupper()
False
>>> test.islower()
False

>>> 'abcd'.isalpha() # 只包含字母，并且非空
True
>>> 'hello123'.isalnum() # 只包含字母和数字，并且非空
False
>>> ' \t\n'.isspace() # 只包含空格、制表符和换行，并且非空
True
>>> '123'.isdecimal() # 只包含数字字符，并且非空
False 
>>> 'This is a cat' # 仅包含以大写字母开头、后面都是小写字母的单词
True

6.2.2 字符串方法 startswith()和endswith()

如果它们所调用的字符串以该方法传入的字符串开始或结束，startswith()和 endswith()方法返回 True。否则，方法返回 False。

>>> 'Hello world!'.startswith('Hello')
True
>>> 'Hello world!'.endswith('world!') 
True
>>> 'abc123'.startswith('abcdef')
False
>>> 'abc123'.endswith('12')
False
>>> 'Hello world!'.startswith('Hello world!')
True
>>> 'Hello world!'.endswith('Hello world!')
True

6.2.3 字符串方法 join()和split()

>>> ' '.join(['My', 'name', 'is', 'Tony'])
'My name is Tony'
>>> letter = ('''Dear Son,
	Nice to meet you!
Yours trutly
Tiny''')
>>> letter.split('\n')
['Dear Son,', '\tNice to meet you!', 'Yours trutly', 'Tiny']

6.2.4 用 rjust()、ljust()和 center()方法对齐文本

rjust()和 ljust()字符串方法返回调用它们的字符串的填充版本，通过插入填充字符来对齐文本。center()字符串方法与 ljust()与 rjust()类似，但它让文本居中，而不是左对齐或右对齐。

>>> 'hello'.rjust(10, '*')
'*****hello'
>>> 'hello'.ljust(10, '*')
'hello*****'
>>> 'hello'.center(11, '*')
'***hello***'

6.2.5 用 strip()、rstrip()和 lstrip()删除空白字符

>>> test = '   hello world   '
>>> test.strip()
'hello world'
>>> test.lstrip()
'hello world   '
>>> test.rstrip()
'   hello world'
>>> test.strip(' hdl')
'ello wor'
>>> test.rstrip(' hdl')
'   hello wor'
>>> test.lstrip(' hdl')
'ello world   '

6.2.6 用 pyperclip 模块拷贝copy()粘贴paste()字符串

>>> import pyperclip
>>> pyperclip.copy('Hello world!')
>>> pyperclip.paste()
'Hello world!'

6.3 项目：口令保管箱

第 1 步：程序设计和数据结构

第 2 步：处理命令行参数

第 3 步：复制正确的口令

6.4 项目：在 Wiki 标记中添加无序列表

第 1 步：从剪贴板中复制和粘贴

第 2 步：分离文本中的行，并添加星号

第 3 步：连接修改过的行

第二部分 自动化任务

第 7 章 模式匹配与正则表达式

7.1 不用正则表达式来查找文本模式

def isPhoneNumber(text):
	if len(text) != 13: 
		return False 
	for i in range(0, 3):
		if not text[i].isdecimal(): 
			return False
	if text[3] != '-':
		return False 
	for i in range(4, 8): 
		if not text[i].isdecimal(): 
			return False
	if text[8] != '-':
		return False 
	for i in range(9, 13):
		if not text[i].isdecimal(): 
			return False
	return True 

print('151-8674-4242 is a phone number:') 
print(isPhoneNumber('151-8674-4242'))

7.2 用正则表达式(regex)查找文本模式

# 1.创建正则表达式对象
import re
phoneNumRegex = re.compile(r'\d\d\d-\d\d\d\d-\d\d\d\d')

# 2.匹配 Regex 对象
mo = phoneNumRegex.search('My number is 151-8674-4242.') 
print('Phone number found: ' + mo.group())
## Phone number found: 151-8674-4242

# 利用括号分组
phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d\d)-(\d\d\d\d)')
mo = phoneNumRegex.search('My number is 151-8674-4242.') 
mo.groups() # ('151', '8674', '4242')
mo.groups(0) # '151-8674-4242'
mo.groups(1) # '151'

# 用管道匹配多个分组
testRegex = re.compile(r'good|bad')
mo = testRegex.search('Today is good, though yesterday was bad')
mo.group() # 'good'

mo = testRegex.search('Though yesterday was bad, today is good')
mo.group() # 'bad'

testRegex = re.compile(r'(goo|ba)d')
mo = testRegex.search('Today is good, though yesterday was bad')
mo.group() # 'good'
mo.group(1) # 'goo'

# 用问号实现可选匹配


# 用星号匹配零次或多次


# 用加号匹配一次或多次


# 用花括号匹配特定次数

7.4 贪心和非贪心匹配123

7.5 findall()方法124

7.6 字符分类 .124

7.7 建立自己的字符分类 .125

7.8 插入字符和美元字符 .126

7.9 通配字符 .126

7.9.1 用点-星匹配所有字符127

7.9.2 用句点字符匹配换行127

7.10 正则表达式符号复习 128

7.11 不区分大小写的匹配128

7.12 用 sub()方法替换字符串.129

7.13 管理复杂的正则表达式129

7.14 组合使用 re.IGNOREC ASE、

re.DOTALL 和re.VERBOSE130

7.15 项目：电话号码和 E-mail 地址提取程序130

第 1 步：为电话号码创建一个正则表达式131

第 2 步：为 E-mail 地址创建一个正则表达式132

第 3 步：在剪贴板文本中找到所有匹配132

第 4 步：所有匹配连接成一个字符串，复制到剪贴板133

第 5 步：运行程序133

第 6 步：类似程序的构想.134

第 8 章 读写文件

8.1 文件与文件路径 137

8.1.1 Windows 上的倒斜杠以及OS X 和 Linux 上的正斜杠

8.1.2 当前工作目录

8.1.3 绝对路径与相对路径

8.1.4 用 os.makedirs()创建新文件夹

8.1.5 os.path 模块

8.1.6 处理绝对路径和相对路径

8.1.7 查看文件大小和文件夹内容

8.1.8 检查路径有效性 .143

8.2 文件读写过程 144

8.2.1 用 open()函数打开文件145

8.2.2 读取文件内容 145

8.2.3 写入文件 146

8.3 用 shelve 模块保存变量 147

8.4 用 pprint.pformat()函数保存

变量 148

8.5 项目：生成随机的测验试卷

文件 149

第 1 步：将测验数据保存在一个

字典中 149

第 2 步：创建测验文件，并打乱

问题的次序 150

第 3 步：创建答案选项 .151

第 4 步：将内容写入测验试卷和

答案文件 151

8.6 项目：多重剪贴板 153欢迎加入非盈利Python编程学习交流QQ群783462347，群里免费提供500+本Python书籍！

目 录

第 1 步：注释和 shelf 设置 153

第 2 步：用一个关键字保存剪贴板

内容154

第 3 步：列出关键字和加载关键字的

内容.154

8.7 小结155

8.8 习题155

8.9 实践项目 .156

8.9.1 扩展多重剪贴板.156

8.9.2 疯狂填词156

8.9.3 正则表达式查找.156

第 9 章 组织文件

9.1 shutil 模块 158

9.1.1 复制文件和文件夹.158

9.1.2 文件和文件夹的移动与

改名158

9.1.3 永久删除文件和文件夹160

9.1.4 用 send2trash 模块安全地

删除160

9.2 遍历目录树.161

9.3 用 zipfile 模块压缩文件.162

9.3.1 读取 ZIP 文件163

9.3.2 从 ZIP 文件中解压缩164

9.3.3 创建和添加到 ZIP 文件164

9.4 项目：将带有美国风格日期的

文件改名为欧洲风格日期165

第 1 步：为美国风格的日期创建一个

正则表达式165

第 2 步：识别文件名中的日期

部分166

第 3 步：构成新文件名，并对文件

改名167

第 4 步：类似程序的想法.168

9.5 项目：将一个文件夹备份到一个

ZIP 文件168

第 1 步：弄清楚 ZIP 文件的

名称 168

第 2 步：创建新 ZIP 文件 .169

第 3 步：遍历目录树并添加到

ZIP 文件 170

第 4 步：类似程序的想法 .170

9.6 小结 171

9.7 习题 171

9.8 实践项目. 171

9.8.1 选择性拷贝 171

9.8.2 删除不需要的文件 .172

9.8.3 消除缺失的编号 .172

第 10 章 调试

10.1 抛出异常 174

10.2 取得反向跟踪的字符串 . 175

10.3 断言 176

10.3.1 在交通灯模拟中使用

断言 177

10.3.2 禁用断言 .178

10.4 日志 178

10.4.1 使用日志模块 178

10.4.2 不要用 print()调试180

10.4.3 日志级别 .180

10.4.4 禁用日志 .181

10.4.5 将日志记录到文件 182

10.5 IDLE 的调试器 182

10.5.1 Go .183

10.5.2 Step 183

10.5.3 Over 183

10.5.4 Out 183

10.5.5 Quit 183

10.5.6 调试一个数字相加的

程序 184

10.5.7 断点 185

10.6 小结 187欢迎加入非盈利Python编程学习交流QQ群783462347，群里免费提供500+本Python书籍！

目 录

10.7 习题.187

10.8 实践项目188

第 11 章 从 Web 抓取信息

11.1 项目：利用 webbrowser 模块的

mapIt.py .190

第 1 步：弄清楚 URL.190

第 2 步：处理命令行参数.191

第 3 步：处理剪贴板内容，加载

浏览器191

第 4 步：类似程序的想法.192

11.2 用 requests 模块从 Web 下载

文件.192

11.2.1 用 requests.get()函数下载

一个网页.193

11.2.2 检查错误.193

11.3 将下载的文件保存到硬盘194

11.4 HTML .195

11.4.1 学习 HTML 的资源.195

11.4.2 快速复习.195

11.4.3 查看网页的 HTML

源代码.196

11.4.4 打开浏览器的开发者

工具197

11.4.5 使用开发者工具来寻找

HTML 元素198

11.5 用 BeautifulSoup 模块解析

HTML.199

11.5.1 从 HTML 创建一个

BeautifulSoup 对象200

11.5.2 用select()方法寻找元素.200

11.5.3 通过元素的属性获取

数据202

11.6 项目：“I’m Feeling Lucky”

Google 查找.202

第１步：获取命令行参数，并请求

查找页面 203

第２步：找到所有的结果 .203

第 3 步：针对每个结果打开 Web

浏览器 204

第 4 步：类似程序的想法 .205

11.7 项目：下载所有 XKCD

漫画 205

第 1 步：设计程序 206

第 2 步：下载网页 207

第 3 步：寻找和下载漫画图像207

第 4 步：保存图像，找到前一张

漫画 208

第 5 步：类似程序的想法 .209

11.8 用 selenium 模块控制浏览器 210

11.8.1 启动 selenium 控制的

浏览器 .210

11.8.2 在页面中寻找元素211

11.8.3 点击页面 .212

11.8.4 填写并提交表单212

11.8.5 发送特殊键 213

11.8.6 点击浏览器按钮213

11.8.7 关于 selenium 的更多

信息 214

11.9 小结 214

11.10 习题 214

11.11 实践项目. 215

11.11.1 命令行邮件程序215

11.11.2 图像网站下载215

11.11.3 2048.215

11.11.4 链接验证215

第 12 章 处理 Excel 电子表格

12.1 Excel 文档 217

12.2 安装 openpyxl 模块 218

12.3 读取 Excel 文档. 218

12.3.1 用 openpyxl 模块打开 Excel欢迎加入非盈利Python编程学习交流QQ群783462347，群里免费提供500+本Python书籍！

目 录

文档219

12.3.2 从工作簿中取得工作表.219

12.3.3 从表中取得单元格220

12.3.4 列字母和数字之间的

转换221

12.3.5 从表中取得行和列222

12.3.6 工作簿、工作表、

单元格.223

12.4 项目：从电子表格中读取

数据.223

第 1 步：读取电子表格数据224

第 2 步：填充数据结构.225

第 3 步：将结果写入文件.226

第 4 步：类似程序的思想.227

12.5 写入 Excel 文档227

12.5.1 创建并保存 Excel 文档.227

12.5.2 创建和删除工作表228

12.5.3 将值写入单元格229

12.6 项目：更新一个电子表格229

第 1 步：利用更新信息建立数据

结构230

第 2 步：检查所有行，更新不正确的

价格231

第 3 步：类似程序的思想.231

12.7 设置单元格的字体风格232

12.8 Font 对象232

12.9 公式.234

12.10 调整行和列235

12.10.1 设置行高和列宽.235

12.10.2 合并和拆分单元格236

12.10.3 冻结窗格237

12.10.4 图表238

12.11 小结240

12.12 习题 240

12.13 实践项目.241

12.13.1 乘法表241

12.13.2 空行插入程序 .241

12.13.3 电子表格单元格翻转

程序 242

12.13.4 文本文件到电子表格242

12.13.5 电子表格到文本文件242

第 13 章 处理 PDF 和 Word 文档

13.1 PDF 文档 243

13.1.1 从 PDF 提取文本244

13.1.2 解密 PDF.245

13.1.3 创建 PDF.246

13.1.4 拷贝页面 .246

13.1.5 旋转页面 .247

13.1.6 叠加页面 .248

13.1.7 加密 PDF.249

13.2 项目：从多个 PDF 中合并

选择的页面. 250

第 1 步：找到所有 PDF 文件250

第 2 步：打开每个 PDF 文件251

第 3 步：添加每一页 252

第 4 步：保存结果 252

第 5 步：类似程序的想法 .253

13.3 Word 文档. 253

13.3.1 读取 Word 文档.254

13.3.2 从.docx 文件中取得完整的

文本 254

13.3.3 设置 Paragraph 和 Run 对象

的样式 .255

13.3.4 创建带有非默认样式的

Word 文档257

13.3.5 Run 属性257

13.3.6 写入 Word 文档.258

13.3.7 添加标题 .260

13.3.8 添加换行符和换页符 261

13.3.9 添加图像 .261

13.4 小结 262欢迎加入非盈利Python编程学习交流QQ群783462347，群里免费提供500+本Python书籍！

目 录

13.5 习题.262

13.6 实践项目263

13.6.1 PDF 偏执狂263

13.6.2 定制邀请函，保存为 Word

文档263

13.6.3 暴力 PDF 口令破解

程序264

第 14 章 处理 CSV 文件和 JSON 数据.265

14.1 csv 模块.265

14.1.1 Reader 对象266

14.1.2 在 for 循环中，从 Reader

对象读取数据267

14.1.3 Writer 对象.268

14.1.4 delimiter 和 lineterminator

关键字参数269

14.2 项目：从 CSV 文件中删除

表头 269

第 1 步：循环遍历每个 CSV

文件270

第 2 步：读入 CSV 文件 270

第 3 步：写入 CSV 文件，没有

第一行271

第 4 步：类似程序的想法.272

14.3 JSON 和 API272

14.4 json 模块273

14.4.1 用 loads()函数读取

JSON 273

14.4.2 用 dumps 函数写出

JSON 273

14.5 项目：取得当前的天气数据274

第 1 步：从命令行参数获取

位置274

第 2 步：下载 JSON 数据275

第 3 步：加载 JSON 数据并打印

天气275

第 4 步：类似程序的想法 .277

14.6 小结 277

14.7 习题 277

14.8 实践项目 277

第 15 章 保持时间、计划任务和启动

程序 279

15.1 time 模块 279

15.1.1 time.time()函数 .279

15.1.2 time.sleep()函数 280

15.2 数字四舍五入. 281

15.3 项目：超级秒表 282

第 1 步：设置程序来记录时间282

第 2 步：记录并打印单圈时间283

第 3 步：类似程序的想法 .283

15.4 datetime 模块 284

15.4.1 timedelta 数据类型285

15.4.2 暂停直至特定日期 286

15.4.3 将 datetime 对象转换为

字符串 .287

15.4.4 将字符串转换成 datetime

对象 288

15.5 回顾 Python 的时间函数 288

15.6 多线程 289

15.6.1 向线程的目标函数传递

参数 290

15.6.2 并发问题 .291

15.7 项目：多线程 XKCD 下载

程序 291

第 1 步：修改程序以使用函数292

第 2 步：创建并启动线程 .293

第 3 步：等待所有线程结束 293

15.8 从 Python 启动其他程序 294

15.8.1 向 Popen()传递命令行

参数 295

15.8.2 Task Scheduler、launchd 和欢迎加入非盈利Python编程学习交流QQ群783462347，群里免费提供500+本Python书籍！

目 录

cron 296

15.8.3 用 Python 打开网站.296

15.8.4 运行其他 Python 脚本.296

15.8.5 用默认的应用程序打开

文件297

15.9 项目：简单的倒计时程序298

第 1 步：倒计时298

第 2 步：播放声音文件.298

第 3 步：类似程序的想法.299

15.10 小结 299

15.11 习题300

15.12 实践项目.300

15.12.1 美化的秒表300

15.12.2 计划的 Web 漫画下载301

第 16 章 发送电子邮件和短信303

16.1 SMTP303

16.2 发送电子邮件304

16.2.1 连接到 SMTP 服务器304

16.2.2 发送 SMTP 的“Hello”

消息305

16.2.3 开始 TLS 加密306

16.2.4 登录到 SMTP 服务器306

16.2.5 发送电子邮件306

16.2.6 从 SMTP 服务器断开307

16.3 IMAP 307

16.4 用 IMAP 获取和删除电子

邮件 307

16.4.1 连接到 IMAP 服务器308

16.4.2 登录到 IMAP 服务器309

16.4.3 搜索电子邮件309

16.4.4 选择文件夹309

16.4.5 执行搜索.310

16.4.6 大小限制.312

16.4.7 取邮件并标记为已读312

16.4.8 从原始消息中获取电子

邮件地址 .313

16.4.9 从原始消息中获取正文.314

16.4.10 删除电子邮件 .315

16.4.11 从 IMAP 服务器断开.315

16.5 项目：向会员发送会费提醒

电子邮件 316

第 1 步：打开 Excel 文件 316

第 2 步：查找所有未付成员 317

第 3 步：发送定制的电子邮件

提醒 318

16.6 用 Twilio 发送短信 319

16.6.1 注册 Twilio 账号319

16.6.2 发送短信 .320

16.7 项目：“只给我发短信”

模块 321

16.8 小结 322

16.9 习题 323

16.10 实践项目 323

16.10.1 随机分配家务活的电子

邮件程序 323

16.10.2 伞提醒程序 324

16.10.3 自动退订 324

16.10.4 通过电子邮件控制你的

电脑 324

第 17 章 操作图像327

17.1 计算机图像基础 327

17.1.1 颜色和 RGBA 值 328

17.1.2 坐标和 Box 元组329

17.2 用 Pillow 操作图像 330

17.2.1 处理 Image 数据类型 331

17.2.2 裁剪图片 .332

17.2.3 复制和粘贴图像到其他

图像 333

17.2.4 调整图像大小 335

17.2.5 旋转和翻转图像 336欢迎加入非盈利Python编程学习交流QQ群783462347，群里免费提供500+本Python书籍！

目 录

17.2.6 更改单个像素338

17.3 项目：添加徽标.339

第 1 步：打开徽标图像.340

第 2 步：遍历所有文件并打开

图像341

第 3 步：调整图像的大小.341

第 4 步：添加徽标，并保存

更改342

第 5 步：类似程序的想法.343

17.4 在图像上绘画344

17.4.1 绘制形状.344

17.4.2 绘制文本.346

17.5 小结.347

17.6 习题.348

17.7 实践项目348

17.7.1 扩展和修正本章项目的

程序348

17.7.2 在硬盘上识别照片

文件夹.349

17.7.3 定制的座位卡350

第 18 章 用 GUI 自动化控制键盘和

鼠标351

18.1 安装 pyautogui 模块 .351

18.2 走对路 352

18.2.1 通过注销关闭所有程序.352

18.2.2 暂停和自动防故障装置.352

18.3 控制鼠标移动353

18.3.1 移动鼠标.354

18.3.2 获取鼠标位置354

18.4 项目：“现在鼠标在

哪里？”355

第 1 步：导入模块355

第 2 步：编写退出代码和无限

循环355

第 3 步：获取并打印鼠标坐标356

18.5 控制鼠标交互. 357

18.5.1 点击鼠标 .357

18.5.2 拖动鼠标 .357

18.5.3 滚动鼠标 .359

18.6 处理屏幕 360

18.6.1 获取屏幕快照 360

18.6.2 分析屏幕快照 360

18.7 项目：扩展 mouseNow 程序 361

18.8 图像识别 362

18.9 控制键盘 363

18.9.1 通过键盘发送一个

字符串 .363

18.9.2 键名 364

18.9.3 按下和释放键盘 365

18.9.4 热键组合 .365

18.10 复习 PyAutoGUI 的函数 366

18.11 项目：自动填表程序. 367

第 1 步：弄清楚步骤 368

第 2 步：建立坐标 368

第 3 步：开始键入数据 .370

第 4 步：处理选择列表和单选

按钮 371

第 5 步：提交表单并等待 .372

18.12 小结 372

18.13 习题 373

18.14 实践项目 373

18.14.1 看起来很忙 373

18.14.2 即时通信机器人 .373

18.14.3 玩游戏机器人指南 374

附录 A 安装第三方模块375

附录 B 运行程序377

附录 C 习题答案 .381