资源简介

(共99张PPT)
Python少儿编程
第四章 形形色色的数据容器
目录
1.1
通用系列
1.2
百变字符串
1.3
会魔法的列表
1.4
被束缚了的元组
1.5
有身份的字典
1.6
独一无二的集合
PART 01
通用序列
索引
1.1
序列中的所有元素都可以通过索引（下标）来获取，从左往右，第一个元素的索引为0，第二个为1，依此类推到最后一位。索引还可以取负值，从右往左，最后一个元素的索引为 1，倒数第二个为 2，依此类推到左侧第一位。
例如，创建字符串“str1='Python'”，其索引如表4-1所示。
表4-1 字符串str1的索引
由表4-1可知，str1[0]和str1[ 6]的值都是字符“P”。还可使用序列字面值直接使用索引，如'Python'[0]的值也是字符“P”。
分片
1.2
分片与索引类似，都可以获取序列中的元素，区别是索引只能获取单个元素，而分片可以获取一定范围内的元素。
分片通过冒号隔开的两个索引来实现，其语法格式如下。
slice[start:end:step]
其中，slice表示序列；start表示起始索引，缺省时分片从序列中的第一个元素开始；end表示结束索引（不含），缺省时分片到序列的最后一个元素结束；step表示步长，缺省时为1，不能为0。
例如，创建字符串“str2='abcdefg'”，使用分片获取字符串中元素的几种情况如表4-2所示。
分片
1.2
表4-2 分片获取字符串str2中元素
分片
1.2
Python中步长不能设置为0，但可以是负数。当步长为负数时，起始索引必须大于结束索引，即分片从右往左提取元素。例如：
str3 = str2[7:0:-1] #str3为'gfedcb'
str3 = str2[-1:-8:-1] #str3为'gfedcba'
str3 = str2[::-1] #str3为'gfedcba'
相加
1.3
使用加法运算符可对序列进行连接操作。例如：
str4 = 'Hello,' + 'World' #字符串连接，str4为'Hello,World'
list1 = [1,2,3] + [4,5,6] #列表连接，list1为[1, 2, 3, 4, 5, 6]
相乘
1.4
使用数字n乘以一个序列会生成新的序列，在新的序列中，原来的序列将重复n次。例如：
str5 = 'hello' * 3 #str5为'hellohellohello'
长度、最小值和最大值
1.5
序列常用的内置函数有len()、min()和max()，其参数都为序列名。其中，len()函数返回序列中元素的个数（即序列长度），min()函数和max()函数则分别返回序列中最小和最大的元素。
【例4-1】 输入一个字符串，输出字符串中的最大字符和最小字符，并将字符串输出为如下格式（输出的“ ”的个数会随着字符串的长度而变化），如图4-1所示。
图4-1 输出的文字格式
【问题分析】 本例题中，输出连续相同的字符“ ”，可使用序列的乘法运算实现，它的个数等于输入字符串的长度，可使用len()函数获取。然后使用max()和min()函数获取字符串中的最大字符和最小字符并输出。
长度、最小值和最大值
1.5
【参考代码】
strs = input('请输入一个字符串：') #输入字符串并赋给strs
str_len = len(strs) #获取strs长度并赋给str_len
str_max = max(strs) #获取strs中最大字符并赋给str_max
str_min = min(strs) #获取strs中最小字符并赋给str_min
print('该字符串中最大字符为：', str_max) #输出最大字符
print('该字符串中最小字符为：', str_min) #输出最小字符
print('+ ' + '-' * str_len + ' +') #输出“+ ”、str_len个“-”和“ +”
print('| ' + strs + ' |') #输出“| ”、字符串和“ |”
print('+ ' + '-' * str_len + ' +') #输出“+ ”、str_len个“-”和“ +”
长度、最小值和最大值
1.5
【运行结果】 程序运行结果如图4-2所示。
图4-2 例4-1程序运行结果
查找和计数
1.6
序列提供index()方法用于返回指定元素在序列中首次出现的位置，如果该元素不在序列中则抛出异常，其语法格式如下。
sequence.index(obj)
如果需要知道指定元素在序列中出现的次数，可以使用count()方法进行计数并返回，其语法格式如下。
其中，sequence表示序列，obj表示要查找的对象。
sequence.count(obj)
【例4-2】 查找输入的人物是否在《三国演义》片段中，如果在，则统计出现的次数。
【问题分析】 首先使用“in”运算符判断输入的人物是否在《三国演义》片段中，如果在，则使用index()方法获取首次出现的位置，然后使用count()方法统计出现的次数。
查找和计数
1.6
【参考代码】
#创建字符串excerpts并赋值
excerpts = '''次日，于桃园中，备下乌牛白马祭礼等项，三人焚香再拜而说誓曰：
“念刘备、关羽、张飞，虽然异姓，既结为兄弟，则同心协力，救困扶危；
上报国家，下安黎庶。不求同年同月同日生，只愿同年同月同日死。
皇天后土，实鉴此心，背义忘恩，天人共戮！”誓毕，拜玄德为兄，
关羽次之，张飞为弟。祭罢天地，复宰牛设酒，聚乡中勇士，
得三百余人，就桃园中痛饮一醉。来日收拾军器，但恨无马匹可乘。
正思虑间，人报有两个客人，引一伙伴当，赶一群马，投庄上来。
玄德曰：“此天佑我也！”三人出庄迎接。原来二客乃中山大商：
一名张世平，一名苏双，每年往北贩马，近因寇发而回。
玄德请二人到庄，置酒管待，诉说欲讨贼安民之意。二客大喜，
愿将良马五十匹相送；又赠金银五百两，镔铁一千斤，以资器用。'''
查找和计数
1.6
【参考代码】（续）
name = input('请输入人物姓名：') #输入人物姓名并赋给name
if name in excerpts: #如果name在此片段中
#使用index()方法获取name首次出现的位置index
index = excerpts.index(name)
print(name, '首次出现的位置索引为：', index) #输出index
#使用count()方法获取name出现的次数并输出
print(name, '在此片段中出现', excerpts.count(name), '次')
else:
print(name, '没有出现在此片段中') #输出name不在此片段中
查找和计数
1.6
【运行结果】 程序运行结果如图4-3所示。
图4-3 例4-2程序运行结果
PART 02
百变字符串
字符串格式化
2.1
Python提供了“%”符号进行字符串格式化，其语法格式如下。
1． “%”符号
其中，[]中的项为可选项，也可以表示为如下形式。
'%[标志][0][输出最小宽度][.精度]格式字符' %变量
'%[±][0][m][.n]格式字符' %变量
（1）标志：标志字符为“+”或“ ”，指定输出数据的对齐方式。
（2）输出最小宽度：用十进制整数m表示输出的最小位数。
（3）精度：精度格式符以“.”开头，后跟十进制整数n。
（4）格式字符：用来表示输出数据的类型，各种格式字符及其功能说明如表4-3所示。
字符串格式化
2.1
1． “%”符号
表4-3 格式字符
字符串格式化
2.1
1． “%”符号
【例4-3】 使用“%”符号格式化。
【参考代码】
a = 15 #定义变量a并赋值
b = 12345678.1234567 #定义变量b并赋值
s = 'I love Python!' #定义字符串s并赋值
print('a = %05d' % a) #使用m控制输出位数，空位补0
print('b = %8.3f' % b) #使用m.n控制输出的长度和小数点位数
print('%17s' % s) #使用m控制输出字符串长度
print('%-17.6s' % s) #使用-m.n左对齐、控制字符串长度和字符位数
字符串格式化
2.1
1． “%”符号
【运行结果】程序运行结果如图4-4所示。
图4-4 例4-3程序运行结果
【程序说明】 输出变量a时，“%05d”表示输出宽度为5并用“0”来补空位。输出变量b时，“%8.3f”表示输出宽度为8，精度为3，由于实际长度超过8位，故应按实际位数输出，小数位数超过3位部分被截去。
输出字符串s时，“%17s”表示输出字符串宽度为17，如果字符串本身长度不足17，则用空格左补齐，可以看到“I love Python!”前存在3个空格。“% 17.6s”表示输出宽度虽为17，但这里指定了精度“.6”，也就是说指定了输出字符的个数为6，并且用“ ”指定了左对齐，所以输出6个字符“I love”，后面还有11个空格。
字符串格式化
2.1
使用format()方法也可以格式化字符串，其基本语法格式如下。
2． format()方法
模板字符串是由一系列槽（用大括号表示）组成，用于控制字符串中嵌入值出现的位置，其基本思想是，将format()方法中逗号分隔的参数按照序号替换到模板字符串的槽中（序号从0开始）。例如：
模板字符串.format(逗号分隔的参数)
#s为'你好，张三，你这个月的工资是8500元！'
s = '你好，{1}，你这个月的工资是{0}元！'.format(8500, '张三')
如果大括号中没有序号，则按照出现顺序替换，例如：
#s为'你好，8500，你这个月的工资是张三元！'
s = '你好，{}，你这个月的工资是{}元！'.format(8500, '张三')
字符串格式化
2.1
format()方法中模板字符串的槽除了包括参数序号外，还可以包括格式控制信息，此时槽的内部格式如下。
2． format()方法
{参数序号:格式控制标记}
其中格式控制标记用于控制参数显示时的格式，它包括“填充”“对齐”“宽度”“,”“.精度”“格式字符”6个可选字段，这些字段可以组合使用。具体的格式控制标记及其说明如表4-4所示。
字符串格式化
2.1
2． format()方法
表4-4 格式控制标记
字符串格式化
2.1
2． format()方法
【例4-4】 模拟输出简单的非刷新文本进度条。要求按照任务执行百分比将整个任务划分为100个单位，每执行10%输出一次进度条，每行输出包含进度百分比、代表已完成部分（**）和未完成部分（..）的两种字符，以及一个跟随完成进度前进的小箭头，风格如下：
%10 [**->..................]
【问题分析】 本例题的关键是输出字符的格式，可使用format()方法进行格式化。采用for循环和print()函数构成程序的主体部分，使用格式字符“%”输出百分比，为了使输出整齐，可使用{:^4.0%}格式化百分比部分。
由于程序执行速度太快，不便于观察，可使用time.sleep(t)函数将当前程序暂停t秒，其中，time是Python标准时间库。
字符串格式化
2.1
2． format()方法
【参考代码】
import time #导入time模块
scale = 10 #变量scale表示输出进度条的精度
print('-----------执行开始-----------') #输出执行开始提示
for i in range(scale + 1): #循环变量从0到scale
done = '**' * i #用“*”表示已完成的部分
undone = '..' * (scale - i) #用“.”表示未完成的部分
percent = i / scale #计算完成百分比
#格式化输出
print('{:>4.0%}[{}->{}]'.format(percent, done, undone))
time.sleep(0.1) #暂停0.1秒
print('-----------执行结束-----------') #输出执行结束提示
字符串格式化
2.1
2． format()方法
【运行结果】 程序运行结果如图4-5所示。
图4-5 例4-4程序运行结果
字符串的常用操作
2.2
除了使用index()方法在字符串中查找指定元素，还可使用find()方法在一个较长的字符串中查找子串。如果找到子串，返回子串所在位置的最左端索引，否则返回 1，其语法格式如下。
str.find(sub[,start[,end]])
1． 查找字符串
其中，str表示被查找字符串；sub表示查找的子串；start表示开始索引，缺省时为0；end表示结束索引，缺省时为字符串的长度。
【例4-5】 使用find()方法实现例4-2，查找输入的人物是否在《三国演义》片段中。
字符串的常用操作
2.2
1． 查找字符串
【参考代码】
#创建字符串excerpts并赋值
excerpts = '''次日，于桃园中，备下乌牛白马祭礼等项，三人焚香再拜而说誓曰：
“念刘备、关羽、张飞，虽然异姓，既结为兄弟，则同心协力，救困扶危；
上报国家，下安黎庶。不求同年同月同日生，只愿同年同月同日死。
皇天后土，实鉴此心，背义忘恩，天人共戮！”誓毕，拜玄德为兄，
关羽次之，张飞为弟。祭罢天地，复宰牛设酒，聚乡中勇士，
得三百余人，就桃园中痛饮一醉。来日收拾军器，但恨无马匹可乘。
正思虑间，人报有两个客人，引一伙伴当，赶一群马，投庄上来。
玄德曰：“此天佑我也！”三人出庄迎接。原来二客乃中山大商：
一名张世平，一名苏双，每年往北贩马，近因寇发而回。
玄德请二人到庄，置酒管待，诉说欲讨贼安民之意。二客大喜，
愿将良马五十匹相送；又赠金银五百两，镔铁一千斤，以资器用。'''
字符串的常用操作
2.2
1． 查找字符串
【参考代码】（续）
name = input('请输入人物姓名：') #输入人物姓名并赋给name
index = excerpts.find(name)#使用find()方法在excerpts中查找name
if index > -1: #如果返回值大于-1
#输出index
print('{}首次出现的位置索引为：{}'.format(name, index))
#使用count()方法获取name出现的次数并输出
print('{}在此片段中出现{}次'.format(name, excerpts.count(name)))
else:
print('{}没有出现在此片段中'.format(name)) #输出不在此片段中
字符串的常用操作
2.2
1． 查找字符串
【运行结果】 程序运行结果如图4-6所示。
图4-6 例4-5程序运行结果
字符串的常用操作
2.2
split()方法以指定字符为分隔符，从字符串左端开始将字符串分隔成多个子串，并返回分割结果的列表，其语法格式如下。
str.split([delimiter, num])
2． 分割字符串
其中，str表示被分割的字符串；delimiter表示分隔符，可以是空格、换行（\n）、制表符（\t）等，缺省时为空格；num表示分割次数，缺省时全部分割。
例如，使用split()方法将字符串“This is an example of cutting”进行分割，可以用下面代码实现。
strs = 'This is an example of cutting' #创建字符串
'''以空格为分隔符将字符串全部分割
结果为['This', 'is', 'an', 'example', 'of', 'cutting']'''
strs.split()
'''以空格为分隔符将字符串分割3次
结果为['This', 'is', 'an', 'example of cutting']'''
strs.split(' ', 3)
字符串的常用操作
2.2
join()方法用于将序列中的元素以指定的字符连接，生成一个新的字符串，其语法格式如下。
str.join(sequence)
3．连接字符串
其中，str表示连接符，可以为空；sequence表示要连接的序列。
例如，使用join()方法将字符串“Python!”中的字符用“ ”连接，可以用下面代码实现。
#用“ ”连接字符，输出结果为“P-y-t-h-o-n-!”
print('-'.join('Python!'))
字符串的常用操作
2.2
3．连接字符串
【例4-6】 将字符串“Rain falls on field and tree.”中的多余空格删除，即如果有连续空格只保留一个。
【问题分析】 可使用split()方法以空格为分隔符将字符串分隔成多个子串，然后使用join()方法通过空格将多个子串进行连接。
【参考代码】
strs = 'Rain falls on field and tree.‘ #创建字符串strs
print(strs) #输出strs
split_strs = strs.split() #以空格为分隔符，将strs全部分割
print(split_strs) #输出分割后结果
join_strs =' '.join(split_strs) #用空格连接分割后的子串
print(join_strs) #输出连接后的字符串
字符串的常用操作
2.2
3．连接字符串
【运行结果】 程序运行结果如图4-7所示。
图4-7 例4-6程序运行结果
字符串的常用操作
2.2
replace()方法用于将字符串中的旧字符串替换成新字符串，其语法格式如下。
str.replace(old,new[,max])
4．替换字符串
其中，str表示字符串；old表示将被替换的旧字符串；new表示新字符串，用于替换old；max是可选参数，表示替换的最大次数，缺省时替换所有。
例如，使用replace()方法将字符串“Monday Tuesday Wednesday”中的“day”替换为“DAY”，可以用下面代码实现。
strs = 'Monday Tuesday Wednesday'
#将strs中的day替换为DAY，输出结果为“MonDAY TuesDAY WednesDAY”
print(strs.replace('day', 'DAY'))
#将strs中的day替换为DAY，只替换两次，输出结果为“MonDAY TuesDAY Wednesday”
print(strs.replace('day', 'DAY', 2))
字符串的常用操作
2.2
strip()方法用于移除字符串首尾连续的空白字符或指定字符，其语法格式如下。
str.strip([chars])
5．移除字符串的首尾字符
其中，str表示字符串；chars表示移除的字符串首尾指定的字符，缺省时为空格。
例如，使用strip()方法移除字符串“110This is an example0001”中的“0”和“1”，可以用下面代码实现。
strs = '110This is an example0001' #创建字符串
#移除strs两侧的1，输出结果为“0This is an example000”
print(strs.strip('1'))
#移除strs两侧的1和0，输出结果为“This is an example”
print(strs.strip('10'))
字符串的常用操作
2.2
lower()方法用于将字符串中所有大写字符转换为小写，而upper()方法则用于将字符串中所有小写字符转换为大写，其语法格式如下。
str.lower()
str.upper()
6．转换字符串的大小写
其中，str表示字符串。例如，使用lower()方法将字符串“This is an EXAMPLE”转换为小写，再使用upper()方法将其转换为大写，可以使用下面代码实现。
strs = 'This is an EXAMPLE' #创建字符串
#将strs中的大写字符转换为小写，输出结果为“this is an example”
print(strs.lower())
#将strs中的小写字符转换为大写，输出结果为“THIS IS AN EXAMPLE”
print(strs.upper())
字符串的常用操作
2.2
isalnum()方法用于检测字符串是否由字母和数字，或两种中的一种组成，如果是则返回True，否则返回False，其语法格式如下。
str.isalnum()
7．检测字符串
其中，str表示要检测的字符串。
例如，使用isalnum()方法判断字符串“2021example”是否由字母和数字组成，可以用下面代码实现。
strs = '2021example' #创建字符串
print(strs.isalnum()) #判断strs中是否只有字母和数字，输出结果为True
PART 03
会魔法的列表
列表的创建和访问
3.1
创建列表只需将逗号分隔的不同元素使用方括号括起来即可。例如：
animal = ['elephant', 'monkey', 'snake', 'tiger'] #创建列表animal
number = [1, 2, 3, 4, 5] #创建列表number
与字符串一样，可以通过下标索引的方式来访问列表中的元素。列表的正索引也是从0开始的，同样也可以是负索引。例如，使用animal[0]访问上述列表animal中索引为0的元素，取值为“elephant”。
列表的创建和访问
3.1
【例4-7】 创建书包列表，记录书包里的物品。
【参考代码】
#创建列表schoolbag并赋值
schoolbag = ['语文书', '数学书', '练习册', '笔盒']
schoolbag1 = schoolbag #将schoolbag赋给schoolbag1
print(schoolbag, schoolbag1) #输出schoolbag和schoolbag1
schoolbag[0] = '英语书' #将第一个元素的值修改为“英语书”
print(schoolbag, schoolbag1) #输出schoolbag和schoolbag1
列表的创建和访问
3.1
【运行结果】 程序运行结果如图4-8所示。
图4-8 例4-7程序运行结果
【程序说明】 schoolbag由实际数据赋值产生，为列表对象。将schoolbag赋值给列表schoolbag1只会对schoolbag列表生成一个新引用，此时，schoolbag和schoolbag1指向同一对象，即内存中真实数据只有一份。因此，修改了schoolbag后，schoolbag1也随之改变。
列表的遍历
3.2
使用while循环遍历列表，首先须获取列表的长度，将其作为while循环的判断条件。
1．使用while循环遍历列表
【例4-8】 使用while循环输出书包中的每项物品。
【参考代码】
#创建书包列表schoolbag并赋值
schoolbag = ['语文书', '数学书', '英语书', '漫画书']
length = len(schoolbag) #获取列表的长度赋给length
i = 0 #循环变量i初值为0
while i < length: #当i小于length时循环
print(schoolbag[i]) #输出列表元素
i += 1 #循环变量加1
【问题分析】 使用len()函数获取列表的长度，作为while循环的次数。
列表的遍历
3.2
1．使用while循环遍历列表
【运行结果】 程序运行结果如图4-9所示。
图4-9 例4-8程序运行结果
列表的遍历
3.2
使用for循环遍历列表，只需将要遍历的列表作为for循环表达式中的序列即可。
2．使用for循环遍历列表
【例4-9】 使用for循环输出书包中的每项物品。
【参考代码】
#创建书包列表schoolbag并赋值
schoolbag = ['语文书', '数学书', '英语书', '漫画书']
for item in schoolbag: #将列表作为for循环表达式中的序列
print(item) #输出item
【运行结果】 程序运行结果如图4-10所示。
图4-10 例4-9程序运行结果
列表的基本操作
3.3
列表可使用append()、extend()或insert()方法来添加元素。
（1）append()方法：在列表末尾添加新的元素，其语法格式如下。
list.append(obj)
1．添加元素
其中，list表示列表，obj表示添加到列表末尾的对象。例如：
number = [0, 1, 2, 3] #创建列表number并赋值
number.append(4) #使用append()方法给number末尾添加元素4
print(number) #输出number，结果为[0, 1, 2, 3, 4]
（2）extend()方法：在列表末尾一次性添加另一个序列中的多个值（用新列表扩展原来的列表），其语法格式如下。
list.extend(seq)
其中，list表示列表，seq表示添加到列表末尾的序列。
列表的基本操作
3.3
1．添加元素
【例4-10】 在书包中再放入练习册和笔盒。
【问题分析】 创建书包列表schoolbag、练习册列表workbook和笔盒列表penbox，其中，workbook包含语文练习册和数学练习册，penbox包含铅笔、油笔和橡皮。使用extend()方法将workbook列表添加到schoolbag中，使用append()方法将penbox添加到schoolbag中。
列表的基本操作
3.3
1．添加元素
【参考代码】
#创建书包列表schoolbag并赋值
schoolbag = ['语文书', '数学书', '英语书', '漫画书']
print(schoolbag) #输出schoolbag
#创建练习册列表workbook并赋值
workbook = ['语文练习册', '数学练习册']
penbox = [‘铅笔’, ‘油笔’, ‘橡皮’] #创建笔盒列表penbox并赋值
#使用extend()方法将workbook添加到schoolbag中
schoolbag.extend(workbook)
print(schoolbag) #输出schoolbag
#使用append()方法将penbox添加到schoolbag中
schoolbag.append(penbox)
print(schoolbag) #输出schoolbag
列表的基本操作
3.3
1．添加元素
【运行结果】 程序运行结果如图4-11所示。
图4-11 例4-10程序运行结果
【程序说明】 使用extend()方法时，是将workbook看作一个序列，将这个序列和schoolbag序列合并，因此，添加元素后，schoolbag中包含了6个元素。使用append()方法时，是将penbox看作一个对象，整体打包添加到schoolbag列表中，因此，添加元素后schoolbag中包含了7个元素，其中第7个元素是一个列表。
列表的基本操作
3.3
2．删除元素
number = [1, 2, 3, 4, 5] #创建列表number并赋值
del number[2] #使用del命令删除number中索引为2的元素
print(number) #输出number，结果为[1, 2, 4, 5]
（1）del命令：根据索引删除列表中的元素。例如：
number = [1, 2, 3, 4, 5] #创建列表number并赋值
del number[1:3] #使用del命令删除索引从1到3（不含）的元素
print(number) #输出number，结果为[1, 4, 5]
del命令还可以使用分片的方式删除列表中的元素。例如：
列表的基本操作
3.3
2．删除元素
list.pop([index])
（2）pop()方法：根据索引删除列表中的元素，并返回该元素的值，其语法格式如下。
number = [1, 2, 3, 4, 5] #创建列表number并赋值
number.pop() #使用pop()方法删除number中的元素，返回值为5
print(number) #输出number，结果为[1, 2, 3, 4]
number.pop(0) #使用pop()方法删除number中索引为0的元素，返回值为1
print(number) #输出number，结果为[2, 3, 4]
其中，list表示列表，index表示删除列表元素的索引值，为可选参数，缺省时为 1，删除列表中的最后一个元素。例如：
列表的基本操作
3.3
2．删除元素
list.remove(obj)
（3）remove()方法：删除列表中某个值的第一个匹配项，其语法格式如下。
其中，list表示列表，obj表示列表中要删除的对象。
【例4-11】 从书包中拿走英语书和漫画书。
【问题分析】 使用pop()方法删除“英语书”，使用remove()方法删除“漫画书”。
列表的基本操作
3.3
2．删除元素
【参考代码】
#创建书包列表schoolbag并赋值
schoolbag = ['语文书', '数学书', '英语书', '漫画书']
print(schoolbag) #输出schoolbag
schoolbag.pop(2) #使用pop()方法删除索引为2的元素“英语书”
print(schoolbag) #输出schoolbag
schoolbag.remove('漫画书') #使用remove()方法删除元素“漫画书”
print(schoolbag) #输出schoolbag
【运行结果】 程序运行结果如图4-12所示。
图4-12 例4-11程序运行结果
列表的基本操作
3.3
3．分片赋值
number = [1, 2, 3, 4] #创建列表number并赋值
print(number) #输出number，结果为[1, 2, 3, 4]
number[2:] = [5, 6, 7] #替换索引从2开始到最后的元素
print(number) #输出number，结果为[1, 2, 5, 6, 7]
分片赋值就是以分片的形式给列表赋值，可以一次为多个元素赋值。例如：
number = [1,7] #创建列表number并赋值
#在number中索引为1的位置插入列表[2,3,4,5,6]中的元素
number[1:1] = [2,3,4,5,6]
print(number) #输出number，结果为[1, 2, 3, 4, 5, 6, 7]
分片赋值还可以在不替换任何原有元素的情况下插入新的元素。
列表的基本操作
3.3
3．分片赋值
number = [1, 2, 3, 4, 5, 6, 7] #创建列表并赋值
number[1:6] = [] #用空列表替换number中索引1到索引6（不含）的元素
print(number) #输出number，结果为[1, 7]
分片赋值也可以删除元素。
列表的基本操作
3.3
4．列表排序
（1）reverse()方法：将列表中的元素反向存放，其语法格式如下。
list.reverse()
其中，list表示列表，该方法没有参数，没有返回值。例如：
number = [1,2,3,4] #创建列表number并赋值
number.reverse() #使用reverse()方法将number中的元素反向存放
print(number) #输出number，结果为[4, 3, 2, 1]
（2）sort()方法：将列表中的元素进行排序（默认为升序排序），其语法格式如下。
list.sort([key=None][,reverse=False])
其中，list表示列表；key为可选参数，如果指定了该参数，会使用该参数的方法进行排序；reverse为可选参数，表示是否降序排序，缺省时为False。
列表的基本操作
3.3
4．列表排序
【例4-12】 将数字从大到小排序，将英文单词从短到长排序。
【问题分析】 降序排序须指定参数reverse为True，要以序列内元素的长度来排序，须使用参数key指定排序依据为len()函数。
【参考代码】
#创建数字列表number并赋值
number = [5, 6, 9, 3, 12, 15, 18, 20, 35, 62]
number.sort(reverse=True) #使用sort()方法对number降序排序
print(number) #输出number
#创建英文单词列表words并赋值
words = ['chicken', 'fox', 'duck', 'dog', 'rabbit', 'sheep']
words.sort(key=len) #使用sort()方法对words按长度升序排序
print(words) #输出words
列表的基本操作
3.3
4．列表排序
【运行结果】 程序运行结果如图4-13所示。
图4-13 例4-12程序运行结果
列表的基本操作
3.3
4．列表排序
（3）sorted()函数：与sort()方法不同，内置函数sorted()返回新列表，并不对原列表进行任何修改，其语法格式如下。
sorted(iterable[,key=None][,reverse=False])
其中，iterable表示可迭代对象，如列表；参数key和reverse的用法与sort()方法中的相同。例如：
number = [1, 5, 2, 3, 4] #创建列表number并赋值
#将number中的元素升序排序后赋给变量number_new
number_new = sorted(number)
print(number) #输出number，结果为[1, 5, 2, 3, 4]
print(number_new) #输出number_new，结果为[1, 2, 3, 4, 5]
PART 04
被束缚了的元组
元组的创建和访问
4.1
创建元组常用的方法是将逗号分隔的不同元素用圆括号括起来，也可省略圆括号，直接使用逗号分隔元素。例如：
x = ('a', 'b', 1, 2, 3) #创建元组x
print(x) #输出x，结果为('a', 'b', 1, 2, 3)
y = 'a', 'b', 'c', 'd' #创建元组y时省略了圆括号
print(y) #输出y，结果为('a', 'b', 'c', 'd')
如果要定义一个空元组，可以使用没有元素的圆括号来表示。例如：
x = () #创建空元组x
print(x) #输出x，结果为()
1．创建元组
元组的创建和访问
4.1
与列表类似，可以使用下标索引来访问元组中的元素。例如：
x = ('a', 1, 3.14) #创建元组x
print(x[0]) #输出索引为0的元素，结果为“a”
print(x[1]) #输出索引为1的元素，结果为1
print(x[-1]) #输出索引为-1的元素，结果为3.14
2．访问元组
元组的合并和遍历
4.2
元组中的元素值是不允许修改的，但可以对元组进行连接组合。例如：
x = (1, 2, 3) #创建元组x
y = ('a', 'b') #创建元组y
z = x + y #将x和y进行连接组合后赋给z
print(z) #输出z，结果为(1, 2, 3, 'a', 'b')
1．合并元组
元组的合并和遍历
4.2
2．遍历元组
【例4-13】 使用元组保存月份信息并输出。
【参考代码】
#创建元组months
months = ('January', 'February', 'March', 'April', 'May',
'June', 'July', 'August', 'September', 'October',
'November', 'December')
print('months索引为1的元素', months[1]) #输出months索引为1的元素
print('months索引为7的元素', months[7]) #输出months索引为7的元素
for month in months: #循环
print(month, end=' ') #输出元素
元组的合并和遍历
4.2
2．遍历元组
【例4-13】 使用元组保存月份信息并输出。
图4-14 例4-13程序运行结果
PART 05
有身份的字典
字典的创建
5.1
直接赋值创建字典的语法格式如下。
变量名 = {键1: 值1, 键2: 值2, 键3: 值3,……}
字典的元素放在大括号中，元素之间用逗号分隔，“键”与“值”之间用冒号分隔。例如，创建一个学生信息字典，包括学生学号、姓名和年龄3个元素，可以用下面代码实现。
#创建字典stu_info
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
1．直接赋值创建字典
字典是Python中常用的一种数据存储结构，它由“键-值”对组成，表示一种映射关系，每个“键-值”对称为一个元素。其中，“键”可以是Python中任意不可变数据类型，如数字、字符串、元组等，但不能是列表、集合、字典等可变数据类型；“值”可以是任意数据类型。
字典的创建
5.1
使用内置函数dict()可通过其他字典、“(键,值)”对的序列或关键字参数来创建字典。例如，通过下面5种方式使用dict()函数可创建相同的字典。
#直接赋值创建字典
stu_info1 = {'num': '20210101', 'name': '小蓝', 'age': 10}
#通过其他字典创建
stu_info2 = dict(stu_info1)
#通过“(键,值)”对的列表创建
stu_info3 = dict([('num','20210101'),('name','小蓝'),('age',10)])
#通过关键字参数创建
stu_info4 = dict(num = '20210101', name = '小蓝', age = 10)
#通过dict和zip结合创建
stu_info5 =dict(zip(['num','name','age'],['20210101','小蓝',10]))
2．使用内置函数dict()创建字典
字典的创建
5.1
3．使用fromkeys()方法创建字典
在Python中，当所有键对应同一个值时，可使用fromkeys()方法创建字典，其语法格式如下。
dict.fromkeys(seq[,value])
其中，seq为字典的“键”的列表；value为键对应的同一值，缺省时默认为None。例如：
#创建字典，“值”默认为None
stu_age1 = dict.fromkeys(['小蓝', '小舞'])
#输出stu_age1，结果为{'小蓝': None, '小舞': None}
print(stu_age1)
#创建字典，“值”赋为10
stu_age2 = dict.fromkeys(['小蓝', '小舞'], 10)
#输出stu_age2，结果为{'小蓝': 10, '小舞': 10}
print(stu_age2)
字典的访问
5.2
1．根据键访问值
字典中的“键”可作为下标访问对应的“值”，如果字典中不存在这个“键”则会抛出异常，其语法格式如下。
dict[key]
其中，dict表示字典名，key表示要查找的键。例如：
#创建字典
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
stu_info['num'] #根据num获取学号，结果为“20210101”
stu_info['name'] #根据name获取姓名，结果为“小蓝”
字典的访问
5.2
2．使用get()方法访问值
在访问字典时，若不确定字典中是否有某个键，可通过get()方法获取，若该键存在，则返回其对应的值，若不存在，则返回默认值，其语法格式如下。
dict.get(key[,default = None])
其中，dict表示字典名；key表示要查找的键；default表示默认值，如果指定键的值不存在，返回该默认值，当default缺省时，返回None。例如，使用get()方法访问前面定义的stu_info字典，可以用下面代码实现。
stu_info.get('name') #使用get()方法获取学生姓名，结果为“小蓝”
stu_info.get('sex') #使用get()方法获取学生性别，返回值为None
stu_info.get('sex', '女') #设置返回默认值为“女”，返回值为“女”
字典的访问
5.2
2．使用get()方法访问值
【例4-14】 创建中英文字典，根据输入的中文词组输出对应的英文单词。
【参考代码】
chinese = ['卷心菜', '午餐', '机器人', '天空', '花'] #创建中文词组列表chinese
english = ['cabbage', 'lunch', 'robot', 'sky', 'flower'] #创建英文单词列表english
dictionary = dict(zip(chinese, english)) #使用dict()和zip()方法生成字典
word = input('请输入中文词组：') #输入中文词组，并赋给word
print(dictionary.get(word)) #使用get()方法获取word的值并输出
【问题分析】 创建两个列表分别保存中文词组（键）和英文单词（值），要求两个列表一一对应；然后通过dict()和zip()函数创建字典；最后根据输入的中文词组，使用get()方法获取对应的值并输出。
字典的访问
5.2
2．使用get()方法访问值
【运行结果】 程序运行结果如图4-15所示。
图4-15 例4-14程序运行结果
字典的基本操作
5.3
1．修改和添加元素
当以指定“键”为下标给字典元素赋值时，有下面两种含义。
（1）若该“键”在字典中存在，则表示修改该“键”对应的值。
（2）若该“键”不存在，则表示添加一个新的“键-值”对，即添加一个新元素到字典中。例如：
#创建字典
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
stu_info['age'] = 11 #修改age的值
print(stu_info['age']) #输出修改后的age值，结果为11
stu_info['sex'] = '女' #添加学生性别
#输出添加后的字典，结果为{'num': '20210101', 'name': '小蓝', 'age': 11, 'sex': '女'}
print(stu_info)
字典的基本操作
5.3
2．删除元素
（1）del命令：根据“键”删除字典中的元素，例如：
#创建字典
stu_info={'num': '20210101', 'name': '小蓝','age': 10}
del stu_info['age'] #删除age“键-值”对
#输出删除后的字典，结果为{'num': '20210101', 'name': '小蓝'}
print(stu_info)
字典的基本操作
5.3
2．删除元素
（2）clear()方法：删除字典中的所有元素，其语法格式如下。
dict.clear()
其中，dict表示字典名。该方法不包含任何参数，也没有返回值。例如：
#创建字典
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
stu_info.clear() #清空字典
print(stu_info) #输出清空后的字典，结果为{}
字典的基本操作
5.3
2．删除元素
（3）pop()方法：删除指定的“键-值”对，并返回该“键”的值，其语法格式如下。
dict.pop(key[,default])
其中，dict表示字典名；key表示删除的键；default是默认值，当字典中没有要删除的key时，该方法返回指定的默认值。例如：
#创建字典
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
stu_info.pop('age') #删除age“键-值”对，并返回age的值10
stu_info.pop('age', 11) #无指定键，返回默认值11
字典的基本操作
5.3
2．删除元素
（4）popitem()方法：随机删除并返回一个“键-值”对，其语法格式如下。
dict.popitem()
其中，dict表示字典名。该方法无参数，返回值为一个随机的“键-值”对。例如：
#创建字典
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
stu_info.popitem() #随机删除并返回某“键-值”对，如('age', 10)
#输出字典，结果为{'num': '20210101', 'name': '小蓝'}
print(stu_info)
字典的基本操作
5.3
3．更新字典
update()方法用于将新字典的“键-值”对一次性全部添加到当前字典中，如果两个字典中存在相同的“键”，则以新字典中的“值”更新当前字典，其语法格式如下。
dict.update(dict1)
其中，dict表示当前字典，dict1表示新字典。例如：
#创建字典stu_info
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
#修改age的值，同时添加新元素
stu_info.update({'age': 11, 'sex': '女'})
#输出字典，结果为{'num': '20210101', 'name': '小蓝', 'age': 11, 'sex': '女'}
print(stu_info)
字典的基本操作
5.3
3．更新字典
【例4-15】 更新中英文字典。
【参考代码】
dictionary = {
'卷心菜': 'cabbage',
'午餐': 'lunch',
'机器人': 'robot',
'天空': 'sky',
'花': 'flower'
} #创建字典dictionary并赋值
print(dictionary) #输出dictionary
dictionary.pop('卷心菜') #删除“卷心菜”键-值对
print(dictionary) #输出dictionary
字典的基本操作
5.3
3．更新字典
【参考代码】（续）
#添加新字典
dictionary.update({'公园': 'park', '桥': 'bridge'})
print(dictionary) #输出dictionary
dictionary['午餐'] = ['lunch', 'nooning'] #修改“午餐”的值
print(dictionary) #输出dictionary
【运行结果】 程序运行结果如图4-16所示。
图4-16 例4-15程序运行结果
字典的基本操作
5.3
4．复制字典
复制字典可使用copy()方法，返回字典的浅复制，其语法格式如下。
dict.copy()
其中，dict表示需要复制的字典，该方法无参数，返回一个新字典。例如：
#创建字典stu_info
stu_info = {'num': '20210101', 'name': '小蓝', 'age': 10}
stu_info1 = stu_info.copy() #复制stu_info，并赋给stu_info1
#输出stu_info1，结果为{'num':'20210101','name':'小蓝', 'age': 10}
print(stu_info1)
字典的基本操作
5.3
4．复制字典
【例4-16】 使用直接赋值、浅复制和深复制3种方法复制中英文字典。
【参考代码】
import copy #导入copy模块
#创建字典dictionary并赋值
dictionary = {'卷心菜': 'cabbage', '午餐': ['lunch', 'nooning']}
dictionary1 = dictionary #直接复制
dictionary2 = dictionary.copy() #浅复制
dictionary3 = copy.deepcopy(dictionary) #深复制
#将dictionary中键为“卷心菜”的值改为“pamphrey”
dictionary['卷心菜'] = 'pamphrey'
字典的基本操作
5.3
4．复制字典
【参考代码】（续）
#移除dictionary中键为“午餐”的值列表中的“nooning”
dictionary['午餐'].remove('nooning')
print('dictionary = ', dictionary) #输出dictionary
print('dictionary1 = ', dictionary1) #输出dictionary1
print('dictionary2 = ', dictionary2) #输出dictionary2
print('dictionary3 = ', dictionary3) #输出dictionary3
【运行结果】 程序运行结果如图4-17所示。
图4-17 例4-16程序运行结果
字典的基本操作
5.3
4．复制字典
【程序说明】 “dictionary1 = dictionary”是复制引用，dictionary和dictionary1都指向同一个对象，如图4-18所示。因此，修改dictionary中的任何一个值，dictionary1中也会随之改变。
图4-18 赋值引用示意图
字典的基本操作
5.3
4．复制字典
【程序说明】（续） “dictionary2 = dictionary.copy()”是浅复制，dictionary和dictionary2分别是独立的对象，但它们的子对象还是指向同一对象，如图4-19所示。因此，修改“dictionary['卷心菜'] = 'pamphrey'”不会改变dictionary2中的值，但修改dictionary中的子对象“dictionary['午餐'].remove('nooning')”时，dictionary2也会随之改变。
图4-18 赋值引用示意图
字典的基本操作
5.3
4．复制字典
【程序说明】（续） “dictionary3 = copy.deepcopy(dictionary)”是深复制，dictionary3完全复制了父对象及其子对象，它和dictionary是完全独立的，如图4-20所示。因此，修改dictionary中的任何一个值，dictionary3中的值都不会随之改变。
图4-20 深复制示意图
字典的遍历
5.4
1．遍历字典中所有的“键-值”对
使用item()方法可遍历字典中所有的“键-值”对，该方法以列表形式返回可遍历的“(键,值)”元组，其语法格式如下。
dict.items()
其中，dict表示字典。
2．遍历字典中所有的键
当不需要使用字典中的值时，可使用keys()方法只遍历字典中的键，该方法以列表形式返回字典中所有的键，其语法格式如下。
dict.keys()
其中，dict表示字典。
字典的遍历
5.4
3．遍历字典中所有的值
当只需要使用字典中的值时，可使用values()方法，该方法以列表形式返回字典中所有的值，其语法格式如下。
dict.values()
其中，dict表示字典。
【例4-17】 输出中英文字典中所有的中文词组及其对应的英文单词、中文词组和英文单词。
字典的遍历
5.4
【参考代码】
dictionary = {
'卷心菜': 'cabbage',
'午餐': 'lunch',
'机器人': 'robot',
'天空': 'sky',
'花': 'flower'
} #创建字典dictionary并赋值
print('中英文字典中所有中文词组及其对应的英文单词')
for item in dictionary.items(): #遍历“键-值”对
print(item) #输出每个“键-值”对
print('中英文字典中所有中文词组')
for chinese in dictionary.keys(): #遍历字典所有的键
print(chinese, end=' ') #输出每个键
print('\n中英文字典中所有英文单词')
for english in dictionary.values(): #遍历字典所有的值
print(english, end=' ') #输出每个值
字典的遍历
5.4
【运行结果】 程序运行结果如图4-21所示。
图4-21 例4-17程序运行结果
PART 06
独一无二的集合
集合的创建
6.1
a = {1, 2, 3, 4} #创建集合并赋值
print(a) #输出集合a，结果为{1, 2, 3, 4}
b = {2, 1, 3, 4, 1, 2} #创建集合并赋值
print(b) #输出集合b，结果为{1, 2, 3, 4}
由上述代码可以看出，由于集合元素是无序的，所以集合的输出结果与定义顺序可能不一致。
创建集合只需将逗号分隔的不同元素使用大括号括起来即可。例如：
集合的基本操作
6.2
1．添加和删除元素
与字典类似，Python也提供了多种函数和方法用于集合元素的添加和删除，具体操作的函数和方法如表4-5所示。
表4-5 集合操作的函数和方法
集合的基本操作
6.2
1．添加和删除元素
例如：
s = {1, 2, 3} #创建集合并赋值
s.add(4) #添加元素
print(s) #输出集合，结果为{1, 2, 3, 4}
s.update({4, 5, 6}) #更新当前集合，自动去除重复元素
print(s) #输出集合，结果为{1, 2, 3, 4, 5, 6}
s.discard(5) #删除元素，不存在则忽略该操作
print(s) #输出集合，结果为{1, 2, 3, 4, 6}
s.remove(3) #删除元素，不存在则抛出异常
print(s) #输出集合，结果为{1, 2, 4, 6}
s.pop() #删除并返回一个元素，返回值为1
print(s) #输出集合，结果为{2, 4, 6}
集合的基本操作
6.2
2．集合运算
内置函数len()、max()、min()、sorted()等也适用于集合，此外，Python中集合还支持数学意义上的交集、并集、差集、补集等运算，具体操作符如表4-6所示。
表4-6 集合类型的操作符
集合的基本操作
6.2
2．集合运算
例如：
a = {1, 2, 3, 4, 5} #创建集合并赋值
b = {1, 2, 6, 7, 8} #创建集合并赋值
print(a & b) #输出交集，结果为{1, 2}
print(a | b) #输出并集，结果为{1, 2, 3, 4, 5, 6, 7, 8}
print(a - b) #输出差集，结果为{3, 4, 5}
print(a ^ b) #输出补集，结果为{3, 4, 5, 6, 7, 8}
x = {1, 2, 3} #创建集合并赋值
y = {2, 3} #创建集合并赋值
z = {1, 2, 4} #创建集合并赋值
print(x >= y) #判断y是否为x的子集并输出，结果为True
print(x <= z) #判断x是否为z的子集并输出，结果为False
感谢观看

展开更多......

收起↑