元组
如果想要存储多个数据，但是这些数据是不能修改的数据，怎么办？
答：列表可以一次性存储多个数据，但是列表中的数据允许修改
一个元组可以存储多个数据，元组内的数据是不能修改的。
一、定义元组
元组的特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型
t = (1)
print(t) # 1
print(type(t)) # <class 'int'>
t = (1,)
print(t) #(1,)
print(type(t)) # <class 'tuple'>
二、元组的常见操作
元组数据不支持修改，只支持查找，具体如下：
1、按下标查找数据：
2、index():查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index()方法相同。
3、count():统计某个数据在当前元组出现的次数。
三、元组数据的修改操作
注意：元组内的直接数据如果修改则立即报错
但是如果元组里面有列表，修改列表里面的数据则是支持的
t2 = ('aa', 'bb', ['cc', 'dd'])
print(t2[2]) # ['cc', 'dd']
print(t2[2][0]) # cc
t2[2][0] = 'TOM'
print(t2[2]) # ['TOM', 'dd']
字典
思考1：如果有多个数据，例如：’Tom’, ‘男’, ‘20’，如何快速储存？
答：列表 list1 = [‘Tom’, ‘男’, 20]
思考2：如何查找到数据’Tom’
答：查找到下标为0的数据即可。list1[0]
思考3：如果将来数据顺序发生改变，如下所示，还能用list[0]访问到数据’Tom’吗？
list1 = [‘男’, 20, ‘Tom’]
答：不能，数据’Tom’此时下标为2.
思考4：数据顺序发生改变，每个数据的下标也会随之改变，如何保证数据顺序变化前后能使用同一的标准查找数据呢？
答：字典，字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。
创建字典的语法
注意：一般冒号前面的为键(key) 简称k；冒号后面的为值(value)，简称v。
字典的常见操作
1.增
写法：字典序列[key] = 值
注意，如果key存在则修改这个key 对应的值；如果key不存在则新增此键值对。
注意：字典为可变类型。
2.删
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# del 删除字典或指定的键值对
del(dict1)
print(dict1)
字典dict1已经被删除了
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['name']
print(dict1) # {'age': 20, 'gender': '男'}
# 删除了键值对'name': 'Tom'以及中间的连接字符 ，
del dict1['names']
print(dict1)
# 如果k不存在，便报错
dict1.clear() # clear():清空字典
print(dict1) #{}
3.改
写法：字典序列[key] = 值
注意： 如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'lily'
print(dict1) # {'name': 'lily', 'age': 20, 'gender': '男'}
4. 查
key值查找
如果当前查找的key存在，则返回对应的值；否则则报错。
get()
语法:
字典序列.get(key, 默认值)
注意：如果当前查找的key不存在则返回第二个参数(默认值),如果省略第二个参数，则返回
None。
# 2.2 keys() # 查找字典中所有的key，返回可迭代带向
print(dict1.keys())
# 2.3 values() 查找字典中的所有的value，返回课迭代对象
print(dict1.values())
# 2.4 items()
# 查找字典中所有的键值对，返回可迭代对象，里面的数据是元组，元组数据1是字典的key，元组数据2是字典的值
print(dict1.items())
字典的循环遍历
遍历字典的key(利用for)
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
# name age gender
遍历字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
# Tom 20 男
遍历字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
遍历字典的键值对
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value, key in dict1.items():
print(f'{value} = {key}')
集合
一、创建集合
集合是可变类型
创建集合使用{} 或set(),但是如果要创造空集合之鞥你使用set()，因为{}用来创造空字典。
s1 = {10, 20, 30, 40, 50}
print(s1)
# {40, 10, 50, 20, 30}
# 集合没有顺序，所以没有下标操作
# 重复数据
s2 = {10, 10, 20, 30, 40}
print(s2)
# {40, 10, 20, 30}
# 自动去除重复数据
s3 = set('abcdefg')
print(s3) # {'g', 'e', 'd', 'a', 'b', 'f', 'c'}
s4 = set('123456')
print(s4) # {'2', '5', '1', '3', '4', '6'}
# 使用set（）创建集合，会使（）中的字符串自动分开。
# 123456必须要带上‘ ’，否则会报错，说明了set（）函数内部只允许输入字符串
# 创造空集合只能使用set函数：
s6 = set()
s7 = {}
print(type(s6)) # <class 'set'>
print(type(s7)) # <class 'dict'>
集合没有顺序，所以没有下标操作
二、 集合常见操作方法
增加数据：add()
s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)
# {100， 10， 20}
# 集合有去重功能，所以）并不会执行 s1.add（10） 此操作
# 此外，add函数不能增加序列否则会报错。
增加序列 update():追加的数据是序列。
s1.update([10, 20, 30, 40])
print(s1)
#{40， 10， 20， 30}
错误注意！
s1.update(100)
print(s1)
update(中只能存储序列)
a = [11]
s1.update(a)
print(s1)
# 如果是以字母进行输入会自动辨识为变量名，要求你提前定义，如上图a = [11]
remove():删除集合中的指定数据，如果数据不存在则报错。
ss = {10, 20, 30, 40, 50}
# remove(): 删除指定数据，如果数据不存在报错
ss.remove(10)
print(ss)
ss.remove(10) # error
print(ss)
第一次print正常输出，第二次由于集合当中再也没有10这个元素了所以报错。
discard():删除集合中的指定数据，如果数据不存在也不会报错。
# discard(): 删除指定数据，如果数据不存在不报错
ss.discard(10)
print(ss) # {40, 50, 20, 30}
ss.discard(10)
print(ss) # {40, 50, 20, 30}
pop():随机删除集合中的某个数据，并返回这个数据。
（可以设立一个新的变量接受被删除的值）
del_num = ss.pop()
print(del_num) # 40
print(ss) # {10, 50, 20, 30}
查找数据
in :判断数据在集合序列
not in:判断数据不在集合序列
sz = {10, 20, 30, 40, 50}
print(10 in sz) #Ture
print(10 not in sz) #False
公共操作
一、运算符
str1 = 'aa'
str2 = 'bb'
list1 = [1,2]
list2 = [3,4]
s1 = (1,2)
s2 = (3,4)
dict1 = {'name':'Tom'}
dict2 = {'age': 18}
# +:合并
print(str1+str2)
print(list1 + list2)
print(s1 + s2)
print(dict1 + dict2)
字典不支持 + 运算符 所以报错
print(str1 * 5)
print('-' * 10)
print(list1 * 5)
print(s1 * 5)
类似的，字典也不支持*运算符
in:
not in:
print('a' in str1) # True
print('a' not in str1) # False
print(1 in list1) # True
print(1 not in list1) # False
print(dict1.keys()) # dict_keys(['name'])
print('name' in dict1.keys()) # True
print('name' in dict1.values()) # False
二、公共方法
len(), del
str1 = 'abcdefg'
lsst = [10, 20, 30, 40, 50]
t1 = (10, 20, 30, 40, 50)
s1 = {10, 20, 30, 40, 50}
dict1 = {'name': 'tom', 'age': 18}
# len()的使用
print(len(str1)) # 7
print(len(lsst)) # 5
del lsst[0]
print(lsst)
del lsst
print(lsst)
报错原因：del函数删除lsst之后，lsst列表消失了，print无法找到lsst列表，print要求重新定义一个lsst列表
min() 和 max()
str1 = 'abcdefg'
list1 = [10, 20, 30, 40, 50]
# max()
print(f'{max(str1)}') # g
print(max(list1)) # 50
# min()
print(min(str1)) # a
print(min(list1)) # 10
range()
range(start,end,step)的使用:生成从start到end的数字，步长为step，供for循环使用
注意：range的使用方法和切片一样，左闭右开，即取得到start的数字取不到end的数字
默认步长为1，默认start为0；
for i in range(1, 10, 1):
print(i, end=' ') # 1 2 3 4 5 6 7 8 9
print()
for i in range(1, 10, 2):
print(i, end=' ') # 1 3 5 7 9
print()
for i in range(10):
print(i, end=' ') # 0 1 2 3 4 5 6 7 8 9
print()
enumerate()
语法
enumerate(可遍历对象, start = 0)
注意： start参数用来设置遍历数据的下标的起始值，默认为0。
list1 = ['a', 'b', 'c', 'd', 'e']
# enumerate 返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
for i in enumerate(list1):
print(i)
for i in enumerate(list1, start=1):
print(i)
for index,char in enumerate(list1):
print(f'下标为{index}，对应的字符为{char}')
三、 容器类型转换
# tuple():将某个序列转换成元组
# list():将某个序列转换成列表
# set():将某个序列转换成集合
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
t1 =('a', 'b', 'c', 'd', 'e')
print(tuple(list1))
print(tuple(s1))
print(list(s1))
print(list(t1))
print(set(list1))
print(set(t1))
注意：1.集合可以快速完成列表去重
2.集合不支持下标
推导式
一、列表推导式
作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。
列表推导式又叫列表生成式。
需求： 创建一个0-10的列表。
# While循环实现：
# 需求：0， 1， 2， 3, 4 ...
# 1.循环实现； 2.列表推导式（化简代码：创建或控制有规律的列表）
"""
1. 创建空列表
2. 循环将有规律的数据写入到列表
"""
list1 = []
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# for 循环实现-----
list1 = []
for i in range(10):
list1.append(i)
print(list1) #同样的结果
# 列表推导式实现 放在中括号里表示的是列表推导式 在列表推导式里面读与写都从for循环开始
# 第一个i：i是整个列表推导式 列表里面要返回的数据 第二个i：是range10里面从0开始的到9为止的数
list1 = [i for i in range(10)]
print(list1) #同样的结果
带if的列表推导式
需求：创建0-10的偶数列表
# 方法1：range()步长实现
list1 = [i for i in range(0, 10, 2)]
print(list1)
# [0, 2, 4, 6, 8]
# 方法2：if实现
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
# [0, 2, 4, 6, 8]
多个 for循环实现列表推导式
需求：创建列表如下：
[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]
listt = []
for i in range(1, 3):
for j in range(3):
# 列表里面追加元组： 循环前准备一个空列表，然后这里追加元组数据到列表
listt.append((i,j))
print(listt)
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
# 多for 的列表推导式等同于for循环嵌套
二、字典推导式
思考：如果有如下两个列表：
list1 = [‘name’, ‘age’, ‘gender’]
list2 = [‘Tom’, 20, ‘man’]
如何快速合并为一个字典？
字典推导式作用： 快速合并列表为字典或提取字典中目标数据。
# 1. 创建一个字典：字典key是1-5数字，value是这个数字的2次方。
dict1 = {i: i**2 for i in range(1, 5) }
print(dict1) #{1: 1, 2: 4, 3: 9, 4: 16}
# 2. 将两个列表 合并成为一个字典
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1) #{'name': 'Tom', 'age': 20, 'gender': 'man'}
# 3. 提取字典中目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
count1 = {key: value for key, value in counts.items() if value >= 200}
print(counts.items())
print(count1)
# dict_items([('MBP', 268), ('HP', 125), ('DELL', 201), ('Lenovo', 199), ('acer', 99)])
# {'MBP': 268, 'DELL': 201}
总结：
- 如果两个列表数据个数相同，len统计任何一个列表的长度都可以
- 如果两个列表数据个数不同，len统计数居多的列表数据个数会报错；len统计数据少的列表数据个数不会报错
三、集合推导式
需求：创建一个集合，数据为下方列表的2次方。
list = {1, 1, 2}
list1 = {1, 1, 2}
set1 = {i ** 2 for i in list1}
print(set1) #{1, 4}
注意：集合有数据去重功能。
428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
