元组、字典、集合及内置方法

1.列表常用方法

sort()
l = [3,4,3,4,3,5,61,1]
l.sort()  # 将列表里的元素从小到大进行排序
l.sort(reverse = True)  # 将列表里的元素从大到小排序
print(l)

count()
l = [3,4,3,4,3,5,61,1]
res = l.count(3)  # 记录其中一个元素在列表中的个数
print(res)

clear()
l = [3,4,3,4,5,61,1]
print(l.clear())  # 将列表元素清除

reverse()
l = [3,4,3,5,61,1]
l = l.reverse()  # 将列表反转
print(l)

列表能存多个值，有序，可变

队列  先进先出
l = []
#先进
l.append('first')
l.append('second')
l.append('third')
#先出
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

堆栈  先进后出
l = []
# 先进
l.append('first')
l.append('second')
l.append('third')
# 后出
print(l.pop())
print(l.pop())
print(l.pop())

2.元组

作用：能够存储多个元素，元素与元素之间逗号隔开，元素可以是任意类型，元组不能被修改

定义：与列表类型相比，将[]换为()

age = (11,2,3,44,55)  本质age = tuple(11,2,3,44,55)

按索引取值（正向取+反向取）：只能读
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(id(t))
print(t)
t[-1][0] = '我改了'
print(id(t))  # id没有改变  不可变指的是黄色部分的连接不能断
print(t)

切片（顾头不顾尾，步长）
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(t[::2])

长度
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(len(t))

成员运算in和not in
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print('a' in t)  # 返回的是False或True

循环
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
for i in t:
    print(i)

print(t.count('a'))  # 返回的是'a'的个数
print(t.index('a'))  # 返回的是第一个'a'的索引

能存多个值，有序，不可变

t2 = (1,2,3,4,[1,2])
print(id(t2))
t2[-1].append(666)
print(t2)  #(1, 2, 3, 4, [1, 2, 666])
print(id(t2))  # id没于发生改变

3.字典

作用：能存储多组key:value键值对 key对value进行描述，key通常情况下是字符串

key只能是不可变类型,value可以是任意数据类型

强调:字典的key是不能重复的 要唯一标识一条数据，如果重复了 只会按照最后一组重复的键值对存储

按key存取值：可存可取
d3 = {'name':'jason','password':'123'}
print(id(d3))
print(d3['name'])
d3['age'] = 18  # 赋值语句，当key不存在的情况下，会自动新增一个键值对
print(d3,id(d3))

长度len
统计的键值对的个数

成员运算in和not in   对于字典来说只能判断key值
d3 = {'name':'jason','password':'123'}
print('123' in d3)  # 返回的是Flase
print('name' in d3)  # 返回的是True

删除
d3 = {'name':'jason','password':'123'}
res = d3.pop('name')  # 弹出的value
res1 = d3.pop('age')  # 当键不存在的时候直接报错
print(res)

定义字典的三种方式

d1 = {'name':'jason','password':123}

d2 = dict(name='jason',password=123,age=18)

l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]
d = {}
for k,v in l:
    print(k,v)  # name jason  age 18  hobby read
    d[k] = v  # {'name': 'jason', 'age': 18, 'hobby': 'read'}
print(d)

键keys()，值values()，键值对items()
d1 = {'name':'jason','password':123}
print(d1.keys())  # 返回的是所有键
print(d1.values())  #返回的是所有值
print(d1.items())  # 返回的是所有键值对

get()根据key获取value
d1 = {'name':'jason','pwd':123}
print(d1['name'])  # 返回的是值
print(d1['age'])  # 报错
res = d1.get('age')  # 当字典的key不存在的情况 不报错 返回None
print(res)
res1 = d1.get('xxx','你给我的age在字典的key中')  # get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
print(res1)  #第二个参数不写的话 当key不存在的情况下返回None，写了就返回写了内容

dict.fromkeys()  快速的创建一个字典
dict.popitem()  尾部以元组的形式弹出键值对

l1 = ['name','password','age','hobby']
s = dict.fromkeys(l1)
print(s)
print(s.popitem())

d1 = {'name':'jason','pwd':123}
res1 = d1.setdefault('name','xxoo')  # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1,res1)
res2 = d1.setdefault('age',18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1,res2)

d1 = {'name':'jason','pwd':123}
d2 = {'age':18}
d1.update(d2)
print(d1)

4.集合

1.关系运算
2.去重

作用：去重、关系运算

定义：可以包含多个元素，用逗号分隔。s = {1,2,3,4,5,6}    # <class 'set'>  # s = set()

s1 = set()  # 定义空集合的时候只能是关键字set

()  # 定义的是一个空元组

{}  # 定义的是一个空字典

集合的元素遵守三个原则：
1.每一个元素必须是不可变类型
可变：不可hash
不可变：可hash
2.没有重复的元素
3.无序

1.长度len
2.成员运算 in 和not in
3.| 合集
4.& 交集
5.-差集
6.^对称差集
7.==      s = {1,2,3}   s1 = {3,2,1}
8.父集：>,>=
9.子集：<,<=

s1={1,2,3}
s1.update({3,4,5})  # {1, 2, 3, 4, 5}
print(s1)

s1={1,2,3}
res=s1.pop()  # 1  弹出的是索引为0的值
print(res)

s1={1,2,3}
res=s1.remove(3) #单纯的删除,返回值为None
print(s1)

s1={1,2,3}
s1.add(4)
print(s1)

s1={1,2,3}
s2={1,2}
s1.difference_update(s2) #s1=s1.difference(s2) 
print(s1)

s1={1,2,3}
res=s1.discard(3) ##单纯的删除,返回值为None
print(s1)
print(res)
s1.remove(444444) #删除的元素不存在则报错
s1.discard(444444) #删除的元素不存在不会报错

可变：list,dict,set

不可变：int,float,str,tuple,bool