资源简介

(共123张PPT)
单元4
序列数据操作与格式化输出
Python程序设计
知识入门
知识要点
1．Python 序列 2．Python 的成员运算符 3．Unicode 字符串 4．Python 字符所占的字节数 5．Python 的转义字符 6．Python 的三引号
1．Python 序列
（1）索引
序列中的每一个元素都有一个索引。从左向右计数为正索引，正索引从0 开始递增，即索引值为0 表示第1 个元素，索引值为1 表示第2 个元素，依此类推。从右向左计数为负索引，负索引从最后一个元素开始计数，即最后一个元素的索引值是-1，倒数第2 个元素的索引值是-2，依此类推。通过索引可以访问序列中的任何元素。
1．Python 序列
（2）计算序列的长度、最大元素和最小元素
在Python 中，使用内置函数len() 计算序列的长度，即返回序列中包含多少个元素；使用max() 函数返回序列中的最大元素；使用min() 函数返回序列中的最小元素。
（3）检查某个元素是否是序列的成员
在Python 中，可以使用in 关键字检查某个元素是否是指定序列的成员，即检查某个元素是否包含在指定序列中。如果某个元素是指定序列的成员，则返回True，否则返回False。
也可以使用not in 关键字检查某个元素是否不包含在指定的序列中。如果某个元素不是指定序列的成员，则返回True，否则返回False。
1．Python 序列
（4）序列相加
Python 支持两个相同类型的序列进行连接，即使用“+”运算符实现两个相同类型序列的连接。
在进行序列连接时，序列必须同为列表、元组、集合或字符串等，序列中的元素类型可以不同。
1．Python 序列
（5）截取序列
在序列中可以通过截取操作访问一定范围内的元素，生成一个新的序列。可以使用中括号截取序列，截取序列的基本语法格式如下。
序列名称[start:end:step]
start 表示截取序列的开始位置（包括该位置），如果不指定开始位置，则默认开始位置为0，即从序列的第1 个元素开始截取。
end 表示截取序列的结束位置（不包括该位置），如果不指定结束位置，则默认结束位置为最后一个元素。
step 表示截取序列的步长，按照该步长遍历序列的元素，如果不指定步长，则默认步长为1，即一个一个地遍历序列。当省略步长时，最后一个冒号也可以省略。
2．Python 的成员运算符
序号 运算符 描述
1 in 如果在指定的序列中找到元素，则返回True，否则返回False
2 not in 如果在指定的序列中没有找到元素，则返回True，否则返回False
>>>a = 10
>>>b = 20
>>>list = [1, 2, 3, 4, 5 ];
>>>print( a in list )
>>>print( b not in list )
示例如下。
False
True
>>>a = 2 # 修改变量 a 的值
>>>print( a in list )
运行结果1
运行结果2
True
3．Unicode 字符串
在Python 2 中，普通字符串是以8 位ASCII 值进行存储的，而Unicode 字符串则存储为16 位，这样能够表示更多的字符集。在Python 3 中，所有的字符串都是Unicode 字符串。
4．Python 字符所占的字节数
在Python 中，不同类型的字符所占的字节数也不同，数字、英文字母、小数点、下划线、空格等半角字符只占一个字节；汉字在GB2312/GBK 编码中占两个字节，在UTF-8/Unicode编码中一般占用3 个字节。
5．Python 的转义字符
序号 转义字符 描述
1 \(在行尾时) 续行符
2 \\ 反斜杠符号
3 \' 单引号
4 \" 双引号
5 \a 响铃
6 \b 退格(Backspace)
7 \0 空
8 \n 换行符
9 \v 纵向制表符
10 \t 横向制表符，用于横向跳到下一制表位
11 \r 回车
12 \f 换页
13 \oyy 八进制数，yy代表的字符，例如：\o12代表换行，其中o是字母，不是数字0
14 \xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
15 \other 其它的字符以普通格式输出
6．Python 的三引号
Python 使用三引号（“"""”或“'''”）可实现一个字符串跨多行，字符串中可以包含换行符“\n”、制表符“\t”以及其他特殊字符。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串为WYSIWYG（所见即所得）格式。
三引号的典型使用场合有HTML 代码编辑、SQL 语句编辑。示例代码如下。
循序渐进
知识要点
4.1　列表的创建与应用 4.1.1　创建列表 4.1.2　访问列表元素 4.1.3　截取列表 4.1.4 连接与重复列表 4.1.5　修改与添加列表元素 4.1.6　删除列表元素 4.1.7　列表运算符 4.1.8　Python列表的内置函数与基本方法 【任务4-1】遍历列表 4.2　元组的创建与应用 4.2.1　创建元组 4.2.2　访问元组元素费 4.2.3　截取元组 4.2.4　连接与重复元组 4.2.5　修改元组元素 4.2.6　删除元组元素 4.2.7　元组运算符 4.2.8　元组的内置函数与基本方法 【任务4-2】遍历元组 4.3　字典的创建与应用 4.3.1　创建字典 4.3.2　访问字典的值 4.3.3　修改与添加字典的值 4.3.4　删除字典元素 4.3.5　字典的内置函数与基本方法 【任务4-3】遍历字典 4.4　集合的创建与应用 4.4.1　创建集合 4.4.2　修改与添加集合的元素 4.4.4　集合的内置函数与基本方法4.4.5　集合的集合运算 【任务4-4】遍历集合 4.5　字符串的常用方法及应用
4.5.1　创建字符串
4.5.2　访问字符串中的值
4.5.3　截取字符串
4.5.4　连接与重复字符串
4.5.5　修改与添加字符串中的字符
4.5.6　字符串运算符
4.5.7　Python字符串常用的内置
函数与基本方法
【任务4-5】应用字符串的方法实现
字符串翻转操作
4.6　字符串的格式化输出
4.6.1　format()的基本语法格式
4.6.2　format()的参数序号
【任务4-6】使用format()方法格式化输出字符串列表.
4.1.1　创建列表
1．使用赋值运算符直接创建列表
可以使用赋值运算符“=”直接将一个列表赋给变量，其基本语法格式如下。
变量名称=[ 元素1, 元素2, 元素3,…, 元素n]
列表元素的数据类型和个数都没有限制，只要是Python 支持的数据类型都可以，但为了增强程序的可读性，一般情况下，列表中各个元素的数据类型是相同的。
示例如下。
>>>x = ['a', 'b', 'c']
>>>n = [1, 2, 3]
4.1.1　创建列表
2．创建空列表
在Python 中，可以创建空列表，基本语法格式如下。
变量名=[]
在Python 中，可以使用list() 函数创建数值列表，基本语法格式如下。
list(data)
其中，data 表示可以转换为列表的数据，其类型可以是range 对象、字符串、元组或者其他可迭代的数据类型。
3．使用list() 函数创建数值列表
>>>list(range(5,15,2))
示例
运行结果
[5, 7, 9, 11, 13]
4.1.1　创建列表
4．创建嵌套列表
在Python 中还可以创建嵌套列表，即在列表里创建其他列表。
运行结果
[['a', 'b', 'c'], [1, 2, 3]]
>>>list[0]
运行结果
['a', 'b', 'c']
>>>list[0][1]
运行结果
'b'
>>>x = ['a', 'b', 'c']
>>>n = [1, 2, 3]
>>>list = [x, n]
>>>list
示例如下。
4.1.2　访问列表元素
列表中的每一个元素都有一个编号（也称为索引）。索引从左至右从0 开始递增，即索引值为0 表示第1 个元素，索引值为1 表示第2 个元素，依次类推。列表及索引如图所示。
列表的索引也可以使用负数，最右一个元素的索引为-1，倒数第2 个元素的索引为-2，依次类推。使用索引可以访问列表中的任何元素，访问列表元素的基本语法格式如下。
列表[ 索引]
4.1.2　访问列表元素
对于列表list=['a', 'b', 'c', 'd', 'e']，访问其中元素的各种形式及示例如表所示。
序号 基本语法格式 说明 实例
1 列表名 返回列表所有元素 list
2 列表名[i] 返回列表中索引为i的元素，即第i+1个元素 list[0]、list[1]、list[2]
3 列表名[-i] 返回列表中从右开始读了的第i个元素 list[-1]、list[-2]
输出列表fieldName 的所有元素： [' 商品ID', ' 图书名称', ' 价格', ' 商品编码', ' 出版社']
逐个输出列表fieldName 的前3 个元素： 商品ID 图书名称 价格
逐个输出列表fieldName 的后2 个元素： 商品编码 出版社
4.1.2　访问列表元素
【实例4-1】演示以多种形式访问列表中的元素
fieldName=[" 商品ID"," 图书名称"," 价格"," 商品编码"," 出版社"]
print(" 输出列表fieldName 的所有元素：",fieldName)
print(" 逐个输出列表fieldName 的前3 个元素：",fieldName[0],fieldName[1],fieldName[2])
print(" 逐个输出列表fieldName 的后2 个元素：",fieldName[-2],fieldName[-1])
实例4-1 的代码如下所示。
实例4-1 代码的运行结果如下。
4.1.3　截取列表
截取操作是访问列表元素的一种方法，可以访问一定范围内的多个元素。列表被截取后返回一个包含所需元素的新列表。
对于列表list=['a', 'b', 'c', 'd', 'e']，截取其中元素的各种形式及示例如表所示。
序号 基本语法格式 说明 实例
1 列表名[i:j] 截取列表中索引号为i至j的元素 list[1:3]
2 列表名[i:] 截取列表中索引号为i的元素至最后1个之间的所有元素 list[2:]
3 列表名[:j] 截取列表中第1个元素至索引号为j-1之间的所有元素 list[:3]
4 列表名[:] 截取列表中所有元素 list[:]
5 列表名[i:j:k] 从列表第i个元素开始，每隔k个截取1个列表中的元素，直到列表第j-1个元素为止 list[1:3:2]
4.1.3　截取列表
对于列表list=['a', 'b', 'c', 'd', 'e']，从左向右的索引值分别为0、1、2、3、4，从右向左的索引值分别为-1、-2、-3、-4、-5。列表list 的截取示意图如图所示。
4.1.3　截取列表
【实例4-2】演示以多种形式截取列表
bookData=["1","HTML5+CSS3 移动Web 开发实战","58.00","50676377587"
," 人民邮电出版社"]
print(" 输出列表bookData 所有元素1 ：",bookData)
print(" 输出列表bookData 所有元素2 ：",bookData[:])
print(" 输出列表bookData 第2 至第3 个元素：",bookData[1:3])
print(" 输出列表bookData 第2 个与第5 个元素：",bookData[1:5:3])
实例4-2 的代码如下所示。
实例4-2 代码的运行结果如下。
4.1.4 连接与重复列表
列表支持连接与重复操作，加号“+”用于连接列表，星号“*”用于重复列表。
将列表list1 元素增加到列表list 中的基本语法格式如下。
list+=list1
也可以使用extend() 实现上述操作，基本语法格式如下。
list.extend(list1)
将list 列表的元素重复n 次生成一个新列表的基本语法格式如下。
list*=n
输出重复2 次的列表： [' 人民邮电出版社', ' 人民邮电出版社']
输出两个列表的连接结果： ['2', '给Python点颜色 青少年学编程', '59.80', '54792975925', '人民邮电出版社']
4.1.4 连接与重复列表
【实例4-3】演示列表的连接与重复操作
publisher=[" 人民邮电出版社"]
bookData1=["2"," 给Python 点颜色 青少年学编程"]
bookData2=["59.80","54792975925"," 人民邮电出版社"]
print(" 输出重复2 次的列表：",publisher*2)
print(" 输出两个列表的连接结果：",bookData1+bookData2)
实例4-3 的代码如下所示。
实例4-3 代码的运行结果如下。
4.1.5　修改与添加列表元素
1．修改列表元素
要修改列表中的元素，只需要通过索引找到相应元素，然后为其重新赋值即可。
修改列表元素的基本语法格式如下。
list[i]=x
即将列表list 中索引值为i 的元素值替换为x。
>>>list = [1, 2, 3, 4, 5, 6]
>>>list [0] = 9
>>>list [2:5] = [13, 14, 15]
>>>list
示例如下。
[9, 2, 13, 14, 15, 6]
运行结果
4.1.5　修改与添加列表元素
1．修改列表元素
也可以修改指定区间的列表中的元素值，用列表list1 替换列表list 中索引为i 到j-1 的元素的基本语法格式如下。
list[i:j]=list1
>>>letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>>list1=['B', 'C', 'D']
>>>letters[1:3] =list1
>>>letters
示例如下。
['a', 'B', 'C', 'D', 'd', 'e', 'f', 'g']
运行结果
4.1.5　修改与添加列表元素
2．在列表末尾添加元素
可以使用append() 方法在列表的末尾添加新元素，在list 列表的末尾添加元素x 的基本语法格式如下。
list.append(x)
>>>list = [1, 2, 3, 4, 5, 6]
>>>list.append(7)
>>>list
示例如下。
[1, 2, 3, 4, 5, 6, 7]
运行结果
4.1.6　删除列表元素
1．将列表元素赋为空值
在Python 中，列表中的元素是可以删除的。
>>>list = [1, 2, 3, 4, 5, 6]
>>>list[2:5] = [] # 删除列表中第3 至第5 个元素
>>>list
示例如下。
[1, 2, 6]
>>>list[:] = [] # 清除列表
>>>list
运行结果如下。
运行结果如下。
[]
4.1.6　删除列表元素
2．使用del 语句删除列表元素
在Python 中可以使用del 语句来删除列表的元素，删除列表list 中索引为i 到j-1 且以k为步长的元素，其基本语法格式如下。
del list[i:j:k]
>>>list = [1, 2, 3, 4, 5, 6]
>>>del list[2]
>>>print (" 删除第3 个元素后的列表：",list)
>>>list
示例如下。
删除第3 个元素后的列表：[1, 2, 4, 5, 6]
运行结果
4.1.7　列表运算符
序号 python表达式 运算结果 说明
1 [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
2 ['go!'] * 3 ['go!', 'go!', 'go!'] 重复
3 3 in [1, 2, 3] True 元素是否存在于列表中
4 for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代
Python 中列表的成员运算符有in 和not in。in 用于检查指定元素是否是列表成员，即检查列表中是否包含指定元素。其基本语法格式如下。
元素 in 列表
4.1.7　列表运算符
>>>list=[1,2,3,4]
>>>3 in list
示例如下
True
运行结果
如果列表中存在指定元素，则返回值为True，否则返回值为False。
在Python 中，也可以使用not in 检查指定元素是否不包含在指定的列表中。其基本语法格式如下。
元素 not in 列表
>>>list=[1,2,3,4]
>>>5 not in list
示例如下
True
运行结果
4.1.8　Python 列表的内置函数与基本方法
1．Python 列表的内置函数
序号 函数格式 说明
1 len(list) 返回列表list元素个数，即列表的长度
2 max(list) 返回列表list元素最大值
3 min(list) 返回列表list元素最小值
4 sum(list[,start]) 返回列表list元素的和，其中start用于指定统计结果的开始位置，是可选参数，如果没有指定，默认值为0
5 sorted(list, key=None ,reverse=False) 对列表list元素进行排序，并且使用该函数进行排序会建立一个原列表的副本，该副本为排序后的列表，原列表的元素顺序不会改变。其中，key用于指定排序规则；reverse为可选参数，如果将其值指定为True，则表示降序排列，如果为False，则表示升序排列，默认为升序排列
6 reversed(list) 反向列表list中的元素
7 str(list) 将列表list转换为字符串
8 list(seq) 将元组seq转换为列表
9 enumerate(list) 将列表list组合为一个索引列表，多用于for循环语句中
4.1.8　Python 列表的内置函数与基本方法
2．Python 列表的基本方法
序号 方法格式 说明
1 list.append(x) 在列表list末尾添加新的元素x
2 list.extend(seq) 在列表list末尾一次性追加另一个序列中的多个元素（用新列表扩展原来的列表）
3 list.insert(i,x) 在列表list的第i位置插入新元素x
4 list.copy() 复制列表list生成新的列表
5 list.pop([index=-1]) 移除列表list中的一个元素（默认最后一个元素），且返回该元素的值
list.pop(i) 将列表list中的第i项元素删除
6 list.remove(x) 移除列表list中x元素值的第一个匹配项
7 list.clear() 清空列表list，即删除列表list中的所有元素
8 list.reverse() 反向列表list中元素
9 list.sort(key=None ,reverse=False) 对原列表list进行排序，并且使用该方法进行排序会改变原列表的元素排列顺序。其中key表示指定一个从每个列表元素中提取一个用于比较的键；reverse为可选参数，如果将其值指定为True，则表示降序排列，如果为False，则表示升序排列，默认为升序排列
10 list.index(x) 从列表list中找出指定元素值首次匹配项的索引值
11 list.count(x) 统计指定元素在列表list中出现的次数
遍历列表
【任务4-1】
【任务描述】
（1）在PyCharm 中创建项目“Unit04”。
（2）在项目“Unit04”中创建Python 程序文件“t4-1.py”。
（3）使用for 循环语句遍历列表，输出列表中所有元素的值。
（4）使用for 循环语句结合enumerate() 函数遍历列表，输出列表中所有元素的索引值和元素值。
【任务4-1】
01
【任务实施】
02
创建PyCharm 项目“Unit04”
成功启动PyCharm 后，在指定位置“D:\PycharmProject\”创建PyCharm 项目“Unit04”。
创建Python 程序文件“t4-1.py”
在PyCharm 项目“Unit04”中，新建Python 程序文件“t4-1.py”，PyCharm 窗口中显示程序文件“t4-1.py”的代码编辑区域，在该程序文件的代码编辑区域中自动添加了模板内容。
【任务4-1】
03
【任务实施】
04
编写Python 代码
运行Python 程序
遍历输出列表bookData 所有元素：
遍历输出列表bookData 所有元素及其索引：
循序渐进
知识要点
4.1　列表的创建与应用 4.1.1　创建列表 4.1.2　访问列表元素 4.1.3　截取列表 4.1.4 连接与重复列表 4.1.5　修改与添加列表元素 4.1.6　删除列表元素 4.1.7　列表运算符 4.1.8　Python列表的内置函数与基本方法 【任务4-1】遍历列表 4.2　元组的创建与应用 4.2.1　创建元组 4.2.2　访问元组元素费 4.2.3　截取元组 4.2.4　连接与重复元组 4.2.5　修改元组元素 4.2.6　删除元组元素 4.2.7　元组运算符 4.2.8　元组的内置函数与基本方法 【任务4-2】遍历元组 4.3　字典的创建与应用 4.3.1　创建字典 4.3.2　访问字典的值 4.3.3　修改与添加字典的值 4.3.4　删除字典元素 4.3.5　字典的内置函数与基本方法 【任务4-3】遍历字典 4.4　集合的创建与应用 4.4.1　创建集合 4.4.2　修改与添加集合的元素 4.4.4　集合的内置函数与基本方法4.4.5　集合的集合运算 【任务4-4】遍历集合 4.5　字符串的常用方法及应用
4.5.1　创建字符串
4.5.2　访问字符串中的值
4.5.3　截取字符串
4.5.4　连接与重复字符串
4.5.5　修改与添加字符串中的字符
4.5.6　字符串运算符
4.5.7　Python字符串常用的内置
函数与基本方法
【任务4-5】应用字符串的方法实现
字符串翻转操作
4.6　字符串的格式化输出
4.6.1　format()的基本语法格式
4.6.2　format()的参数序号
【任务4-6】使用format()方法格式化输出字符串列表.
4.2.1　创建元组
1．使用赋值运算符创建元组
创建元组只需要将元组的所有元素放在一对小括号“()”中，两个相邻元素之间用半角逗号“,”隔开。
创建元组时，可以使用赋值运算符“=”直接将一个元组赋给变量，基本语法格式如下。
变量名=( 元素1, 元素2, 元素3,…, 元素n)
可以将整数、浮点数、字符串、列表、元组等Python 支持的任何类型的内容作为元素值放入元组中，并且在同一个元组中，元素的类型也可以不同，因为元组的元素之间没有相关关系。元组中元素个数也没有限制。
>>>tuple1 = (1, 2, 3, 4, 5 )
>>>tuple1
>>>tuple2 = "a", "b", "c", "d"
>>>tuple2
示例如下
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd')
>>>type(tuple2)
运行结果

4.2.1　创建元组
2．创建空元组
在Python 中，也可以创建空元组。创建空元组（即包含0 个元素的元组）的基本语法格式如下。
tuple = () # 空元组
3．创建只包含一个元素的元组
创建包含0 个或一个元素的元组是个特殊的问题，所以有一些额外的语法规则。当元组中只包含一个元素时，需要在元素后面添加半角逗号，否则小括号会被当作运算符使用。
>>>tuple1 = (50,)
>>>type(tuple1)
示例如下

>>>tuple2 = (50)
>>>type(tuple2)
运行结果
4.2.1　创建元组
4．创建元素类型不同的元组
元组中的元素类型也可以不相同，示例如下。
>>>bookData=(2," 给Python 点颜色 青少年学编程",59.80," 人民邮电出版社")
>>>bookData
运行结果如下。
(2, ' 给Python 点颜色 青少年学编程', 59.8, ' 人民邮电出版社')
4.2.1　创建元组
5．使用tuple() 函数创建数值元组
在Python 中，可以使用tuple() 函数创建数值元组，其基本语法格式如下。
tuple(data)
其中，data 表示可以转换为元组的数据，其类型可以是range 对象、字符串、元组或者其他可迭代的数据类型。
可以直接使用range() 函数创建数值列表。
>>>tuple(range(5,15,2))
示例如下
运行结果如下
(5, 7, 9, 11, 13)
4.2.2　访问元组元素
可以使用索引来访问元组中的元素，元组的索引从0 开始，也可以进行截取。示例如下。
>>>tuple = (1, 2, 3, 4, 5, 6, 7 )
>>>print(tuple) # 输出完整元组，结果包括小括号“()”
>>>print(tuple[0]) # 输出元组的第1 个元素
>>>print(tuple[2]) # 输出元组的第3 个元素
>>>print(tuple[-2]) # 反向读取，输出元组的倒数第2 个元素
运行结果如下。
(1, 2, 3, 4, 5, 6, 7)
136
4.2.3　截取元组
因为元组也是序列，所以可以访问元组中指定位置的元素，也可以截取其中的一段元素。
示例如下。
>>>tuple = (1, 2, 3, 4, 5, 6, 7 )
>>>print(tuple) # 输出元组的全部元素
>>>print(tuple[1:3]) # 输出第2 个元素到第3 个元素
>>>print(tuple[2:]) # 输出从第3 个元素开始的所有元素
运行结果如下。
(1, 2, 3, 4, 5, 6, 7)
(2, 3)
(3, 4, 5, 6, 7)
4.2.4 连接与重复元组
元组也支持连接与重复操作，加号“+”用于连接元组，星号“*”用于重复元组。
示例如下。
>>>tuple1, tuple2 = (1, 2, 3), (4, 5, 6)
>>>tuple= tuple1+tuple2 # 连接元组，连接的内容必须都是元组
>>>print(tuple)
>>>print(tuple * 2) # 输出2 次元组
运行结果如下。
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6)
【说明】在进行元组连接操作时，连接的内容必须都是元组，不能将元组和列表或者字符进行连接。如果要连接的元组只有一个元素，不要忘记在这个元素后面添加半角逗号“,”。
4.2.4 连接与重复元组
【实例4-4】演示以多种形式访问元组中的元素
fieldName=(" 商品ID"," 图书名称"," 价格"," 商品编码"," 出版社")
bookData=("1","HTML5+CSS3 移动Web 开发实战","58.00","50676377587"," 人民邮电出版社")
print(" 输出元组fieldName 所有元素：",fieldName)
print(" 输出元组bookData 所有元素：",bookData[:])
print(" 输出元组fieldName 第2 个元素：",fieldName[1])
print(" 输出元组fieldName 倒数第1 个元素：",fieldName[-1])
print(" 输出元组bookData 第2 个与第5 个元素：",bookData[1:5:3])
print(" 输出元组bookData 第2 至第3 个元素：",bookData[1:3])
实例4-4 的代码如下
实例4-4 代码的运行结果
4.2.5　修改元组元素
元组中的单个元素值是不允许修改的，示例如下。
>>>tuple = (1, 2, 3, 4, 5, 6)
>>>print(tuple[0], tuple[1:5])
运行结果如下。
1 (2, 3, 4, 5)
>>>tuple[0] = 11 # 修改元组中元素的操作是非法的
执行以上代码会出现如下所示的异常信息。
Traceback (most recent call last):
File "", line 1, in
TypeError: 'tuple' object does not support item assignment
4.2.5　修改元组元素
但可以对元组重新赋值，示例如下。
>>>bookData=("1","HTML5+CSS3 移动Web 开发实战","58.00"," 人民邮电出版社")
>>>bookData=("3"," 零基础学Python（全彩版）","79.80"," 吉林大学出版社")
>>>print(" 输出元组bookData 修改后的所有元素：",bookData)
运行结果如下。
输出元组bookData 修改后的所有元素： ('3', ' 零基础学Python（全彩版）', '79.80', ' 吉林大学出版社')
虽然元组的元素不可改变，但它可以包含可变的对象，例如列表。示例如下。
>>>tuple = (1, 2, 3, 4, [5, 6])
>>>print(tuple)
运行结果如下。
(1, 2, 3, 4, [5, 6])
>>>tuple[4][0] = 15 # 修改元组中列表元素的元素是可以的
>>>print(tuple)
运行结果如下。
(1, 2, 3, 4, [15, 6])
4.2.6　删除元组元素
元组中的元素是不允许删除的，但可以使用del 语句来删除整个元组，示例如下。
>>>tuple = (1, 2, 3, 4, 5, 6)
>>>tuple[0]=()
执行以上代码会出现以下异常信息。
File "", line 1, in
TypeError: 'tuple' object does not support item assignment
>>>del tuple
>>>print(tuple[0])
元组被删除后，输出元组的元素会出现异常信息，如下所示。
Traceback (most recent call last):
File "", line 1, in
TypeError: 'type' object is not subscriptable
4.2.7　元组运算符
序号 Python表达式 结果 说明
1 (1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
2 ('Go!',) * 3 ('Go!', 'Go!', 'Go!') 复制
3 3 in (1, 2, 3) True 元素是否存在
4 for item in (1, 2, 3): print(item, end=" ") 1 2 3 迭代
4.2.8　元组的内置函数与基本方法
1．Python 元组的内置函数
序号 函数格式 功能描述 实例 实例运行结果
1 len(tuple) 计算元组元素个数 >>>tuple = ('1', '2', '3') >>>len(tuple) 3
2 max(tuple) 返回元组中元素最大值 >>>tuple = ('5', '4', '8') >>>max(tuple) 8
3 min(tuple) 返回元组中元素最小值 >>>tuple = ('5', '4', '8') >>>min(tuple) 4
4.2.8　元组的内置函数与基本方法
2．Python 元组的基本方法
（1）count() 方法
（2）index() 方法
（3）sorted() 方法
该方法用于统计元组指定元素出现的次数，例如：tuple.count('str')。
该方法用于查看指定元素的索引，例如：tuple.index('str')。
该方法用于对元组的元素进行排序，例如：sorted(tuple)。
>>>tuple = ('1', '2', '3', '1', '2', '3')
>>>tuple.index('2')
>>>tuple.count('2')
>>>sorted(tuple)
示例如下
12
['1', '1', '2', '2', '3', '3']
运行结果
遍历元组
【任务4-2】
【任务描述】
（1）在项目“Unit04”中创建Python 程序文件“4-2.py”。
（2）使用for 循环语句遍历元组，输出元组中所有元素的值。
（3）使用for 循环语句结合enumerate() 函数遍历元组，输出元组中所有元素及其索引。
【任务4-2】
01
【任务实施】
02
创建Python 程序文件“t4-2.py”
编写Python 代码
【任务4-2】
【任务实施】
03
运行Python 程序
程序文件“t4-2.py”的运行结果如下。
遍历输出元组bookData 所有元素及其索引：
循序渐进
知识要点
4.1　列表的创建与应用 4.1.1　创建列表 4.1.2　访问列表元素 4.1.3　截取列表 4.1.4 连接与重复列表 4.1.5　修改与添加列表元素 4.1.6　删除列表元素 4.1.7　列表运算符 4.1.8　Python列表的内置函数与基本方法 【任务4-1】遍历列表 4.2　元组的创建与应用 4.2.1　创建元组 4.2.2　访问元组元素费 4.2.3　截取元组 4.2.4　连接与重复元组 4.2.5　修改元组元素 4.2.6　删除元组元素 4.2.7　元组运算符 4.2.8　元组的内置函数与基本方法 【任务4-2】遍历元组 4.3　字典的创建与应用 4.3.1　创建字典 4.3.2　访问字典的值 4.3.3　修改与添加字典的值 4.3.4　删除字典元素 4.3.5　字典的内置函数与基本方法 【任务4-3】遍历字典 4.4　集合的创建与应用 4.4.1　创建集合 4.4.2　修改与添加集合的元素 4.4.4　集合的内置函数与基本方法4.4.5　集合的集合运算 【任务4-4】遍历集合 4.5　字符串的常用方法及应用
4.5.1　创建字符串
4.5.2　访问字符串中的值
4.5.3　截取字符串
4.5.4　连接与重复字符串
4.5.5　修改与添加字符串中的字符
4.5.6　字符串运算符
4.5.7　Python字符串常用的内置
函数与基本方法
【任务4-5】应用字符串的方法实现
字符串翻转操作
4.6　字符串的格式化输出
4.6.1　format()的基本语法格式
4.6.2　format()的参数序号
【任务4-6】使用format()方法格式化输出字符串列表.
4.3.1　创建字典
1．直接使用大括号“{}”创建字典
定义字典时，字典的所有元素放入大括号“{}”中，每个元素都包含两个部分，即“键”和“值”。字典的每个键与值用半角冒号“:”分隔，每两个元素（键值对）之间用半角逗号“,”分隔，基本语法格式如下所示。
dictionary = {key1 : value1, key2 : value2,…, keyn : valuen}
示例如下。
>>>dict = {"name":" 李明","age":21,"gender":" 男","math":86,"english":92}
>>>dict1 = {"name":" 李明","age":21,"gender":" 男"}
>>>dict2 = {"math":86,"english":92}
字典值可以是任何的Python 对象，既可以是标准的对象，也可以是用户定义的对象，但键不行。
4.3.1　创建字典
1．直接使用大括号“{}”创建字典
（1）在同一个字典中，键必须是唯一的。
字典中不允许同一个键出现两次。创建字典时如果同一个键被赋值两次，后一个值会覆盖前一个值，示例如下。
>>>dict = {"name":" 李明","age":21,"gender":" 男","math":86,"english":92,
"name":"LiMing"}
>>>print(dict)
>>>print(dict["name"])
运行结果如下。
{'name': 'LiMing', 'age': 21, 'gender': ' 男', 'math': 86, 'english': 92}
LiMing
（2）字典的键必须是不可变类型，而值可以是任何数据类型，并且值不是必须唯一。
4.3.1　创建字典
2．创建空字典
（1）使用空的大括号{} 创建空字典。
>>>dictionary = {}
# 创建空字典
>>> print(dictionary)
示例如下。
{}
运行结果
（2）使用dict() 方法创建空字典。
>>>dictionary=dict()
>>>print(dictionary)
示例如下。
{}
运行结果
4.3.1　创建字典
3．通过映射函数创建字典
使用dict() 方法和zip() 函数通过已有数据快速创建字典，其基本语法格式如下。
dictionary=dict(zip(listkey,listvalue))
其中，zip() 函数用于将多个列表或元组对应位置的元素组合为元组，并返回包含这些内容的zip 对象。如果想得到元组，可以使用tuple() 函数将zip 对象转换为元组；如果想得到列表，则可以使用list() 函数将zip 对象转换为列表。
例如，listkey 是一个用于指定要生成字典的键的列表，listvalue 是一个用于指定要生成字典的值的列表。
>>>listkey=["name","age","gender"]
>>>listvalue =[" 李明",21, " 男"]
>>>dictionary=dict(zip(listkey,listvalue))
>>>print(dictionary)
代码如下
运行结果如下
{'name': ' 李明', 'age': 21, 'gender': ' 男'}
4.3.1　创建字典
4．通过给定的“键参数”创建字典
使用dict() 方法，通过给定的“键参数”创建字典的基本语法格式如下。
dictionary =dict(key1=value1, key2=value2,…, keyn=valuen)
其中，key1、key2……keyn 表示参数名，必须是唯一的，并且要符合Python 标识符的命名规则，这些参数名会转换为字典的键；value1、value2……valuen 表示参数值，可以是任何数据类型，不一定是唯一的，这些参数值将被转换为字典的值。
>>>dictionary = dict(name=" 李明",age=21,gender=" 男")
>>>print(dictionary)
示例代码如下
运行结果如下
{'name': ' 李明', 'age': 21, 'gender': ' 男'}
4.3.1　创建字典
4．通过给定的“键参数”创建字典
通过已经存在的元组和列表创建字典，其基本语法格式如下。
dictionary={tuple:list}
其中，tuple 表示作为键的元组，list 表示作为值的列表。
使用dict 对象的fromkeys() 方法创建值为空的字典，其基本语法格式如下。
dictionary=dict.fromkeys(list)
其中，list 表示字典的键列表。
4.3.2　访问字典的值
1．通过键值对访问字典的值
字典中的元素以“键”信息为索引进行访问，把相应的“键”放入中括号中即可访问字典的值。在Python 中使用字典的get() 方法也可获取指定键的值。
【实例4-5】演示以多种形式访问字典的键与值
实例4-5代码如下所示。
dict = {"name":" 李明","age":21,"gender":" 男","math":86,"english":92}
print(dict["name"]," ",dict["age"]) # 通过键查询
print(dict) # 输出完整的字典
print(dict.keys()) # 输出所有键
print(dict.values()) # 输出所有值
4.3.2　访问字典的值
实例4-5 代码的运行结果如下。
李明 21
{'name': ' 李明', 'age': 21, 'gender': ' 男', 'math': 86, 'english': 92}
dict_keys(['name', 'age', 'gender', 'math', 'english'])
dict_values([' 李明', 21, ' 男', 86, 92])
如果使用字典里没有的键访问数据，会出现异常，示例如下。
>>>print(dict["Name"])
执行以上代码会出现以下异常信息。
Traceback (most recent call last):
File "D:/PycharmProject/Practice/Unit04/p4-8.py", line 11, in
print(dict["Name"]," ",dict["age"])
KeyError: 'Name'
4.3.2　访问字典的值
2．遍历字典
Python 提供了遍历字典的方法，使用字典的items() 方法可以获取字典的全部键值对列表，其基本语法格式如下。
dictionary.items()
其中，dictionary 表示字典对象，返回值为可遍历的键值对的元组。想要获取具体的键值对，可以通过for 循环遍历该元组。
Python 中还提供了keys() 和values() 方法，分别用于返回字典的键和值的列表，想要获取具体的键和值，可以通过for 循环遍历该列表。
4.3.3　修改与添加字典的值
字典长度是可变的，可以通过对“键”信息赋值的方法实现增加或修改键值对。向字典中添加元素的基本语法格式如下。
dictionary[key]=value
其中，key 表示要添加元素的键，必须是唯一的，并且不可变，可以是字符串、数字或元组；value 表示要添加元素的值，可以是任何Python 支持的数据类型，不是必须唯一。可以先创建空字典，然后添加字典的值。
>>>dict = {}
>>>dict["name"] = " 李明"
>>>dict["age"]=22
>>>dict["gender"]=" 男"
>>>print(dict)
代码如下
运行结果如下
{'name': ' 李明', 'age': 22, 'gender': ' 男'}
4.3.3　修改与添加字典的值
由于在字典中，键必须是唯一的，如果新添加元素的键与已经存在的键重复，则将使用新值替换原来该键的值，这就相当于修改字典的元素。
示例如下。
>>>dict = {"name":" 李明","age":21,"gender":" 男"}
>>>dict["age"]=23 # 修改age 的值
>>>dict["math"]=90 # 添加一个键值对
>>>print(dict)
运行结果如下。
{'name': ' 李明', 'age': 23, 'gender': ' 男', 'math': 90}
4.3.4　删除字典元素
在Python 中，使用del 语句可以删除字典中的一个元素，也能删除字典。
>>>dict = {"name":" 李明","age":21,"gender":" 男"}
>>>del dict["age"] # 删除键值对age
>>>print(dict)
示例如下
运行结果如下
{'name': ' 李明', 'gender': ' 男'}
如果输出一个不存在字典中的键，将会出现异常。
>>>del dict # 删除字典dict
>>>print(dict["name"])
示例如下
运行结果如下
Traceback (most recent call last):
File "", line 1, in
TypeError: 'type' object is not subscriptable
4.3.4　删除字典元素
【实例4-6】演示访问、修改与删除字典元素
实例4-6的代码如下所示。
4.3.4　删除字典元素
【实例4-6】演示访问、修改与删除字典元素
实例4-6 代码的运行结果下所示。
4.3.5　字典的内置函数与基本方法
1．字典的内置函数
Python 字典的内置函数及示例如表所示。各示例中的字典为dict = {"name":" 李明","age":21,"gender":" 男"}。
序号 基本语法格式 函数描述 实例 结果
1 len(dict) 计算字典元素个数，即键的总数。 len(dict) 3
2 str(dict) 输出字典，以可打印的字符串表示 str(dict) "{'name': '李明', 'age': 21, 'gender': '男'}"
3 type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型 type(dict)
4.3.5　字典的内置函数与基本方法
2．字典的基本方法
序号 方法的基本语法格式 说明
1 dictionary.clear() 删除字典内所有元素（键值对）
2 dictionary.copy() 返回一个字典的复制副本
3 dictionary.fromkeys(seq[, value]) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 dictionary.get(key, default=None) 返回指定键的值，如果值不在字典中则返回default值，如果省略了默认值，则返回None
5 key in dictionary 如果键在字典dictionary里存在则返回True，否则返回False
6 dictionary.items() 以列表返回可遍历的(键,值)对
7 dictionary.keys() 返回字典的所有键信息
8 dictionary.values() 返回字典的所有值信息
9 dictionary.setdefault(key, default=None) 和get()类似，但如果键在字典中不存在，将会添加键并将值设为default
10 dictionary.update(dict2) 把字典dict2的键值对更新到dictionary里
11 dictionary.pop(key[,default]) 删除字典给定键key所对应的值，返回被删除的值。key值必须给出，否则，返回default值
12 dictionary.popitem() 随机返回并删除字典中的最后一个键值对元素
【任务描述】
【任务4-3】遍历字典
（1）在项目“Unit04”中创建Python 程序文件“t4-3.py”。
（2）使用for 循环语句遍历字典，输出字典中所有元素的值。
（3）使用for 循环语句结合items() 方法遍历字典，输出字典中所有元素的键和值。
【任务4-3】遍历字典
01
【任务实施】
02
创建Python 程序文件“t4-3.py”
在程序文件“t4-3.py”中编写代码
运行程序文件“t4-3.py”
03
循序渐进
知识要点
4.1　列表的创建与应用 4.1.1　创建列表 4.1.2　访问列表元素 4.1.3　截取列表 4.1.4 连接与重复列表 4.1.5　修改与添加列表元素 4.1.6　删除列表元素 4.1.7　列表运算符 4.1.8　Python列表的内置函数与基本方法 【任务4-1】遍历列表 4.2　元组的创建与应用 4.2.1　创建元组 4.2.2　访问元组元素费 4.2.3　截取元组 4.2.4　连接与重复元组 4.2.5　修改元组元素 4.2.6　删除元组元素 4.2.7　元组运算符 4.2.8　元组的内置函数与基本方法 【任务4-2】遍历元组 4.3　字典的创建与应用 4.3.1　创建字典 4.3.2　访问字典的值 4.3.3　修改与添加字典的值 4.3.4　删除字典元素 4.3.5　字典的内置函数与基本方法 【任务4-3】遍历字典 4.4　集合的创建与应用 4.4.1　创建集合 4.4.2　修改与添加集合的元素 4.4.4　集合的内置函数与基本方法4.4.5　集合的集合运算 【任务4-4】遍历集合 4.5　字符串的常用方法及应用
4.5.1　创建字符串
4.5.2　访问字符串中的值
4.5.3　截取字符串
4.5.4　连接与重复字符串
4.5.5　修改与添加字符串中的字符
4.5.6　字符串运算符
4.5.7　Python字符串常用的内置
函数与基本方法
【任务4-5】应用字符串的方法实现
字符串翻转操作
4.6　字符串的格式化输出
4.6.1　format()的基本语法格式
4.6.2　format()的参数序号
【任务4-6】使用format()方法格式化输出字符串列表.
4.4.1　创建集合
1．直接使用大括号“{}”创建集合
使用大括号“{}”创建集合的基本语法格式如下。
sets = {element1, element2, element3,…,elementn}
其中，sets 表示集合的名称，可以是任何符合Python 命名规则的标识符；element1、element2、element3、elementn 表示集合中的元素，元素个数没有限制，并且只要是Python支持的数据类型就可以。
在创建集合时，如果出现了重复的元素，Python 会自动只保留一个，重复的元素被自动去掉。
>>>fruits = {" 苹果", " 橘子", " 苹果", " 梨", " 橘子", " 香蕉"}
>>>print(fruits) # 输出集合，重复的元素被自动去掉
示例如下
{' 苹果', ' 梨', ' 香蕉', ' 橘子'}
运行结果如下
4.4.1　创建集合
2．使用set() 函数创建集合
在Python 中创建集合时推荐使用set() 函数，可以使用set() 函数将列表、元组等其他可迭代对象转换为集合。使用set() 函数创建集合的基本语法格式如下。
sets =set(iteration)
其中，iteration 表示要转换为集合的可迭代对象，可以是列表、元组、range 对象等，也可以是字符串，如果是字符串，返回的集合将包含全部不重复字符。
>>>fruits1 = set([" 苹果", " 橘子", " 梨"," 香蕉"])
>>>print(fruits1)
示例如下
运行结果如下
{' 苹果', ' 梨', ' 香蕉', ' 橘子'}
>>>fruits2 = set((" 苹果", " 橘子", " 梨", " 香蕉"))
运行结果如下
{' 苹果', ' 梨', ' 香蕉', ' 橘子'}
4.4.2　修改与添加集合的元素
添加集合元素的基本语法格式如下。
sets.add( x )
添加的元素只能是字符串、数字、布尔值（True 或False）、元组等不可变对象，不能列表、字典等可变对象。如果元素已存在，则不进行任何操作。
>>>fruits = {" 苹果", " 橘子"}
>>>fruits.add(" 香蕉")
>>>print(fruits)
示例如下。
{' 苹果', ' 香蕉', ' 橘子'}
运行结果
4.4.2　修改与添加集合的元素
还有一个方法，也可以用于添加集合元素，并且参数可以是列表、元组、字典等，其基本语法格式如下。
sets.update( x )
添加的元素可以有多个，用半角逗号分开。
>>>fruits = {" 苹果", " 橘子"}
>>>fruits.update({" 香蕉"})
>>>print(fruits)
示例如下
运行结果如下
{' 苹果', ' 香蕉', ' 橘子'}
>>>fruits = {" 苹果", " 橘子"}
>>>fruits.update([" 香蕉", " 梨"])
>>>print(fruits)
运行结果如下
{' 苹果', ' 梨', ' 香蕉', ' 橘子'}
4.4.3　删除集合元素
1．移除集合元素
从集合中移除元素的基本语法格式如下。
sets.remove( x )
如果指定的元素不存在，则执行移除操作会出现异常。
>>>fruits = {" 苹果", " 橘子", " 梨", " 香蕉"}
>>>fruits.remove(" 梨")
>>>print(fruits)
示例如下
运行结果如下
>>>fruits = {" 苹果", " 橘子", " 梨", " 香蕉"}
>>>fruits.remove(" 樱桃") # 指定删除的集合元素不存在时，会出现异常
Traceback (most recent call last):
File "", line 1, in
KeyError: ' 樱桃'
4.4.3　删除集合元素
1．移除集合元素
还有一个方法discard() 也能用于移除集合中的元素，并且当指定元素不存在时，不会出现异常。其基本语法格式如下所示。
sets.discard( x )
示例如下
>>>fruits = {" 苹果", " 橘子", " 梨", " 香蕉"}
>>>fruits.discard (" 梨")
>>>fruits.discard (" 樱桃") # 指定删除的集合元素不存在时，不会出现异常
>>>print(fruits)
运行结果如下
{' 苹果', ' 香蕉', ' 橘子'}
4.4.3　删除集合元素
2．随机删除集合中的一个元素
使用pop() 方法可以实现随机删除集合中的一个元素，其基本语法格式如下。
sets.pop()
集合的pop() 方法会对集合进行无序排列，然后将这个无序排列集合左侧的第一个元素删除。
>>>fruits = {" 苹果", " 橘子", " 梨", " 香蕉"}
>>>fruits.pop()
示例如下。
' 苹果'
>>>fruits.pop()
运行结果如下。
' 梨'
运行结果
使用pop() 方法随机删除集合中的元素时，多次运行的结果都不一样。
4.4.3　删除集合元素
3．清空集合
使用clear() 方法可以删除集合中的全部元素，实现清空集合，其基本语法格式如下。
set.clear()
示例如下
>>>fruits = {" 苹果", " 橘子", " 梨", " 香蕉"}
>>>fruits.clear()
>>>print(fruits)
运行结果如下
set()
4.4.3　删除集合元素
【实例4-7】演示Python 集合中添加与删除元素的操作
实例4-7 的代码如下所示
实例4-7 代码的运行结果如下
4.4.4　集合的内置函数与基本方法
1．计算集合元素个数
使用len() 方法可以计算集合的元素个数，其基本语法格式如下。
len(sets)
示例如下
>>>fruits = {" 苹果", " 橘子", " 梨", " 香蕉"," 樱桃"}
>>>len(fruits)
运行结果如下
5
4.4.4　集合的内置函数与基本方法
2．判断指定元素在集合中是否存在
（1）使用运算符in 的基本语法格式如下
（2）使用运算符not in 的基本语法格式如下
x in sets
判断元素x 是否在集合sets 中，x 若在集合sets 中则返回True，否则返回False。
x not in sets
判断元素x 是否在集合sets 中，x 若不在集合sets 中则返回True，否则返回False。
>>>fruits = {" 苹果", " 橘子", " 梨", " 香蕉"," 樱桃"}
>>>" 樱桃" in fruits
示例如下。
True
>>>" 草莓" not in fruits
运行结果如下。
True
运行结果
4.4.5　集合的集合运算
两个集合可以进行集合运算，集合运算中常见的是并运算（使用“|”运算符）、交运算（使用“&”运算符）、差运算（使用“-”运算符）。
【实例4-8】演示两个集合间的多种运算
实例4-8 的代码如下
所示。
实例4-8 代码的运行结果如下。
遍历集合
【任务4-4】遍历集合
【任务描述】
（1）在项目“Unit04”中创建Python 程序文件“t4-4.py”。
（2）使用集合名称输出集合中所有元素的值。
（3）使用for 循环语句遍历集合，输出集合中所有元素的值。
【任务4-4】遍历集合
【任务实施】
01
02
创建Python 程序文件“t4-4.py”
在程序文件“t4-4.py”中编写代码
运行程序文件“t4-4.py”
03
循序渐进
知识要点
4.1　列表的创建与应用 4.1.1　创建列表 4.1.2　访问列表元素 4.1.3　截取列表 4.1.4 连接与重复列表 4.1.5　修改与添加列表元素 4.1.6　删除列表元素 4.1.7　列表运算符 4.1.8　Python列表的内置函数与基本方法 【任务4-1】遍历列表 4.2　元组的创建与应用 4.2.1　创建元组 4.2.2　访问元组元素费 4.2.3　截取元组 4.2.4　连接与重复元组 4.2.5　修改元组元素 4.2.6　删除元组元素 4.2.7　元组运算符 4.2.8　元组的内置函数与基本方法 【任务4-2】遍历元组 4.3　字典的创建与应用 4.3.1　创建字典 4.3.2　访问字典的值 4.3.3　修改与添加字典的值 4.3.4　删除字典元素 4.3.5　字典的内置函数与基本方法 【任务4-3】遍历字典 4.4　集合的创建与应用 4.4.1　创建集合 4.4.2　修改与添加集合的元素 4.4.4　集合的内置函数与基本方法4.4.5　集合的集合运算 【任务4-4】遍历集合 4.5　字符串的常用方法及应用
4.5.1　创建字符串
4.5.2　访问字符串中的值
4.5.3　截取字符串
4.5.4　连接与重复字符串
4.5.5　修改与添加字符串中的字符
4.5.6　字符串运算符
4.5.7　Python字符串常用的内置
函数与基本方法
【任务4-5】应用字符串的方法实现
字符串翻转操作
4.6　字符串的格式化输出
4.6.1　format()的基本语法格式
4.6.2　format()的参数序号
【任务4-6】使用format()方法格式化输出字符串列表.
4.5.1　创建字符串
创建字符串只要为变量分配一个值即可。示例如下。
str1 = 'Hello Python!'
str2 = 'LiMing'
str3="The quick brown fox jumps over a lazy dog"
如果字符串本身包含有单引号但不含双引号，则字符串会用双引号引起来，否则通常使
用单引号引起来。这样标识的字符串，print() 函数会更易读。
>>>str1 = "I'm David"
>>>str2 = 'I told my friend:"I love Python"'
【注意】
字符串开始和结尾使用的引号形式必须一致，另外当需要表示复杂字符串时，还可以嵌套使用引号。示例如下。同时还可以使用反斜杠“\”转义引号和其他特殊字符来准确地表示所需字符。
4.5.2　访问字符串中的值
字符串是字符的序列，可以把字符串看作一种特殊的元组，按照单个字符或字符片段进行索引。Python 中的字符串有两种索引方式：第1 种是从左往右计数，索引值从0 开始依次增加，字符串的第1 个字符的索引为0，图4-8 中第2 行的数字0、1、2、3、4、5 表示各个字符的索引值；第2 种是从右往左计数，使用负数，从-1 开始依次减少，图中第4 行数字表示相应的负数索引值。
4.5.2　访问字符串中的值
【实例4-9】演示以多种形式访问字符串中的值
实例4-9 的代码如下所示
实例4-9 代码的运行结果如下
python
P
n
h
h
Hello
Python
Hello\nPython
4.5.3　截取字符串
可以对字符串进行截取操作，获取一个子字符串。
截取字符串的基本语法格式如下。
变量[ 头索引值: 尾索引值: 步长]
前2 个参数表示索引值，用冒号分隔两个索引值，截取的范围是前闭后开的，并且两个索引值都可以省略。默认的第1 个索引值为0，第2 个索引值为字符串可以被截取的长度。对于非负数截取参数，如果索引值都在有效范围内，截取部分的长度就是索引值的差。例如，str[1:3] 的长度是2。
str[ i:j ] 表示截取从第i+1（索引值为i）个字符开始，到第j（索引值为j-1）个字符的全部字符，截取的子字符串不包括索引值为j 的字符。
字符串的索引值与截取长度如图 所示。
4.5.3　截取字符串
【实例4-10】演示以多种形式访问字符串中的值
实例4-10 的代码如下所示
实例4-10 代码的运行结果如下
abcdef
abcdef
abc
abc
cd
cd
cdef
abcd
4.5.4　连接与重复字符串
1．连接字符串
加号（+）用于连接字符串，使用“+”运算符可以连接多个字符串并产生一个新的字符串。
>>>first_name = "Li"
>>>last_name = "Ming"
>>>full_name = first_name + " " + last_name # 连接字符串
>>>print(full_name)
>>>print(full_name + '，你好') # 连接字符串
示例如下
运行结果如下
Li Ming
Li Ming，你好
4.5.4　连接与重复字符串
1．连接字符串
也可以截取字符串的一部分并与其他字符串连接。
>>>str = 'Hello World!'
>>>print (" 新字符串：", str[:6] + 'Python!')
示例如下
运行结果如下
新字符串： Hello Python!
4.5.4　连接与重复字符串
2．重复字符串
使用“*”运算符可实现字符串重复多次，星号“*”表示重复当前字符串，与之结合的数字为字符串出现的次数。
>>>str='go!'
>>>print(str * 3) # 输出字符串3 次
示例如下
go!go!go!
运行结果
4.5.4　连接与重复字符串
【实例4-11】演示字符串的访问、连接等多种操作
实例4-11 的代码如下所示
实例4-11 代码的运行结果如下
字符串的基本操作
输出截取不同长度的字符串1 ： H T 实 战
输出截取不同长度的字符串2 ： HTML5+CSS3 Web
输出截取不同长度的字符串3 ： 移动 开发实战
输出连接字符串1 ： 图书名称为HTML5+CSS3 移动Web 开发实战
输出连接字符串2 ： 图书价格为58.0
4.5.5　修改与添加字符串中的字符
由于Python 中的字符串不能改变，如果向一个字符串的某个索引位置赋值，会出现异常信息。
>>>str='go'
>>>str[0]= 't'
示例如下
File "", line 1, in
TypeError: 'str' object does not support item assignment
>>>str[2]= 's'
异常信息1
异常信息2
File "", line 1, in
TypeError: 'str' object does not support item assignment
4.5.5　修改与添加字符串中的字符
所以不能修改字符串中的任意字符，也不能在字符串末尾添加字符，但可以通过截取字符串与连接字符串的方法对字符串中的字符进行修改与添加操作。
>>>str="go"
>>>print("Let's "+str)
>>>print("t"+str[1:])
>>>print(str+"es")
Let's go
to
goes
示例如下
运行结果如下
4.5.6　字符串运算符
Python 字符串运算符及示例如表所示。表中的示例中变量a 的值为字符串"Hello"，变量b 的值为"Python"。
序号 操作符 说明 实例 结果
1 + 字符串连接 a + b HelloPython
2 * 重复输出字符串 a*2 HelloHello
3 [] 通过索引获取字符串中字符 a[1] e
4 [ : ] 截取字符串中的一部分，遵循左闭右开原则，str[0:2]是不包含第3个字符的 a[1:4] ell
5 in 成员运算符：如果字符串中包含给定的字符返回True，否则返回False 'H' in a True
6 not in 成员运算符：如果字符串中不包含给定的字符返回True，否则返回False 'M' not in a True
7 r/R 原始字符串：所有的字符串都是直接按照字面的字符串输出，没有转义或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母r（可以大小写）以外，与普通字符串有着几乎完全相同的语法 print( r'\n' ) print( R'\n' ) \n
\n
4.5.7　Python 字符串常用的内置函数与基本方法
1．计算字符串长度
Python 中使用len() 方法计算字符串的长度，其基本语法格式如下。
len(string)
默认情况下，计算字符串的长度时，不区分英文字母、数字和汉字，每个字符的长度都计为1。
>>>str = "python"
>>>print(len(str))
示例如下
6
运行结果
如果要获取字符串实际所占的字节数，可先使用encode() 方法进行编码。获取采用UTF-8 编码的字符串长度的基本语法格式为：len(str.encode())。获取采用GBK 编码的字符串长度的基本语法格式为：len(str.encode("GBK"))。
4.5.7　Python 字符串常用的内置函数与基本方法
2．计算字符串中最大与最小的字符
（1）max(str)
（2）min(str)
max(str) 方法用于返回字符串str 中ASCII 码值最大的字符。
min(str) 方法用于返回字符串str 中ASCII 码值最小的字符。
4.5.7　Python 字符串常用的内置函数与基本方法
3．检索字符串
（1）count() 方法
count() 方法返回指定的字符串在另一个字符串中出现的次数，其基本语法格式如下。
count(str [,start=0 [,end=len(string)]])
如果指定start 或end，则返回指定范围内str 出现的次数。如果检索的字符串不存在，则返回0，否则返回它出现的次数。
>>>str = "hello python"
>>>print(str.count('o'))
示例如下
2
运行结果
4.5.7　Python 字符串常用的内置函数与基本方法
3．检索字符串
（2）find() 方法与rfind() 方法
find() 方法用于检索某字符串中是否包含指定的字符串，其基本语法格式如下。
find(str[,start=0[,end=len(string)]])
该方法用于检测指定字符串是否包含str，如果包含则返回首次出现该字符串时的索引值，否则返回-1。如果指定了start 和end，则在指定范围内检索。可以根据find() 方法的返回值是否大于-1 来判断指定的字符串是否存在。
>>>str = "hello python"
>>>print(str.find('o'))
示例如下
4
>>>print(str.find('x'))
运行结果如下。
-1
运行结果
4.5.7　Python 字符串常用的内置函数与基本方法
3．检索字符串
（3）index() 方法与rindex() 方法
index() 方法的功能与find() 方法一样，也是用于检索某字符串中是否包含指定的字符串，只不过如果检索的字符串不在指定的字符串中会抛出异常。其基本语法格式如下。
index(str[,start=0[,end=len(string)]])
rindex(str[,start=0[,end=len(string)]]) 方法的功能类似于index()，只是从字符串的右边开始查找。
（4）startswith() 方法
startswith() 方法用于判断字符串是否以指定字符串开头，如果是，则返回True，否则返回False。其基本语法格式如下。
startswith(substr[,start=0[,end=len(string)]])
如果指定了start 和end，则在指定范围内进行判断。
4.5.7　Python 字符串常用的内置函数与基本方法
3．检索字符串
endswith() 方法用于判断字符串是否以指定字符串结束，如果是，则返回True，否则返回False。其基本语法格式如下。
endswith(suffix[,start=0[,end=len(string)]])
如果指定了start 和end，则在指定范围内进行判断。
（5）endswith() 方法
4.5.7　Python 字符串常用的内置函数与基本方法
4．分割字符串
split() 方法可以实现字符串分割，也就是将一个字符串按照指定的分隔符分割为字符串列表，该列表的元素中不包括分隔符。其基本语法格式如下。
split([sep[,max=string.count(str)]])
>>>str = "hello python"
>>>print(str.split(' '))
示例如下
运行结果
['hello', 'python']
>>>print(str.split(' ',0))
运行结果如下。
['hello python']
4.5.7　Python 字符串常用的内置函数与基本方法
5．去除字符串的空格和特殊字符
（1）strip() 方法
strip() 方法用于去掉字符串左、右两侧的空格和特殊字符，其基本语法格式如下。
strip([chars])
其中，chars 为可选参数，用于指定要去除的字符，可以指定多个字符。如果不指定chars 参数，将默认去除空格、回车符“\r”、换行符“\n”、制表符“\t”等。
>>>str = " p y t h o n "
>>>print(str.strip()) # 删除字符串两端的空格
p y t h o n
示例如下
4.5.7　Python 字符串常用的内置函数与基本方法
5．去除字符串的空格和特殊字符
lstrip() 方法用于去掉字符串左侧的空格和特殊字符，其基本语法格式如下。
lstrip([chars])
可选参数chars 的说明见strip() 方法。
>>>str = " p y t h o n "
>>>print(str.lstrip()) # 删除字符串左端的空格
p y t h o n
示例如下
（2）lstrip() 方法
4.5.7　Python 字符串常用的内置函数与基本方法
5．去除字符串的空格和特殊字符
rstrip() 方法用于去掉字符串右侧的空格和特殊字符，其基本语法格式如下。
rstrip([chars])
可选参数chars 的说明见strip() 方法。
>>>str = " p y t h o n "
>>>print(str.rstrip()) # 删除字符串右端的空格
p y t h o n
示例如下
（3）rstrip() 方法
4.5.7　Python 字符串常用的内置函数与基本方法
6．字母的大小写转换
（1）lower() 方法
lower() 方法用于将字符串中所有大写字符转换为小写。
>>>str = "Hello Python"
>>>print(str.lower()) # 将字符串中的大写字符全部改为小写
hello python
示例如下
4.5.7　Python 字符串常用的内置函数与基本方法
6．字母的大小写转换
upper() 方法用于将字符串中的所有小写字母转换为大写。
>>>str = "I love python"
>>>print(str.upper()) # 将字符串中的小写字符全部改为大写
I LOVE PYTHON
示例如下
（2）upper() 方法
4.5.7　Python 字符串常用的内置函数与基本方法
6．字母的大小写转换
title() 方法用于返回“标题化”的字符串，所有单词都以大写字母开头，其余字母均为小写。
>>>str = "hello python"
>>>print(str.title())
Hello Python
示例如下
（3）title() 方法
4.5.7　Python 字符串常用的内置函数与基本方法
7．替换字符串
replace() 用于替换字符串中的部分字符或子字符串，其基本语法格式如下。
replace(str1,str2[,max])
该方法将字符串中的str1 替换成str2，如果指定了max 参数，则替换不超过max 次。
>>>str = " p y t h o n "
>>>print(str.replace(' ','')) # 删除字符串中的全部空格
python
示例如下
应用字符串的方法实现字符串翻转操作
【任务4-5】
【任务描述】
（1）在项目“Unit04”中创建Python 程序文件“t4-5.py”。
（2）分别应用字符串的方法split()、join() 和字符串的访问操作实现字符串翻转操作，例如原字符串为“I love Python”，翻转后的字符串变为“Python love I”。
【任务4-5】
【任务实施】
01
02
创建Python 程序文件“t4-5.py”
在程序文件“t4-5.py”中编写代码
运行程序文件“t4-5.py”
03
程序文件“t4-5.py”的代码中strWord[-1::-1] 有3 个参数：第1 个参数为-1，表示最后
一个元素；第2 个参数为空，表示移动到单词列表开头；第3 个参数为步长，-1 表示逆向。
循序渐进
知识要点
4.1　列表的创建与应用 4.1.1　创建列表 4.1.2　访问列表元素 4.1.3　截取列表 4.1.4 连接与重复列表 4.1.5　修改与添加列表元素 4.1.6　删除列表元素 4.1.7　列表运算符 4.1.8　Python列表的内置函数与基本方法 【任务4-1】遍历列表 4.2　元组的创建与应用 4.2.1　创建元组 4.2.2　访问元组元素费 4.2.3　截取元组 4.2.4　连接与重复元组 4.2.5　修改元组元素 4.2.6　删除元组元素 4.2.7　元组运算符 4.2.8　元组的内置函数与基本方法 【任务4-2】遍历元组 4.3　字典的创建与应用 4.3.1　创建字典 4.3.2　访问字典的值 4.3.3　修改与添加字典的值 4.3.4　删除字典元素 4.3.5　字典的内置函数与基本方法 【任务4-3】遍历字典 4.4　集合的创建与应用 4.4.1　创建集合 4.4.2　修改与添加集合的元素 4.4.4　集合的内置函数与基本方法4.4.5　集合的集合运算 【任务4-4】遍历集合 4.5　字符串的常用方法及应用
4.5.1　创建字符串
4.5.2　访问字符串中的值
4.5.3　截取字符串
4.5.4　连接与重复字符串
4.5.5　修改与添加字符串中的字符
4.5.6　字符串运算符
4.5.7　Python字符串常用的内置
函数与基本方法
【任务4-5】应用字符串的方法实现
字符串翻转操作
4.6　字符串的格式化输出
4.6.1　format()的基本语法格式
4.6.2　format()的参数序号
【任务4-6】使用format()方法格式化输出字符串列表.
4.6.1　format() 的基本语法格式
可以使用str.format() 方法来格式化输出字符串，字符串格式化是为了实现字符串和变量同时输出时按一定的格式显示。format() 方法的基本语法格式如下。
"< 模板字符串>".format(< 以半角逗号分隔的参数>)
模板字符串由一系列占位符（用{} 表示）组成，大括号{} 及其里面的字符（称作格式化字符）将会被format() 中的参数替换。调用format() 方法会返回一个新的字符串。
format() 方法中的模板字符串包含参数序号、半角冒号（:）、格式控制标记，样式如下。
{[< 参数序号>][:[< 格式控制标记>]]}
>>>pi=3.14159
>>>print(" 常量π 的值近似为：{}。".format(pi))
示例如下
运行结果
常量π 的值近似为：3.14159。
4.6.2　format() 的参数序号
format() 中的参数会按{} 中的序号替换到模板字符串的对应位置。{} 的默认顺序为0、1、2……，参数从0 开始编号，参数的顺序固定为0、1、2……。
如果{} 没有序号，就按它们出现的先后顺序自动替换。
>>>print(" 姓名：{}，年龄：{}".format(" 李明", 21))
示例如下
运行结果
姓名：李明，年龄：21
大括号中的数字用于指向传入对象在format() 中的位置。
>>>print(" 姓名：{0}，年龄：{1}".format(" 李明", 21))
示例如下
运行结果
姓名：李明，年龄：21
>>>print(" 姓名：{1}，年龄：{0}".format(21," 李明"))
运行结果如下。
姓名：李明，年龄：21
4.6.2　format() 的参数序号
如果在format() 中使用了关键字参数，那么它们的值会指向使用相应名字的参数。
>>>print(" 姓名：{name}，年龄：{age}".format(age=21,name=" 李明"))
示例如下
运行结果
姓名：李明，年龄：21
位置及关键字参数可以结合使用。
>>>print(" 姓名：{0}，年龄：{1}，性别：{gender}".format(" 李明",21, gender=" 男"))
示例如下
运行结果
姓名：李明，年龄：21，性别：男
4.6.2　format() 的参数序号
使用format() 方法可以连接不同类型的变量或数据，如果大括号本身是字符串的一部分，需要输出大括号，可使用“{{{”，其中“{{”表示“{”。
>>>pi=3.14159
>>>print(" 圆周率{{{0}{1}}} 是{2}。".format(pi , "…", " 无理数"))
示例如下
运行结果
圆周率{3.14159…} 是无理数。
使用format() 方法格式化输出字符串列表
【任务4-6】
【任务描述】
（1）在项目“Unit04”中创建Python 程序文件“t4-6.py”。
（2）使用format() 方法格式化输出字符串列表。
【任务4-6】
【任务实施】
01
02
创建Python 程序文件“t4-6.py”
在程序文件“t4-6.py”中编写代码
运行程序文件“t4-6.py”
03
THANKS

展开更多......

收起↑