什么是可迭代对象？
支持同构 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 创建列表
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
2.2 访问列表元素
列表的作用是一次性存储多个数据，程序员可以对这些数据进行操作的有：增 删 改 查
列表元素的查找
用列表元素的下标查找（访问）
格式：序列名[下标]
下标就是计算机内存为列表的每个元素分配了一个地址，也是编号。
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tome
print(name_list[1]) # Lily
print(name_list[2])
用函数查找（访问）
略
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)
排序： sor() 函数
语法：列表名.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 列表推导式
列表推导式（功能：简化代码；创建或控制有规律的列表）
# 需求：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. 十大歌手
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)) # set
4.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)
输出结果：
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])
方式二：函数查找
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 支持通过 pop()、 popitem() 和 clear() 函数修改字典中的元素
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)
运行程序，输出结果如下：
实例训练
1.青春有你
2.手机通讯录
组合数据类型与运算符
公共操作，数据序列都支持的操作方式。
三个方面的内容：运算符、公共方法和容器类型转换
- 运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| 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)