一本书让你识编程、懂编程、会编程
培养编程思维，做Python编程高手
字符串的深入
目前编写的许多程序都涉及字符串的使用，但方法并不很丰富。目前为止，字
符串主要涉及输入和输出。如从键盘和文件中读取输入的字符串，并将字符串作为程序输出，发送到屏幕和文件。
许多程序不只是为了输入读取字符串和输出写入的字符串，还要对字符串执行
相关处理。如处理大量文本时，需要广泛地使用字符串。Email 程序和搜索引擎也是对字符串执行操作的典型程序。
Python 提供了各种检查和操作字符串的工具、编程技术。其实，字符串是一个
序列，第6 章中很多有关序列的概念也适用于字符串。
6.1 字符串的基本操作
6.1.1 访问字符串中的单个字符
一些编程任务要求访问字符串中的各个字符。常见的要求如设置网站的密码。出于安全考虑，许多网站要求设置的密码至少包含一个大写字母、一个小写字母和
一个数字。当我们设置密码的时候，程序会检查每个字符，以确保密码符合这些要求（在本章后面会介绍该程序的例子）。
在本节中，我们将介绍两种可以在Python 中访问字符串中单个字符的操作——
for 循环和索引。
用for循环迭代字符串
访问字符串中单个字符最简单的方法之一是使用for 循环。一般格式如下：
for variable in string:
Statement
Statement
etc.
其中，variable 是变量的名称，string 是字符串或引用字符串的变量。每次循环
迭代时，variable 将从第一个字符开始依次引用字符串中的每个字符副本。这个循环遍历了字符串中的所有字符。如下：
>>> string='python'
>>> for char in string:
print(char)
pyt
hon
图6-1 演示了循环迭代时char 变量是如何引用字符串的字符副本的。
图6-1 在字符串'python'上迭代
程序6-1 展示了另一个例子。该程序用来统计用户在控制台输入的一个字符串
中字符a 的个数（忽略大写和小写）。
程序6-1 string_demo1.py
#用户在控制台输入一个字符串，统计其中字符a出现的次数（忽略大写和小写）
#输入字符串
string=input("请输入字符串:")
#定义a的数量
a_count=0
#遍历字符串
for str in string:
if str=="a" or str=="A":
a_count=a_count+1
print('字符串为',string)
print('字符串中a出现的次数为',a_count)
程序输入
请输入字符串:wjawjdaawaAEJNA
程序输出
字符串为wjawjdaawaAEJNA
字符串中a出现的次数为6
6.1.2 索引
访问字符串中字符的另一种方法是使用索引。字符串中的每个字符都有索引指
定其在字符串中的位置。索引从0 开始，所以第一个字符的索引是0，第二个字符的索引是1，以此类推。字符串中最后1 个字符的索引比字符串中的字符总数小1。
图6-2 展示了字符串“Hello World”中的每个字符的索引。该字符串共有11 个
字符，所以字符索引的范围是从0 到10。
可以使用索引取回字符串中单个字符的副本，如图6-2 所示。
>>> my_string='Hello World'
>>> char=my_string[6]
图6-2 字符串索
图6-3 从字符串获取字符的副本
第二条语句中的表达式“my_string[6]”返回my_string 中在索引6 位置上的字
符副本。执行完这条语句后，char 将引用“W”。如图6-3 所示。
还有一个例子：
>>> my_string='Hello World'
>>> print(my_string[0],my_string[6],my_string[10])
H W d
也可以用同样的方法对字符串进行负数索引，标识字符在整个字符串中的位置。
Python 解释器使用负数索引与字符串长度来确定字符的位置。索引-1 标识该字符串的最后一个字符，索引-2 标识该字符串最后一个字符前的一个字符，以此类推。
>>> my_string='Hello World'
>>> print(my_string[-1],my_string[-2],my_string[-3])
d l r
程序6-2 string_demo2.py
#用户在控制台输入一个字符串，并将整个字符串中的字符分别按正序和逆序输出
#输入字符串
string=input("请输入字符串:")
#顺序输出
for str in string:
print(str,end=' ')
#逆序输出
for i in range(len(string)):
print(string[-i-1],end=' ')
程序输入
请输入字符串:HelloWorld
程序输出
H e l l o W o r l d
d l r o W o l l e H
6.1.3 IndexError 异常
对于特定的字符串，如果使用超出范围的索引，则会发生IndexError 异常。例如：
字符串“python”有6 个字符，所以有效的索引从0 到5（有效的负数索引从-1 到-6）。
下面的示例代码会导致IndexError 异常。
>>> string='python'
>>> print(string[6])
Traceback (most recent call last):
File "<pyshell#43>", line 1, in <module>
print(string[6])
IndexError: string index out of range
这种类型的错误最有可能发生在循环过程中迭代次数超过了字符串末尾的情
况，如下所示：
city='Beijing'
index=0
while index<8:
print(city[index])
index+=1
这个循环的最后一次迭代，index 变量将被赋值为7，是字符串“Beijing”的一
个无效索引，因此会导致IndexError 异常。
6.1.4 len() 函数
在第5 章介绍了len() 函数，它返回序列的长度。len() 函数同样也能获取字符
串的长度，如下所示：
>>>string ='python'
>>>size=len(string)
>>>print(size)
6
第二条语句将变量string 作为参数调用len() 函数。该函数的返回值是6，是字符串“python”的长度，这个值赋给了size 变量。len() 函数可以防止循环迭代超出
字符串的末尾，如下所示：
>>> string='python'
>>> index=0
>>> while index<len(string):
print(string[index])
index=index +1
p
y
t
h
o
n
注意：只要索引小于字符串的长度，循环就会一直迭代。这是因为字符串中最
后一个字符的索引始终比字符串的长度小1。
6.1.5 连接字符串
在Python 中，比较常见的字符串操作就是连接或追加一个字符串到另一个字符
串的末尾。在前面的章节中，我们了解到使用“+”运算符连接字符串的操作。“+”运算符将两个字符串组合起来生成一个新的字符串。如下：
>>> my_string='Hello'+'World'
>>> print(my_string)
HelloWorld
第一行连接字符串“Hello”和“Wor1d”产生字符串“HelloWorld”，然后将字
符串“HelloWorld”分配给my_string 变量。第二行打印了my_string 变量引用的字符串。
下面是展示连接字符串的另一个交互式会话：
>>> first_name='Tom'
>>> last_name='Mark'
>>> full_name=first_name+' '+last_name
>>> print(full_name)
Tom Mark
第一行将字符串“Tom”赋给了first_name 变量；第二行将字符串“Mark”赋
给了last_name 变量；第三行将两个字符串通过一个空格连接在一起，生成的字符
串赋给了full_name 变量；第四行打印了full_name 引用的字符串；输出结果显示在第五行。
当然，在进行字符串拼接操作时，也可以使用“+=”运算符执行连接。以下交
互式会话演示了这一过程：
>>> first_str='Hello'
>>> str='World'
>>> str +=first_str
>>> print(str)
WorldHello
程序6-3 string_demo3.py
#创建一个英文字母列表，并将列表按照空格相隔，拼接成一个新字符串
#创建空字符串
my_string=' '
#创建字母列表
letter_list=[]
for number in range(97,123):
#创建字符
char=chr(number)
#将字符添加到列表中
letter_list.append(char)
#拼接字符串
for char in letter_list:
my_string=my_string+char+' '
print("拼接后的字母字符串为",my_string)
程序输出
拼接后的字母字符串为a b c d e f g h i j k l m n o p q r s t u v w x y z
6.1.6 字符串是不可变的
在Python 的数据类型中，字符串是无法被修改的，这就意味着一旦创建字符串，
就无法改变。一些对字符串的操作，如连接，我们会认为它们修改了字符串，但实
际上并没有。如下：
>>> name='Jack'
>>> print("名字是",name)
名字是Jack
>>> name=name +' '+'Tom'
>>> print("现在的名字是",name)
现在的名字是Jack Tom
第一行中的语句将字符串“Jack”赋给name 变量，如图6-4 所示；第四行中的
语句将字符串“Jack”通过空格和字符串“Tom”连接，并将结果赋给name 变量，如图6-5 所示。
从图中可以看出，原始字符串“Jack”未被修改。相反，一个包含“Jack Tom”
的新字符串被创建并分配给name 变量（原来的字符串“Jack”不可用，Python 解释器最终会从内存中销毁不可用的字符串）。
图6-4 字符串“Jack”赋给name 图6-5 字符串“Jack Tom”赋给name
6.2 字符串的切片
在第5 章中已经介绍过切片是从序列中截取的一组元素。当从字符串中取出一
个切片时，便可以从字符串中获取一组字符。字符串切片也称为子串。
从字符串中获取切片的表达式为：
string[start:end]
其中，start 是切片中第一个字符的索引，end 是标记切片结尾的索引。该表达
式返回一个包含从start 开始到end 结束（但不包括）的所有字符副本的字符串。如下：
>>> my_string='Hello World'
>>> cut_string=my_string[6:10]
第6 章 字符串的深入 133
>>> print(cut_string)
Worl
第二条语句将字符串“Worl”赋给cut_string，如果在切片表达式中没有指定
start 索引，Python 将使用字符串的开头作为起始索引。如下：
>>> my_string='Hello World'
>>> cut_string=my_string[:5]
>>> print(cut_string)
Hello
第二条语句将字符串“Hello”赋给cut_string。如果切片表达式没有指定end 索引，Python 将字符串的最后一个元素作为结束索引。如下：
>>> my_string='Hello World'
>>> cut_string=my_string[2:]
>>> print(cut_string)
llo World
第二条语句将字符串“llo World”赋给cut_string。如果切片表达式中start 和
end 都不指定，会输出什么呢？如下：
>>> my_string='Hello World'
>>> cut_string=my_string[:]
>>> print(cut_string)
Hello World
可见，当start 和end 都不指定时，会截取整个字符串。上面的字符串切片都是
连续的字符片段。切片表达式也能设置步长，使字符串中的部分字符被忽略。如下：
>>> letters='abcdefghijklmnopqrstuvwxyz'
>>> print(letters[0:26:2])
acegikmoqsuwy
注意：无效的索引不会使切片表达式触发异常。
如果end 索引指定了一个超过字符串结尾的位置，Python 将使用字符串的长度
代替；如果start 指定了一个超出字符串起始的位置，Python 将会使用0 代替；如果start 索引比end 索引大，切片表达式将返回空字符串。
程序6-4 string_demo4.py
#用户输入一个字符串并对该字符串进行切片操作
#输入字符串
string=input("请输入字符串:")
print("字符串为",string)
print("截取前面三个元素:",string[0:3])
print("截取后三个元素:",string[-3:-1])
print("截取全部元素:",string[:])
print("截取从第三个元素开始的所有元素:",string[2:])
目录
第1 章 Python 基础入门
1.1 Python 的基本介绍
1.1.1 Python 简介
1.1.2 Python 的前世今生
1.1.3 Python 的特点
1.2 搭建Python 的开发环境
1.2.1 Python 的下载
1.2.2 Python 的安装
1.2.3 Python 的环境变量配置
1.2.4 运行Python
习 题
第2 章 Python 语言基础
2.1 Python 的基本语法和特点
2.1.1 Python 的基本语法结构
2.1.2 Python 中的变量
2.2 基本的数据类型
2.2.1 数字（number）类型
2.2.2 字符串（string）类型
2.2.3 列表（list）类型
2.2.4 元组（tuple）类型
2.2.5 集合（set）类型
2.2.6 字典（dictionary）类型
2.2.7 Python 数据类型的转换
2.3 Python 的基本输入和基本输出
2.3.1 基本输入——input() 函数
2.3.2 输出——print() 函数
2.4 运算符和表达式.
2.4.1 运算符
2.4.2 运算符优先级
2.4.3 表达式
2.5 海龟绘图简介
2.5.1 线条绘制
2.5.2 线条的转向
2.5.3 线条朝向设置指定的角度
2.5.4 获取线条的方向
2.5.5 画笔的抬起和落下
2.5.6 绘制圆和点及修改画笔的宽度
2.5.7 改变画笔的颜色和背景的颜色
2.5.8 重新设置屏幕及设置屏幕的窗口的大小
2.5.9 移动海龟画笔到指定的位置
2.5.10 获取当前画笔所在位置
2.5.11 控制画笔的速度和隐藏画笔
2.5.12 显示文本
2.5.13 图形填充
2.5.14 让图形窗口保持开放状态
习 题
第3 章 流程控制
3.1 程序结构
3.2 选择结构语句
3.2.1 单分支结构语句
3.2.2 双分支结构语句
3.2.3 多分支结构语句
3.2.4 嵌套语句
3.2.5 字符串比较
3.3 循环语句
3.3.1 for 循环
3.3.2 while 循环
3.3.3 while 嵌套
3.3.4 循环关键字
3.4 海龟图形库: 判断海龟的状态
3.4.1 获取海龟的位置和朝向
3.4.2 检测画笔的状态
3.4.3 获取画笔的颜色
3.4.4 获取画笔的线宽
3.4.5 获取画笔的移动速度
3.5 海龟图形库: 使用循环语句进行绘图设计
习 题
第4 章 Python 函数编程
4.1 函数的定义和调用
4.1.1 Python 函数的定义
4.1.2 Python 函数的调用
4.2 函数的参数
4.2.1 必选参数
4.2.2 默认参数
4.2.3 可变参数
4.2.4 关键字参数
4.2.5 参数组合
4.3 函数返回值
4.3.1 指定返回值和隐含返回值
4.3.2 return 语句的位置和多条return 语句.
4.3.3 返回值类型
4.3.4 函数嵌套
4.4 作用域
4.5 Python 匿名函数（lambda）
4.5.1 匿名函数与普通函数对比
4.5.2 匿名函数的优点
4.5.3 匿名函数的多种形式
4.5.4 lambda 作为一个参数传递
4.5.5 lambda() 函数与Python 内置函数配合使用
4.5.6 lambda 作为函数的返回值
4.6 其他高阶函数
4.6.1 map() 函数
4.6.2 reduce() 函数
4.6.3 filter() 函数
4.6.4 sorted() 函数
4.7 随机库:random
4.7.1 标准库函数和import 语句
4.7.2 产生随机数
4.7.3 random()、randrange()、uniform() 函数
4.7.4 随机数种子
习 题
第5 章 列表与元组
5.1 序列
5.2 列表的简介
5.2.1 重复运算符
5.2.2 列表的索引
5.2.3 len() 函数
5.2.4 列表是可变的
5.2.5 连接列表
5.3 列表切片
5.4 in 操作符
5.5 列表的内置函数
5.5.1 append() 方法
5.5.2 index() 方法
5.5.3 insert() 方法.
5.5.4 sort() 方法
5.5.5 remove() 方法
5.5.6 reverse() 方法
5.5.7 del 语句
5.5.8 min() 函数和max() 函数
5.6 复制列表
5.6.1 列表的复制
5.6.2 处理列表
5.7 二维列表
5.8 元组
5.8.1 元组基础
5.8.2 列表和元组间的转换
习 题
第6 章 字符串的深入
6.1 字符串的基本操作
6.1.1 访问字符串中的单个字符
6.1.2 索引
6.1.3 IndexError 异常
6.1.4 len() 函数
6.1.5 连接字符串
6.1.6 字符串是不可变的
6.2 字符串的切片
6.3 测试、搜索和操作字符串
6.3.1 使用in 和not in 测试字符串
6.3.2 字符串方法
6.3.3 字符串的测试方法
6.3.4 修改方法
6.3.5 搜索和替换
习 题
第7 章 字典和集合
7.1 字典的简介
7.1.1 字典的概念
7.1.2 创建字典
7.1.3 从字典中检索值
7.1.4 使用in 和not in 操作符判断字典中的值
7.2 字典的操作
7.2.1 向已有字典中添加元素
7.2.2 删除元素
7.2.3 获取字典中元素的数量
7.2.4 字典中数据类型的混合
7.2.5 创建空字典
7.2.6 使用for 循环遍历字典
7.3 字典的函数
7.3.1 clear() 方法
7.3.2 get() 方法
7.3.3 items() 方法
7.3.4 keys() 方法
7.3.5 pop() 方法
7.3.6 popitem() 方法
7.3.7 values() 方法
7.4 字典操作实例
7.4.1 程序1
7.4.2 程序2
7.4.3 程序3
7.5 集合及其操作
7.5.1 创建集合
7.5.2 获取集合中元素的数量
7.5.3 添加和删除元素
7.5.4 使用for 循环在集合上迭代
7.5.5 使用in 和not in 操作符判断集合中的值
7.6 集合间的操作
7.6.1 求集合的并集
7.6.2 求集合的交集
7.6.3 求两个集合的差集
7.6.4 求集合的对称差集
7.6.5 求子集和超集
习 题
第8 章 面向对象程序设计
8.1 面向对象编程概述
8.2 封装、继承、多态
8.2.1 封装（Encapsulation）
8.2.2 继承（Inheritance）
8.2.3 多态（Polymorphism）
8.3 类的定义和使用
8.3.1 类的定义
8.3.2 构造方法__init__()
8.3.3 实例属性和实例方法
8.3.4 类的使用
8.4 面向对象的各种方法
8.4.1 静态方法（用@staticmethod表示）
8.4.2 类方法（用@classmethod表示）
8.4.3 属性方法（用@property表示）
8.5 高级面向对象
8.5.1 成员修饰符
8.5.2 特殊成员
8.5.3 类与对象
8.5.4 异常处理
8.5.5 反射/ 自省
8.5.6 单例模式
习 题
第9 章 Python 模块
9.1 模块的简介和使用
9.1.1 模块分类
9.1.2 模块引入
9.2 Python 导入自定义模块的方法
9.2.1 将两个文件放在同一级别的目录下
9.2.2 将自定义模块打包
9.2.3 在test.py 中设置模块搜索路径
9.2.4 使用.pth 文件
9.3 Python 中的包
9.3.1 介绍.
9.3.2 包的安装和发布
9.4 常见的Python 模块
9.4.1 Python 标准库
9.4.2 Python 第三方模块
习 题.
第10 章 异常处理及程序调试
10.1 异常介绍
10.1.1 异常概述.
10.1.2 异常捕获
10.1.3 采用traceback 模块查看异常
10.2 程序调试
10.2.1 断点打印法
10.2.2 断言
10.2.3 logging 日志
10.2.4 pdb 调试
10.2.5 IDE 调试
习 题
第11 章 文件及目录操作
11.1 基本文件操作
11.1.1 打开文件
11.1.2 关闭文件
11.1.3 写入文件
11.1.4 读取文件
11.2 目录操作
11.2.1 os 和os.path 模块
11.2.2 路径
11.2.3 判断目录是否存在
11.2.4 创建目录
11.2.5 删除目录
11.3 高级文件操作8
习 题
第12 章 使用进程和线程
12.1 进程
12.1.1 什么是进程？
12.1.2 什么是多进程？
12.1.3 创建进程
12.1.4 多进程修改全局变量
12.1.5 multiprocessing 创建进程
12.1.6 进程间通信
12.2 线程
12.2.1 线程的状态
12.2.2 线程简单使用
12.2.3 同步和通信
12.2.4 线程池
习 题
第13 章 递归
13.1 递归简介
13.2 递归求解
13.3 使用递归计算阶乘
13.4 递归算法示例
13.4.1 递归求解列表中元素的和
13.4.2 斐波纳奇数列
13.4.3 求解最大公约数
习 题
习题答案
温馨提示：请使用泸西县图书馆的读者帐号和密码进行登录
