python容器类型元组,字典和集合
元组
-
概述: 属于容器类型的一种,但可以同时储存多个元素,但元组内容是不可变的.
-
简单理解:列表与元组的区别
-
列表 = 同时存储多个元素+元素内容 可变.
-
元组 = 同时存储多个元素+元素内容不可变.
-
-
格式:
tuple1 = (值1, 值2, 值3...)
tuple2 = tuple()
tuple3 = ()
tuple4 = (10,)
tuple5 = (10)
-
下标和切片:
-
下标:就是索引,元组和列表,字符串一样,每个元素都有下标,且默认从零开始.
-
切片: 元组支持切片,写法和列表,字符串一致.
-
-
常用函数: index(), count(), len()
-
注意:
-
1.如果元组只有1个元素,该元素后必须加逗号.
-
2.如果元组只有且后边没有加逗号,就说明它是一个该类型的变量.
-
# 需求1: 演示如何定义元组.
# 1. 演示如何定义元组.
tuple1 = (10, 20, 30, 40, 50)
tuple2 = tuple()
tuple3 = ()
tuple4 = (10,)
tuple5 = (10)
tuple6 = ('aa')
# 2. 打印上述的变量.
print(tuple1) # (10, 20, 30, 40, 50)
print(tuple2) # ()
print(tuple3) # ()
print(tuple4) # (10,)
print(tuple5) # 10
print(tuple6) # aa
# 3. 打印上述的变量的 数据类型.
print(type(tuple1)) # <class 'tuple'>
print(type(tuple2)) # <class 'tuple'>
print(type(tuple3)) # <class 'tuple'>
print(type(tuple4)) # <class 'tuple'>
print(type(tuple5)) # <class 'int'>
print(type(tuple6)) # <class 'str'>
print('-' * 30)
# 需求2: 演示元组的 索引 和 切片操作.
tuple7 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
# 根据索引, 获取 元组的元素值.
print(tuple7[3]) # 4
# 尝试修改元组的元素值.
# tuple7[3] = 200 # 报错, 因为元组内容是 不可变 的.
# 元组切片.
print(tuple7[2:6]) # [3, 4, 5, 6]
# 打印元组的内容.
print(f'tuple7: {tuple7}')
print("-" * 30)
# 需求3: 元组的常用函数.
tuple8 = (1, 2, 3, 4, 5, 3, 5)
print(tuple8.index(3)) # 2, 第一次出现的位置.
# print(tuple8.index(30)) # 找不到就报错.
print(tuple8.count(3)) # 2次
print(f'元组的长度为: {len(tuple8)}') # 7
print("-" * 30)
# 4. 元组的细节问题, 即: 元组嵌套列表.
# 前提: 元组是属于容器类型的一种, 它属于 不可变类型, 但是当: 元组嵌套列表的时候, 其内部列表的值是可以修改的, 但是改 列表的地址值是不变的.
t1 = (1, 2, 3, ['a', 'b', 'c'])
print(f'修改前: {t1}')
# 需求, 把 'b' => 'AI30期'
# print(t1[3])
t1[3][1] = 'z'
print(f'修改后: {t1}')
字典
-
概述: 字典属于容器类型一种,用于存储多个元素,存储的是 键值对 数据.
-
格式:
-
dict1 ={键:值,键:值,…}
-
dict2 = dict()
-
dict3 = {}
-
-
特点:
- 键具有唯一性,而值可以重复.
演示定义字典
# 1. 演示如何定义字典.
# 键 值 键 值 键值对数据
dict1 = {'name': '张三', 'age': 23, 'gender': 'male'}
dict2 = dict()
dict3 = {}
dict4 = {10, 20, 30, 40, 50} # 这个可不是字典, 而是1个集合(set)
# 2. 打印字典.
print(dict1)
print(dict2)
print(dict3)
print(dict4)
# 3. 打印字典的类型.
print(type(dict1)) # <class 'dict'>
print(type(dict2)) # <class 'dict'>
print(type(dict3)) # <class 'dict'>
print(type(dict4)) # <class 'set'>
字典详解:常见操作
- 增/改:字典名[键] = 值 键存在就修改,不存在就新增.
# 1. 定义字典, 添加元素.
dict1 = {'杨过': '大雕', '郭靖': '杨康', '阿东': '王二麻子'}
# 2. 演示上述的函数.
# 增
dict1['乔峰'] = '阿朱' # 键不存在就添加
dict1['阿紫'] = '阿朱' # 键不存在就添加
- 查
- get(键名,默认值)
dict1 = ['杨过': '大雕', '郭靖': '杨康', '阿东': '王二麻子']
# 查
# get(键名,默认值)根据键获取对应的值,如果不存在就返回默认值,默认值不写为:None
print(dict1.get('杨过')) # 结果为 大雕
print(dict1.get('阿朱')) #不存在该键 结果为None
- keys() 查询所有键
print(dict1.keys()) # dict_keys(['杨过', '阿东', '乔峰', '阿紫'])
- values() 获取所有值
print(dict1.values()) # dict_values(['大雕', '王二麻子', '阿朱', '阿朱'])
- items() 获取所有键值对数据,并封装成:列表嵌套元组的形式.
print(dict1.items())
#结果为 dict_items([('杨过', '大雕'), ('阿东', '王二麻子'), ('乔峰', '阿朱'), ('阿紫', '阿朱')])
- 改
dict1['郭靖'] = '黄蓉' # 键存在, 就覆盖(用新值 覆盖 旧值)
字典的遍历
演示如何遍历字典 即:逐个获取字典中键值对的过程.
# 1. 定义字典, 记录元素.
dict1 = {'name': '乔峰', 'age': 41, 'gender': '男', 'kongfu': '降龙十八掌'}
# 思路1: 根据 键 获取其对应的 值. 理解为: 根据丈夫 找 妻子.
# step1: 获取所有的键.
keys = dict1.keys()
# step2: 遍历, 获取到 每个键.
for key in keys:
# key 就是字典的中的每个键, 根据键 获取值.
value = dict1.get(key)
# step3: 打印结果.
print(key, value)
print('-' * 30)
# 上述格式简化版
for key in dict1.keys():
print(key, dict1.get(key))
print('-' * 30)
# 思路2: 根据 键值对 找键和值. 理解为: 根据 结婚证 找丈夫和妻子.
# step1: 获取所有的键值对.
items = dict1.items()
# step2: 遍历, 获取到每一组 键值对.
for item in items:
# item就是每组键值对的 元组形式, 即: (键, 值)
# step3: 从item中获取到 键 和 值.
key = item[0]
value = item[1]
# step4: 打印结果
print(key, value)
print('-' * 30)
# 合并版.
for item in dict1.items():
print(item[0], item[1])
print('-' * 30)
集合
-
概述:属于容器类型一种,属于可变类型.
-
格式:
-
set1 ={值1,值2,值3…}
-
set2 = set{}
-
set3= {} # 单纯这种属于在定义字典不是集合.
-
-
特点: 无序(元素的存和取的顺序不一致),唯一
-
应用场景:自动去重重复的元素.
# # 1. 演示: 集合的定义格式.
# set1 = {10, 20, 'aa', 50, 'cc', 'bb', 20, 'cc'}
# set2 = set()
# set3 = {} # 这个不是在定义集合, 而是在定义字典.
#
# # 2. 打印上述变量的 数据类型.
# print(type(set1)) # <class 'set'>
# print(type(set2)) # <class 'set'>
# print(type(set3)) # <class 'dict'>
#
# # 3. 打印上述变量的值.
# print(set1) # {50, 10, 20, 'bb', 'cc', 'aa'}, 元素存取顺序不同 = 无序.
# print(set2) # set()
# print(set3) # {}
# print("-" * 30)
# 4. 需求: 列表元素去重(保留1个)
# 思路1: 列表 => 集合, 自动去重 => 列表
list1 = ['aa', 'bb', 'cc', 'cc', 'cc', 'dd', 'bb', 'cc']
list2 = []
# step1: 把 列表 => 集合, 会自动去重.
# set1 = set(list1)
# # step2: 把去重后的 集合 => 列表.
# list2 = list(set1)
# step3: 打印结果.
# print(f'去重后, 结果为: {list2}')
容器类型公共运算符
-
概述:这些运算符可作用到容器类型中
-
常用如下:
+ 合并(拼接), 适用于: 字符串, 列表, 元组.
* 复制, 适用于: 字符串, 列表, 元组.
in 是否包含, 适用于: 字符串, 列表, 元组, 字典.
not in 是否不包含, 适用于: 字符串, 列表, 元组, 字典.
-
注意:
- in, not in 针对于字典的时候只作用于键.
需求: 演示上述的 公共的运算符.
# + 合并(拼接), 适用于: 字符串, 列表, 元组.
print('abc' + 'xyz')
print([1, 2, 3] + ['a', 'b', 'c'])
print((1, 2, 3) + ('a', 'b', 'c'))
print('-' * 30)
# * 复制, 适用于: 字符串, 列表, 元组.
print('abc' * 2)
print([1, 2, 3] * 2)
print((1, 2, 3) * 2)
print('-' * 30)
# in 是否包含, 适用于: 字符串, 列表, 元组, 字典.
print('a' in 'abc') # True
print(10 in [1, 2, 3]) # False
print(10 in (10, 2, 3)) # True
print(10 in {10, 2, 3}) # True
print(10 in {1:2, 2:3, 10:5}) # True, 如果判断字典, 则判断的是: 键(key)
print(10 in {1:2, 2:3, 5:10}) # False, 如果判断字典, 则判断的是: 键(key)
print('-' * 30)
# not in 是否不包含, 适用于: 字符串, 列表, 元组, 字典.
print('a' not in 'abc')
print(10 not in [1, 2, 3])
print(10 not in (10, 2, 3))
print(10 not in {10, 2, 3})
print(10 not in {1:2, 2:3, 10:5})
print(10 not in {1:2, 2:3, 5:10})
-
容器的公共方法
- 常用如下:
len() 获取长度的
del 删除的
max() 最大值
min() 最小值
range(start, end, step) 生成指定区间范围的值. 包左不包右.
enumerate() 生成列表元素的: 索引 和 值, 封装成 元组形式, 即: (索引, 值)
# 演示 len() 获取长度的
# 1. 字符串
s1 = 'abc'
print(len(s1))
# 2. 列表
print(len([1, 2, 3, 4, 5]))
# 3. 字典
print(len({'a': 1, 'b': 2, 'c': 3})) # 3
print("-" * 30)
# 演示 del 删除的
# 1. 字符串.
s1 = 'abc'
del s1
# print(s1)
# 2. 列表
list1 = [1, 2, 3, 4, 5]
del list1[0]
del (list1[2])
print(list1)
# 3. 字典
dict1 = {'a': 1, 'b': 2, 'c': 3}
del dict1['a']
del (dict1['c'])
print(dict1)
print("-" * 30)
# 演示 max() 最大值
print(max('abcdefg'))
print(max([1, 2, 3, 4, 5]))
print(max((1, 2, 3, 4, 5)))
print(max({1, 2, 3, 4, 5}))
print(max({'a': 1, 'b': 2, 'c': 1})) # 只针对于 键.
print("-" * 30)
# 演示 min() 最小值
# 同上, 自测.
# 演示 range(start, end, step) 生成指定区间范围的值. 包左不包右.
print(range(1, 10, 2)) # 生成 1 到 10 的 奇数, 获取: range()对象.
for i in range(1, 10, 2):
print(i)
print(list(range(1, 10, 2))) # 把 range() => 列表.
print("-" * 30)
# 演示 enumerate() 生成列表元素的: 索引 和 值.
list1 = ['a', 'b', 'c', 'd', 'e']
for i in list1:
print(i) # 'a', 'b', 'c', 'd', 'e', 它们的索引分别是: 0, 1, 2, 3, 4
# for i in enumerate(list1): # 默认: 索引是从 0 开始的.
for i in enumerate(list1, 5): # 指定 索引从 5 开始.
print(i) # 把列表元素和其索引封装成元组, 即: (索引, 值)
print('-' * 30)
# 扩展, 看看就行了, 把 列表 => 字典. 下午我们会详细讲解 推导式.
dict1 = {item[0]:item[1] for item in enumerate(list1)}
print(dict1)推导式
推导式
-
概述:推倒式也叫解析式,即:根据特定的规则生成1个数据序列的操作.
-
可分为:
-
列表推导式
-
格式: 列表 = [变量名 for i in … if 条件…]
# 需求1: 创建0 ~ 9的列表.
# 思路1: 自定义 while 或者 for循环搞定.
list1 = []
for i in range(10):
list1.append(i)
print(list1)
# 思路2: 列表推导式写法.
list2 = [i for i in range(10)] # 效果同上.
print(list2)
print('-' * 30)
# 需求2: 创建1个0 ~ 9的 偶数列表.
# 方式1: 自定义 while 或者 for循环搞定.
list3 = []
for i in range(0, 10, 2):
list3.append(i)
print(list3)
# 方式2: 列表推导式写法, 结合 步长.
list4 = [i for i in range(0, 10, 2)]
print(list4)
# 方式3: 列表推导式写法, 结合 if判断.
list5 = [i for i in range(10) if i % 2 == 0]
print(list5)
print('-' * 30)
# 需求3: 创建列表 => [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
# 方式1: 分解版, 自定义for 或者 while循环搞定.
list6 = []
for i in range(1, 3): # i的值: 1, 2
for j in range(3): # j的值: 0, 1, 2
# 把元素添加到列表中.
# my_tuple = (i, j)
# list6.append(my_tuple)
list6.append((i, j))
print(list6)
# 方式2: 列表推导式写法.
# 外循环 内循环 = 外循环执行一次, 内循环指定一圈(一轮)
list7 = [(i, j) for i in range(1, 3) for j in range(3)] # 效果同上.
print(list7)
-
字典推导式
- :推导式也叫解析式,即根据特定规则生成1个数据列表的操作.
演示
# 案例1: 创建1个字典, key是1~5, 值是这个数字的平方.
# 方式1: for, while 手动实现.
dict1 = {}
for i in range(1, 6):
dict1[i] = i ** 2
print(dict1)
# 方式2: 字典推导式.
# 键值对
dict2 = {i : i ** 2 for i in range(1, 6)}
print(dict2)
print("-" * 30)
# 案例2: 将两个列表合并为1个字典.
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
# 方式1: for, while手动实现.
dict3 = {}
for i in range(len(list1)): # i的值: 0, 1, 2
# i 就是 列表中的每个元素的 索引, 把索引对应的值 添加到 字典中即可.
dict3[list1[i]] = list2[i]
print(dict3)
# 方式2: 字典推导式.
dict4 = {list1[i] : list2[i] for i in range(len(list1))} # i的值:0, 1, 2
print(dict4)
print("-" * 30)
# 案例3 演示: 集合推导式 => 默认具有 元素去重的功能.
# 1. 定义1个列表, 记录一些元素.
list1 = [1, 1, 2]
# 2. 集合推导式实现, 获取的元素值为 上述元素的平方结果.
set2 = {i ** 2 for i in list1} # i的值: 1, 1, 2
print(set2) # {1, 4} 因为集合默认会: 去重.
-
集合推导式
-
注:具有元素去重的功能
# 1. 定义1个列表, 记录一些元素.
list1 = [1, 1, 2]
# 2. 集合推导式实现, 获取的元素值为 上述元素的平方结果.
set2 = {i ** 2 for i in list1} # i的值: 1, 1, 2
print(set2) # {1, 4} 因为集合默认会: 去重.
总结
持续个更新中~~~