目录
- 一、认识组合数据类型
- 二、列表
- 2.1 创建列表
- 2.2 访问列表元素
- 2.3 添加列表元素 (append、extend和insert)
- 2.4 元素排序（sort、reverse）
- 2.5 删除列表元素（del、pop、remove和clear）
- 2.6 列表元素的统计
- 2.7 二维列表的创建
- 2.8 列表推导式
- 三、元组
- 3.1 元组的应用场景
- 3.2 元组的定义
- 实例训练
- 1. 十大歌手
- 2.神器魔方阵
- 四、集合
- 4.1 创建集合
- 4.2 集合常见操作—增加数据（add和update）
- 4.3 集合常见操作—删除数据（remove、dicard和pop）
- 4.4 集合常见操作—查找数据
- 五、字典
- 5.1 创建字典
- 5.2 字典的（查找）访问(key值、get、keys、values和items)
- 5.3 字典元素的添加和修改（' 键=值 ' 和update）
- 5.4 字典元素的删除（pop、popitem和clear）
- 5.5 字典推导式
- 5.6 总结
- 实例训练
- 1.青春有你
- 2.手机通讯录
- 3.学生信息管理系统
- 组合数据类型与运算符
什么是可迭代对象？
支持同构 for…in…语句迭代获取数据的对象就是可迭代对象。
字符串、列表、集合、字典和文件类型的数据都是可迭代对象。
使用isinstance()函数 可以判断目标是否为可迭代对象，示例代码如下：
from collections.abc import Iterable
ls = [3,4,5]
print(isinstance(ls, Iterable))运行结果为 True
一、认识组合数据类型
什么是组合数据类型？
我们知道组合的意思是将数据组织在一起，之前，我们学过的数据类型有：整型、浮点型、字符串数据类型。
组合数据类型是指 将多个相同类型或不同类型的数据组织为一个整体，根据数据组织方式的不同，Python 组合数据类型分为三类：序列类型、集合类型和映射类型。
- 序列类型
分类 | 数据序列 | 说明 |
序列类型 | 字符串（str）、列表（list）和元组（tuple） | 序列类型支持双向索引，正向递增索引和反向递减索引。 |
- 集合类型
集合具备三个特性：确定性、互异性和无序性。
确定性：给定一个集合，那么任何一个元素是否在集合中就确定了。
互异性：集合中的元素 互不相同。
无序性：集合中的元素没有顺序(顺序不同但元素相同的集合可视为同一集合)
- 映射类型
映射类型 以键值对的形式存储元素，键值对中的键与值之间存在映射关系。
字典（dictionary）是Python 中唯一的内置映射类型，字典的键必须遵守以下两个原则：
第一，每个键只能对应一个值，不允许同一个键在字典中重复出现；
第二，字典中的键是不可变类型。
|
二、列表
2.1 创建列表
列表（list）是与字符串相似的结构，可以视为一列格子，编号从 0 开始，与字符串不同，每个格子里面可以放任何类型的数据。
在使用时用[ ]表示，例如：
ls = ['apple', 100, 3.14159265] # 列表中的元素可以是 字符串、整数、浮点数...
print(ls)输出结果：
列表里面甚至可以存放列表，例如：
# 列表里面甚至可以存放列表，例如
ls = ['apple', 100, 3.1415926, '1', [1, 2, 3]]
print(ls)输出结果：
Python 列表的创建方式分为两种：
- 第一种可以直接用"
[]" 中括号创建； - 第二种可以用内置函数
list()创建。
示例：
list1 = []
list2 = ['p', 'y', 't', 'h', 'o', 'n']
list3 = list()
list4 = list('python') # 元素 ‘python'注意：当使用list()创建列表时，若传入的数据 不是可迭代类型 的时候会报错！
list3 = list(1) # 1 不是可迭代对象
print(list3)报错：TypeError:'int' object is not iterable
除此之外，可以使用内置函数 len 函数求列表中的元素个数，可以使用+运算符连接两个列表，用*运算符构造重复的列表。
a = [1, 2, 3]
b = [4, 5, 6]
print(len(a))
print(a + b)
print(a * 3)输出结果：
2.2 访问列表元素
列表的作用是一次性存储多个数据，程序员可以对这些数据进行操作的有：增 删 改 查
列表元素的查找
用列表元素的下标查找（访问）
格式：序列名[下标]
下标就是计算机内存为列表的每个元素分配了一个地址，也是编号。
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tome
print(name_list[1]) # Lily
print(name_list[2]) # Rose
print(name_list[0:2]) # 下标为0和2的元素：Tom 、 Rose
print(name_list[-2:]) # 倒数2位元素: Lily 、 Rose用函数查找（访问）
略
2.3 添加列表元素 (append、extend和insert)
添加指定数据到列表中
函数1： append() 函数列表结尾追加数据
语法： 列表名.append(数据)
示例：
num = ['1' , '2', '3']
num.append('9') # 字符串序列
num.append([11, 22]) # 列表序列
# 结果1： ['1' , '2', '3', '9']
# 结果2： ['1' , '2', '3', '9', [11, 22]]
print(num)
append()函数 总结：
1、列表数据是可改的 —— 列表是可变类型
2、append() 函数追加数据的时候如果数据是一个序列，追加整个序列到列表的结尾。
函数2： extend 函数列表结尾追加数据
语法： 列表名.extend(数据)
示例：
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming') # 将字符串数据序列 拆开 单个元素追加到列表结尾
name_list.extend(['xiaoming', 'xiaoming']) # 将列表拆开，追加到列表的结尾
# 结果1：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
# 结果2：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaoming']
print(name_list)
extend()函数总结
1、extend()函数追加的数据是一个序列时，把数据序列里面的数据拆开成单个元素后，逐一追加到列表的结尾
函数2： insert 函数列表结尾追加数据
语法： 列表名.insert(位置下标，数据)
示例：
name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming') # 将'xiaoming' 插入到列表下标为1 的位置
# 结果1：['Tom', 'xiaoming', 'Lily', 'Rose',]
print(name_list)
insert()函数总结
1、insert()函数指定位置新增数据
2.4 元素排序（sort、reverse）
逆置 ： reverse() 函数
只是列表内的元素位置发生变化，不按照元素大小排序！！！
# 逆置 reverse()
list1 = [1, 4, 2, 3, 9]
list1.reverse()
# 结果：[9,3,2,4,1]
print(list1)排序： sort() 函数
语法：列表名.sort(key = None, reverse = False) （参数 key 用于字典数据序列的值排序）
示例：
# sort() 排序 ：升序 和 降序
list1 = [1, 4, 2, 3, 9]
list1.sort() # 默认升序
list1.sort(reverse = False) # 升序
list1.sort(reverse = True) # 降序
# 结果1：[1,2,3,4,9]
# 结果2：[1,2,3,4,9]
# 结果3：[9,4,3,2,1]
print(list1)注意：reverse 表示排序规则，reverse = True 降序（3, 2,1），reverse = False (默认)升序 (1, 2, 3)
2.5 删除列表元素（del、pop、remove和clear）
del()函数
作用： 删除整个目标（可以是列表、函数） 和 删除指定列表下标的数据
语法：del 列表名 和 del(列表名）
示例：
name_list = ['tom', 'lily', 'rose']
name_list2 = ['tom', 'lily', 'rose']
del name_list
# del(name_list)
# 结果：报错 NameError 'name_list' 没有定义 原因是列表别删除了
print(name_list)
# del 可以删除指定下标的数据
del name_list2[0]
# 结果：['lily', 'rose']
print(name_list2) #pop()函数
作用：删除指定下标的数据（默认为最后一个数据），并返回该数据。
语法：列表名.pop(下标)
示例：
name_list = ['tom', 'lily', 'rose']
del_name = name_list.pop(1) # 删除序列下标为1 的元素'lily'，并返回'lily'
# 结果为：lily
print(del_name)
# 结果为：['tom', 'rose']
print(name_list)remove()函数
作用：remove()函数 删除列表中某个元素的第一个匹配项。
语法：列表命名.remove(数据)
示例：
name_list = ['tom', 'lily', 'rose']
name_list.remove('rose')
# 结果：['tom', 'lily']
print(name_list)clear()函数
作用：清空列表
语法：列表命名.clear()
示例：
name_list = ['tom', 'lily', 'rose']
name_list.clear()
# 结果：[] 空列表
print(name_list)2.6 列表元素的统计
使用count()函数统计列表中某个元素的个数
ls = [20, 20, 20, 20, 20, 60, 60, 100, 99, 6, 9, 4, 5, 55, 77, 0.369, 100]
print(ls.count(20)) # 统计列表中元素为 20 的个数
ls.sort() # 排序--升序
print(ls)
print(max(ls)) # 统计列表中元素的最大数
print(min(ls)) # 统计列表中元素的最小数输出结果：
2.7 二维列表的创建
问题：想要修改二维列表中其中一个值，会造成所有项都改变！
match = [[0] * 4] * 4 # 比赛情况 注意：这是错误的二维列表的创建方式
# match = [[0]*4 for _ in range(4)] # 这是正确的二维列表创建方式
print(match)
for i in range(4):
for j in range(4):
match[0][j] = 1
print(f"match[{i}][{j}]={match[i][j]}", end=" ")
print()输出结果：所有的元素都被修改了！
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
match[0][0]=1 match[0][1]=1 match[0][2]=1 match[0][3]=1
match[1][0]=1 match[1][1]=1 match[1][2]=1 match[1][3]=1
match[2][0]=1 match[2][1]=1 match[2][2]=1 match[2][3]=1
match[3][0]=1 match[3][1]=1 match[3][2]=1 match[3][3]=1
解决办法
原因是，创建二维数组的方式有问题。可能使用的创建方式是：
match = [[0] * 4] * 4 # 比赛情况正确创建二维列表的方式为：
list1 = [[0] * 3 for _ in range(3)]2.8 列表推导式
列表推导式（功能：简化代码；创建或控制有规律的列表）
# 需求：0,1,2，4，…… （创建有规律的列表）
# 1.循环实现
# 2.列表推导式（功能：简化代码；创建或控制有规律的列表）
# 方式一：while 实现
list1 = []
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)
# 方式二：for 实现
list2 = []
for i in range(10)
list2.append(i)
print(list2)
# 方式三：列表推导式实现
list3 = [i for i in range(10)]
print(list3)带 if 的列表推导式
# 需求： 0-10偶数数据的列表 [0,2,4,6,8]
# 1. 简单列表推导式 range 步长
list1 = [i for i in range(0,10,2)]
print(list1)
# 2.for循环加if 创建有规律的列表
list2 = []
for i in range(10)
if i % 2 == 0:
list2.append(i)
print(list2)
# 3.把for循环配合if的代码 改写 带if的列表推导式
list3 = [i for i range(10) if i % 2 ==0]
print(list3)多个for循环实现列表推导式
需求：创建如下列表
[(1, 0), (1, 1), (1, 2),(2, 0), (2, 1), (2, 2)]
# 需求：[(1, 0), (1, 1), (1, 2),(2, 0), (2, 1), (2, 2)]
# 分析：
# 数据1 ： 1 和 2 -- range(1,3)
# 数据2： 0 1 2 ---range(3)
# 方式一：for嵌套
list2 = []
for i in range(1, 3):
for j in range(3):
list2.append((i, j))
print(list2)
# 方式二：多个for实现列表推导式
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)三、元组
3.1 元组的应用场景
思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么操作？
答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。
num = [10, 20 ,30]
num[0] = 100 # 将列表下标为0 的元素从10 更改为 100注意：一个元组可以储存多个数据，元组内的 数据是不能修改的。
3.2 元组的定义
定义：元组使用小括号定义，且逗号隔开各个数据，数据可以是不同的数据类型（最好保证元组内的数据类型一致）。
t1 = (10, 'a', 1.2) # 多个数据类型元组，最好保证元组内的数据类型一致！
t2 = (10,) # 单个数据元组
t3 = () # 空元组注意：如果定义的元组只有一个数据，该元素后面的逗号" , " 不能省略，否则数据类型为小括号内唯一元素的这个数据的数据类型。
t2 = (10,) # 元组
t3 = (10) # 整型
t4 = ('hello') # 字符串元组常见的操作
使用内置函数 tuple()也可以创建元组，当函数参数列表为空时，该函数创建元组，当参数为可迭代对象时该函数创建非空元组。
示例代码
t1 = tuple() # 创建空元组
t2 = tuple([1,2,3]) # 利用列表创建元组
t3 = tuple('python') # 利用字符串创建元组('p', 'y', 't', 'h', 'o', 'n')
t4 = tuple(range(5)) # 利用可迭代对象创建元组(0,1,2,3,4)
print(t1, t2,t3,t4)
与列表相同，Python支持通过索引和切片访问元组的元素，也支持在循环中遍历元组，示例代码如下：
t1 = tuple() # 创建空元组
t2 = tuple([1,2,3]) # 利用列表创建元组
t3 = tuple('python') # 利用字符串创建元组('p', 'y', 't', 'h', 'o', 'n')
t4 = tuple(range(5)) # 利用可迭代对象创建元组(0,1,2,3,4)
print(t2[1]) # 以索引方式访问元组元素
print(t3[3:5]) # 以切片方式范根元组元素
for data in t3:
print(data, end='')输出结果如下：
实例训练
1. 十大歌手
场景预设：学校组织了这么一个比赛，设置了10名评委打分，为了防止作弊和恶意打分，去掉最高分和最低分再计算平均分作为选手成绩。
本实例要求编写这样一个程序：记录评委打分，排序去掉最高和最低分，计算平均分。
import time
# 创建存储评委打分数的空列表
score_ls = []
# 定义记录总分数的整型变量
score = 0
print('*'*50)
for i in range(1, 11):
s = int(input(f"请第{i}为评委打分："))
score_ls.append(s) # 将分数s添加进列表score_ls
print('*'*50)
print("评委分数：", end="")
for i in score_ls:
print(i, end=" ")
time.sleep(0.1)
# print("\n"len(score_ls))
# 列表元素排序
score_ls.sort(reverse=False) # 升序
print("\n升序：", end="")
for i in score_ls:
print(i, end=" ")
time.sleep(0.1)
# 删除最低/最高分
del score_ls[0] # 删除元素--下标
# score_ls.remove(score_ls[0]) # 删除某个--元素
# score_ls.pop(0) # 删除元素--下标
del score_ls[len(score_ls)-1]
print("\n去掉最低/高分：", end="")
for i in score_ls:
print(i, end=" ")
time.sleep(0.1)
for i in score_ls:
score += i
# time.sleep(0.1)
print(f"\n总分：{score}", end=" ")
print(f'\n实际分数：{score/(len(score_ls))}')2.神器魔方阵
四、集合
4.1 创建集合
创建集合使用{} 或set() ,但是如果要创建空集合只能使用set(),因为{}是用来创建字典的。
# 1. 创建有数据的集合
s1 = {10, 20, 30, 40, 50} # 集合没有下标，集合无顺序
print(s1)
s2 = {10, 10,20, 30, 40, 50} # 集合里面的元素数据不能重复(去重打印数据)
print(s2) # 去重
# 2.创建空集合
s3 = {} # 注意：{}表示字典
print(s3) # 字典类型
s5 = set('abcdefg')
# 结果： {‘e', 'b', 'a', 'd', 'c', 'f', 'g'} 集合内的元素数据无序
print(s5)
s4 = set()
print(type(s4)) # set4.2 集合常见操作—增加数据（add和update）
s1 = {10, 20}
#1. 集合是可变的数据序列
# add()
s1.add(100)
# 结果：{100,10, 20}
print(s1)
# 集合有去重功能，如果追加的数据是集合已有数据，则什么事情都不做
s1.add(100)
# 结果：{100,10, 20}
print(s1)
#
# update() :增加的数据是序列
s1.update([10,20,30,40]) # 集合s1追加列表
print(s1)4.3 集合常见操作—删除数据（remove、dicard和pop）
remove()函数, 删除集合中的指定数据，如果数据不存在则报错。
s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)discard()函数,删除集合中的指定数据，如果数据不存在不会报错。
s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)pop()函数, 随机删除集合汇总的某个数据，并返回这个数据。
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(s1)4.4 集合常见操作—查找数据
in: 判断数据在集合序列
not in: 判断数据不再集合序列
s1 = {10, 20, 30, 40, 50}
print(10 in s1) # 返回 True
print(10 not in s1) # 返回False五、字典
5.1 创建字典
字典的特点：
- 符号为
大括号{} - 数据为
键值对形式出现 - 各个键值对之间用
逗号隔开
示例程序：
（创建有数据的字典和空字典）
# 创建有数据的字典
dict1 = {'name':'Tom', 'age':'18', 12:'male'}
# 创建空字典
dict2 = {} # 方法一
dict3 = dict() # 方法二
# dict3 = dict({'name':'Tom', 'age':'18', 'sexy':'male'}) # 方法二
print(dict1)
print(type(dict1))
print(dict2)
print(dict3)输出结果：
使用 for 循环可以遍历字典里所有数据，例如：
# 遍历字典
for i in num:
print(i, num[i], end=" ")
print()
# 另一种遍历
for key, value in num.items():
print(key, value, end=" ")输出结果：
5.2 字典的（查找）访问(key值、get、keys、values和items)
字典的查找（访问）
方式一：key值查找
注意：如果当前的key存在，则放回key对应的值value；否则报错
# 字典的查找（访问）
# 注意：如果当前的key存在，则放回key对应的值value；否则报错
# 方式1：key值查找
dict1 = {'name': 'Tom', 'age': '18', 12:'male'}
print(dict1['name'])
print(dict1[12])使用 in 可以查看字典里面是否有某个键，例如：
num = {'one':1, 'two':2, 3:9}
print('i' in num) # 查看 键 是否存在 字典 中
print('one' in num)输出结果：
又例如：
dic = {'pen':'笔', 'apple':'苹果', 'pineapple':'菠萝'}
if 'pen' in dic:
print(f"\n字典中的\'pen\'：{dic['pen']}")
else:
print('No')方式二：函数查找
-
get()
Python 中提供了内置方法get()，该方法根据键从字典中获取对应的值，若指定的键不存在，则返回默认值（default），语法格式如下：字典名.get(键[, default])
# 方式2：get()函数查找
dict1 = {'name': 'Tom', 'age': '18', 12:'male'}
print(dict1.get('name'))
print(dict1.get(12))Python 字典数据分为键、值和元素（键值对），除了直接利用键访问外，Python还提供了御用访问字典中所有键、值和元素的内置方法 key() 、 values() 、items()
key() - 获取字典中的所有键values() - 获取字典中的所有值items() - 获取字典中的所有元素
dict1 = {'name': 'Tom', 'age': '18', 12:'male'}
print(dict1.keys()) # 利用keys()方法获取所有键
print(dict1.values()) # 利用values()方法获取所有值
print(dict1.items()) # 利用items()方法获取所有元素输出结果如下：
5.3 字典元素的添加和修改（’ 键=值 ’ 和update）
字典元素的添加：
方式1: 字典变量名['键'] = 值
方式2:字典变量名.update(键的名字 = 值)
# 方式1. 字典变量名['键'] = 值
# dict1 = {'name': 'Tom', 'age': '18', 12:'male'}
# dict1['sco'] = 100 # 添加元素
# print(dict1)
# 方式2：字典变量名.update(键的名字 = 值)
dict1 = {'name': 'Tom', 'age': '18', 12:'male'}
dict1.update(sexy = '男') # 添加元素
print(dict1)字典元素的修改：
修改字典元素的本质是通过键获取值 ，再重新对元素进行赋值。修改元素的操作与添加元素的操作相似，示例代码如下所示：
stu_dict = {'stu1': '兰兰','stu2':'红红','stu3': '黄黄'}
print(stu_dict)
stu_dict.update(stu3 = '小黑') # 通过update()修改元素
stu_dict['stu2'] = '小明' # 通过制定键修改元素值
print(stu_dict)运行代码，结果如下：
5.4 字典元素的删除（pop、popitem和clear）
Python 支持通过del、 pop()、 popitem() 和 clear()
可以使用del 删除某对键值， 例如：
dic = {'pen':'笔', 'apple':'苹果', 'pineapple':'菠萝'}
if 'pen' in dic:
print(f"\ndic中的\'pen\'：{dic['pen']}")
else:
print('No')
del dic['apple'] # 删除某对键值
print(dic)输出结果：
pop() 方法
功能：pop()方法可以根据指定键删除字典中对应的元素，若删除成功，该方法返回目标元素的值
stu_dict = {'stu1': '兰兰','stu2':'红红','stu3': '黄黄'}
print(stu_dict.pop('stu1'))
print(stu_dict)运行程序，输出结果如下：
popitem() 方法
功能： 使用此方法可以随机删除字典中的元素。实际上popitem()之所以能随机删除元素，是因为字典元素本身无序，没有"第一项""最后一项"之分。若删除成功返回被删粗元素。
stu_dict = {'stu1': '兰兰', 'stu2': '红红', 'stu3': '黄黄'}
print(stu_dict.popitem())
print(stu_dict)
print(stu_dict.update())运行程序，输出结果如下：
clear() 方法
功能：clear()用于清空字典中的元素
stu_dict = {'stu1': '兰兰', 'stu2': '红红', 'stu3': '黄黄'}
stu_dict.clear()
print(stu_dict)结果如下：
5.5 字典推导式
字典推导式的格式、用法与列表推导式类似，区别在于字典推导式外侧为大括号"{ }" ,且内部需包含键和值2个部分，具体格式如下所示：
{ new_key : new_value for key , value in dict.items()}
利用字典推导式，可以快速交换字典中键和值的位置 示例代码如下：
old_stu_dict = {'stu1': '兰兰', 'stu2': '红红', 'stu3': '黄黄'}
new_stu_dict = {value : key for key, value in old_stu_dict.items()}
print(new_stu_dict)运行程序，输出结果如下：
5.6 总结
字典的访问（遍历）、 增 、 删、 改、 查 。
# 字典的创建、访问(遍历)、添加、删除、修改、查找
# 创建
color_dic = {'blue': '蓝色', 'red': '红色', 'black': '黑色'}
# color_dic = {}
# color_dic = dict()
print('\n', '\t', color_dic)
# 访问
print('\t', color_dic['blue'], color_dic['red'], color_dic['black']) # 键访问— 相当于C语言中数组的下标
# 遍历
print('\t', "遍历1:", end="")# 换行
for i in color_dic: # 方式一
print('\t', i, color_dic[i], end=" ")
print('\n', '\t', "遍历2:", end="")# 换行
for key, value in color_dic.items(): # 方式二
print('\t', key, value, end=" ")
# 添加元素
color_dic['white'] = '白色' # 方式一
print('\n', '\t', "添加1：", color_dic)
color_dic.update(green='绿色') # 方式二
print('\t', "添加2：", color_dic)
# 删除
del color_dic['green'] # 方式一
print('\t', "删除1: ", color_dic)
color_dic.pop("white") # 方式二
print('\t', "删除2: ", color_dic)
# 修改
color_dic['black'] = '黑黑黑'
color_dic['red'] = '红红红'
print('\t', "修改1: ", color_dic)
# 查找
if 'blue' in color_dic:
print('\t', "查找1: ", f"color_dic中有\'blue\': {color_dic['blue']}")
print('\t', "查找2: ", color_dic.keys())
print('\t', "查找3: ", color_dic.values()) # 利用values()方法获取所有值
print('\t', "查找4: ", color_dic.items()) # 利用items()方法获取所有元素
print('\t', type(color_dic.keys()), '\t', type(color_dic.values()), '\t', type(color_dic.items()))
# 按要求取出字典中的各个元素
for i in color_dic.keys():
print('\t', i, end=" ")
print() # 换行
for i in color_dic.values(): # 遍历列表 取出所有’值‘
print('\t', i, end=" ")
print() # 换行
for i in color_dic.items(): # 第一层可迭代序列是 ’列表‘
for j in i: # 第二层可迭代序列是 ’元组‘
print('\t', j, end=" ")输出结果：
实例训练
1.青春有你
2.手机通讯录
3.学生信息管理系统
使用自定义函数，完成对程序的模块化
学生信息包含：姓名、性别、手机号
该系统具有的功能：添加、删除、修改、查找、退出系统
设计思路：
提示用户选择功能操作
获取用户选择的功能
根据用户的选择，分别调用不同的函数
"""
使用自定义函数，完成对程序的模块化
学生信息包含：姓名、性别、手机号
该系统具有的功能：添加、删除、修改、查找、退出系统
设计思路：
提示用户选择功能操作
获取用户选择的功能
根据用户的选择，分别调用不同的函数
"""
# 新建一个列表，用来保存学生的所有信息
stu_info = []
# 功能打印
# 打印功能菜单
def print_menu():
print('=' * 30)
print('学生管理系统 2021/12/2')
print('1.添加学生信息')
print('2.删除学生信息')
print('3.修改学生信息')
print('4.查询所有学生信息')
print('0.退出系统')
print('=' * 30)
# 添加学生信息
def add_stu_info():
# 提示并获取学生的姓名
new_name = input('请输入新学生的姓名:')
# 提示并获取学生的性别
new_sex = input('请输入新学生的性别:')
# 提示并获取学生的手机号
new_phone = input('请输入新学生的手机号码:')
new_info = dict() # 新建一空字典
new_info['name'] = new_name # 字典元素的添加和修改：字典的“键”：“值”对 添加字典元素
new_info['sex'] = new_sex
new_info['phone'] = new_phone
stu_info.append(new_info) # 添加列表元素
# 删除学生信息
def del_stu_info(student):
del_num = int(input('请输入要删除的序号：')) - 1
del student[del_num] # 删除列表指定下标的数据：del()函数 函数 - 列表变量 - 整型变量（列表的下标）
print("删除成功！")
# 修改学生信息
def modify_stu_info():
if len(stu_info) != 0:
stu_id = int(input('请输入要修改学生的序号:'))
new_name = input('请输入要修改学生的姓名:')
new_sex = input('请输入要修改学生的性别:(男/女)')
new_phone = input('请输入要修改学生的手机号码:')
stu_info[stu_id - 1]['name'] = new_name # 访问列表 ：list[下标][]
stu_info[stu_id - 1]['sex'] = new_sex
stu_info[stu_id - 1]['phone'] = new_phone
'''
数据类型：<class 'list'>
数据内容：[{'name': '小明', 'sex': '男', 'phone': '1002'}, {'name': '小红', 'sex': '女', 'phone': '1221111111111'}]
'''
print(type(stu_info))
print(stu_info)
else:
print('学生信息表为空')
# 显示所有的学生信息
def show_stu_info():
print('学生的信息如下：')
print('=' * 30)
print('序号 姓名 性别 手机号码')
i = 1
# tempInfo 遍历列表stu_info 中的元素（字典），再直接通过键值访问元素
for tempInfo in stu_info:
print("%d %s %s %s" % (i, tempInfo['name'],
tempInfo['sex'], tempInfo['phone']))
i += 1
# 在main函数中执行不同的功能
def main():
while True:
print_menu() # 打印功能菜单
key = input("请输入功能对应的数字：") # 获取用户输入的序号
if key == '1': # 添加学生信息
add_stu_info()
elif key == '2': # 删除学生信息
del_stu_info(stu_info)
elif key == '3': # 修改学生信息
modify_stu_info()
elif key == '4': # 查询所有学生信息
show_stu_info()
elif key == '0':
quit_confirm = input('亲，真的要退出么？(Yes or No):').lower() # 转换字符串中所有 大写 字符为 小写
if quit_confirm == 'yes':
print("谢谢使用！")
break # 跳出循环
elif quit_confirm == 'no':
continue
else:
print('输入有误!')
if __name__ == '__main__':
main()总结：
创建一个可迭代序列列表 来存放所有学生的信息；再创建一个字典，利用字典键值对的访问与修改 来对列表内的学生信息做修改操作。
数据类型—列表list：<class 'list'>
数据内容—字典dictionary：[{'name': '小明', 'sex': '男', 'phone': '1002'}, {'name': '小红', 'sex': '女', 'phone': '1221111111111'}]
组合数据类型与运算符
公共操作，数据序列都支持的操作方式。
三个方面的内容：运算符、公共方法和容器类型转换
- 运算符
运算符 | 描述 | 支持的容器类型 |
+ | 合并 | 字符串、列表、元组 |
* | 复制 | 字符串、列表、元组 |
in | 元素是否存在 | 字符串、列表、元组、字典 |
not in | 元素是否不存在 | 字符串、列表、元组、字典 |
合并
str1 = 'aa'
str2 = 'bb'
list1 = [1, 2]
list2 = [10, 20]
t1 = (1, 2)
t2 = (10, 20)
dict1 = {'name':'pyton'}
dict2 = {'age':'18'}
print(str1 + str2) # 结果为：aabb
print(list1 + list2) # 打印输出结果为：[1,2,10,20]
print(t1 + t2)
# print(dict1 + dict2) # 报错：字典不支持合并运算复制
str1 = 'a'
list1 = ['hello']
t1 = ('world',)
# *: 复制
print(str1 * 5)
# 打印10个‘-’
print('-' * 10)
print(list1 * 5) # 输出结果为：['hello','hello','hello','hello','hello']
print(t1 * 5)元素是否存在
dict1 = {'name':'pyton','age':'19'}
print('name' in dict1)
print('name' not in dict1)
print('name' in dict1.keys)
print('name' not in dict1.keys)
print('name' in dict1.values)
