Python学习（四）列表、元组、字典、集合
1.列表的应用场景
一个变量一次性可以存储一个数据，多个数据要一次性存储则使用列表。
列表可以一次性存储多个数据，且可以为不同的数据类型。但一般存储相同类型（为了后期好控制）
2.列表的格式
[数据1，数据2，数据3....]
3.列表的常用操作
3.1查找
3.1.1下标
a=['tom','cat','pig','dog']
print(a[2])
#结果
pig3.1.2函数
语法：列表序列.index(数据，开始位置下标，结束位置下标）
index()：返回指定数据所在位置的下标
count()：统计指定数据在当前列表中出现的次数
len()：访问列表长度，即列表中数据的个数
a=['tom','cat','pig','dog','sheep','house','ox','tiger']
print(a.index('ox'))
print(a.count('ox'))
print(len(a))
#结果
6#ox的下标位置时6
1#ox出现的次数是1次
8#列表中总共有8个数据3.1.3判断是否存在
in/not in 返回都是bool型，True或False
a=['tom','cat','pig','dog','sheep','house','ox','tiger']
print('tom'in a)
print('a'in a)
print('a'not in a)
#结果
True
False
True案例：查找用户输入的名字是否存在
a=['lily','rose','Julia','jack','kangkang','Maria']
name=input('请输入您的名字')
if name in a:
print(f'您输入的名字是{name},名字已存在')
else:
print(f'您输入的名字是{name},请继续下一步')3.2增加
作用：增加指定数据到列表中
语法：列表序列.append(数据) ，列表序列.extend(数据)，列表序列.insert(位置下标，数据)
append()： 如果追加的是一个序列，则将整个序列增加在序列中
a=['lily','rose','Julia','jack','kangkang','Maria']
a.append('jesse')
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'jesse']
#追加一个序列[1,2]
a=['lily','rose','Julia','jack','kangkang','Maria']
name=[1,2]
a.append(name)
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', [1, 2]]a=['lily','rose','Julia','jack','kangkang','Maria']
name=input('请输入您的账号名')
if name not in a:
a.append(name)
print(f'您输入的账号{name}不存在，已将您账号进行保存如下：',a)
else:
print(f'您输入的账号已存在，具体情况如下：',a)
#结果
请输入您的账号名jesse
您输入的账号jesse不存在，已将您账号进行保存如下： ['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'jesse']extend()：如果追加的数据是一个序列，则会将这个序列的数据拆开，逐一添加到列表。
a=['lily','rose','Julia','jack','kangkang','Maria']
a.extend('name')
a.extend(['name','haha'])
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'n', 'a', 'm', 'e', 'name', 'haha']
#['name','haha']被拆开,name被拆开insert(位置下标，数据)
a=['lily','rose','Julia','jack','kangkang','Maria']
a.insert(1,'jesse')
print(a)
#结果
['lily', 'jesse', 'rose', 'Julia', 'jack', 'kangkang', 'Maria']3.3删除
del(): del目标，可以直接删除列表（del 列表；或者del (列表)），也可以删除指定下标的数据：del[下标位置]
a=['lily','rose','Julia','jack','kangkang','Maria']
del a[1]#删除指定位置的数据，用下标来实现
print(a)
#结果
['lily', 'Julia', 'jack', 'kangkang', 'Maria']pop() 删除指定下标的数据，如果不加下标，则是删除最后一个
a=['lily','rose','Julia','jack','kangkang','Maria']
a1=a.pop()
print(a1)
#结果a.pop()没有指定位置，则删除的是最后一个数据；会返回这个被删除的数据
Maria#指定下标删
a=['lily','rose','Julia','jack','kangkang','Maria']
a1=a.pop(1)
print(a1)
print(a)
#结果
rose
['lily', 'Julia', 'jack', 'kangkang', 'Maria']
remove() 移除列表中某个数据的第一个匹配项
a=['lily','rose','lily','jack','kangkang','Maria']
a.remove('lily')
print(a)
#结果
['rose', 'lily', 'jack', 'kangkang', 'Maria']clear() 清空列表
a=['lily','rose','lily','jack','kangkang','Maria']
a.clear(a)
print(a)3.4修改
（1）逆置：reverse()
a=['lily','rose','lily','jack','kangkang','Maria']
a.reverse()
print(a)
#结果：
['Maria', 'kangkang', 'jack', 'lily', 'rose', 'lily']（2）排序：sort(key=None，reverse=False)；False表示非逆序，即升序排序；True表示逆序，即降序排序
a=['12','7','3','23','77','33']
a.sort(reverse=True)
print(a)
#结果
['77', '7', '33', '3', '23', '12']3.5复制
函数：copy()
a=['12','7','3','23','77','33']
b=a.copy()
print(b)
#结果
['12', '7', '3', '23', '77', '33']4.列表的循环遍历
需求：依次打印列表中的各个数据
4.1while
a=['tom','maria','rose','jack']
i=0
while i4.2 for
a=['tom','maria','rose','jack']
for i in a:
print(i)
#结果
tom
maria
rose
jack5.列表的嵌套使用
就是一个列表里面包含了其他的子列表
应用场景：要存储一、二、三，三个班级学生姓名，且每个班级的学生姓名在一个列表，查找某一个学生姓名
a=[['tom','maria'],['yes','no'],['jack','rose']]
print(a[1][0])
#结果
yes案例：随机分配办公室——有三个办公室，将8位老师随机分配到这个三个办公室
#有三个办公室，有8位老师，将这8位老师随机分配到办公室里去
import random
teachers=['a','b','c','d','e','f','g','h']
offices=[[],[],[]]
for name in teachers:
num=random.randint(0,2) #三个列表，所以0-2
offices[num].append(name) #将随机在0，1，2的列表中添加name
#办公室i的人数
i=1
for office in offices: #如果子列表office在offices中，进入循环
print(f'办公室{i}的老师是：') #输出办公室的编号i
for name in office: #如果人在子列表office中
print(name) #输出具体的人名
i += 1 #办公室编号加1，继续输出人名
#结果
办公室1的老师是：
d
办公室2的老师是：
c
e
f
g
办公室3的老师是：
a
b
h
6.元组
元组的应用场景：存储多个数据，但是这些数据是不能修改的数据
a=('a','c','b') #多个数据的元组
b=('a')
c=('a',) #单个数据的元组
print(a,type(a))
print((b,type(b)))
print(c,type(c))
#结果
('a', 'c', 'b')
('a', ) #说明单个数据的元组也要加“，”，不然会变成是这个数据的类型str
('a',) 7.元组的常见操作
元组只支持查找操作，统计操作（统计出现次数，统计长度）
a=('a','c','b')
print(a.index('c'))
print(len(a))
print(a.count('b'))
#结果
1 #c在下标为1的位置
3 #a元组总共3个
1 #b出现的次数是1元组的数据直接修改是会报错的；但是可以修改元组内列表的数据，但尽量避免修改
a=('a','c','b',['d','e'])
a[3][1]='f' #修改元组里面列表的数据，将e改为f
print(a)
#结果
('a', 'c', 'b', ['d', 'f'])8.字典
8.1.字典的应用场景：有多个数据，存储的位置变换了，不改查找代码也能查到这个数据
字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。
8.2.创建字段的语法
符号为大括号{}，数据为键值对形式出现，各个键值对之间用逗号隔开
有数据字典：a={'a','b','c'}；空字典：a={}
i={'a':'tom','b':'jack','c':'rose'}
w={}
q=dict()
print(i,type(i))
print(w,type(w))
print(q,type(q))
#结果：
{'a': 'tom', 'b': 'jack', 'c': 'rose'}
{}
{} 8.3.字典的常见操作
8.3.1增加
字典序列[key]=值；如果key存在则修改这个key对应的值，如果key不存在则新增此键值对
i={'a':'tom','b':'jack','c':'rose'}
i['hah']='yes' #不存在，则直接新增
print(i)
i['a']='cat' #存在，则在之前的基础上修改
print(i)
#结果：
{'a': 'tom', 'b': 'jack', 'c': 'rose', 'hah': 'yes'}#没有hah，直接新增
{'a': 'cat', 'b': 'jack', 'c': 'rose', 'hah': 'yes'}#将a的值tom改为了cat8.3.2删除
del/del()；clear()
i={'a':'tom','b':'jack','c':'rose'}
del i['b']# 或者del(i['a'])
print(i)
i.clear()
print(i)
#结果
{'a': 'tom', 'c': 'rose'} #删除b的键值对
{} #清空字典8.3.3修改
字典序列[key]=值
新增和修改的用法是一样的，存在则修改，不存在则新增
i={'a':'tom','b':'jack','c':'rose'}
i['a']='cat'
print(i)
#修改值结果
{'a': 'cat', 'b': 'jack', 'c': 'rose'}8.3.4查找
8.3.4.1 key值查找：当前查找的key存在，则返回对应的值，否则报错
i={'a':'tom','b':'jack','c':'rose'}
print(i['a'])
print(i['d'])
#结果
tom
Traceback (most recent call last): #没有就直接报错
File "D:\工作\python script\字典.py", line 3, in
print(i['d'])
KeyError: 'd' 8.3.4.2 get()函数查找：如果当前查找的key不存在，则返回第二个参数（默认值），如果省略第二个参数，则返回None
i={'a':'tom','b':'jack','c':'rose'}
print(i.get('a'))
print(i.get('jac'))
print(i.get('jac','找不到'))
#结果
tom
None #找不到就返回None
找不到 #找不到就返回第二个参数（默认值）：找不到8.3.4.3 keys() ：查找字典中所有的key，返回可迭代对象
i={'a':'tom','b':'jack','c':'rose'}
print(i.keys()) #查找字典中所有的key，返回可迭代对象
#结果
dict_keys(['a', 'b', 'c'])8.3.4.4 values() :查找字典中所有的值，返回可迭代对象
i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
print(i.values()) #查找字典中所有的value，返回可迭代对象
#结果
dict_keys(['a', 'b', 'c'])
dict_values(['tom', 'jack', 'rose'])8.3.4.5items()：查找字典中所有的键值对，返回可迭代对象
里面的数据是元组，元组数据1是字典的key，元组数据2是字典的value
i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
print(i.values())
print(i.items()) #查找字典中所有的键值对，返回可迭代对象，里面的数据是元组
#结果
dict_keys(['a', 'b', 'c'])
dict_values(['tom', 'jack', 'rose'])
dict_items([('a', 'tom'), ('b', 'jack'), ('c', 'rose')])#元组数据1是字典的key，元组数据2是字典的value8.4.字典的循环遍历
8.4.1遍历字典的key
i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
for key in i.keys():
print(key)
#结果
dict_keys(['a', 'b', 'c'])
a
b
c8.4.2遍历字典的value
i={'a':'tom','b':'jack','c':'rose'}
print(i.values())
for values in i.values():
print(values)
#结果
dict_values(['tom', 'jack', 'rose'])
tom
jack
rose8.4.3遍历字典的键值对
i={'a':'tom','b':'jack','c':'rose'}
for a in i.items():
print(a)
#结果
('a', 'tom')
('b', 'jack')
('c', 'rose')8.4.4遍历字典的键值对（拆包）
i={'a':'tom','b':'jack','c':'rose'}
for key,value in i.items():
print(f'{key}={value}')
#结果
a=tom
b=jack
c=rose9.集合
创建集合使用{}或set()；但如果要创建空集合，只能用set()，因为{}是用来创建空字典的
集合里面有重复的会去重
i={1,2,3,4,1,2} #集合里面有重复的数据
print(i,type(i))
#结果
{1, 2, 3, 4} #会去重 集合里面是没有顺序的
i={1,2,3,4,6,5}
q={10,34,20,45,50,43}
p={1,2,3,4,5}
w=set('abcdefg')
print(i,type(i))
print(q)
print(p)
print(w)
#结果
{1, 2, 3, 4, 5, 6}
{34, 50, 20, 10, 43, 45}
{1, 2, 3, 4, 5}
{'d', 'g', 'f', 'c', 'e', 'a', 'b'} 10.集合的常见操作方法
10.1增加
1、add()，增加的只能是单一数据，不能是数组，会报错；且增加相同的数据，会去重。
2、update()，增加的数据是序列，如果写单一数据的话，会报错
i={1,2,3,4,6,5}
q=i.add('hah')
w=i.update([100,'hahaha'])
print(i)
#结果
{1, 2, 3, 4, 5, 6, 'hahaha', 'hah', 100}10.2删除数据
1、pop()，随机删除某个数，如果pop是删除不存在的数据，则会报错
i={10,20,13,14,16,15}
q=i.pop()
print(i)
#结果
{20, 10, 13, 14, 15}2、remove()，指定数删除，如果remove是删除不存在的数据，则会报错
i={1,2,3,4,6,5}
q=i.remove(2)
print(i)
#结果
{1, 3, 4, 5, 6}3、discard()，指定数删除，即是删除的数据不存在，也不会报错
i={10,2,3,4,6,5}
q=i.discard(100) #删除的数据不存在，也不会报错
print(i)
#结果
{2, 3, 4, 5, 6, 10}10.3查找
in：在集合里；not in ：不在集合里；返回的是bool值
i={10,20,13,14,16,15}
print(1 in i)
print(10 in i)
print(10 not in i)
#结果
False
True
False