元组、字典、集合

1.元组基本介绍

元组 tuple
元组是⼀个不可变序列。⼀般当我们希望数据不改变时，我们使⽤元组，其他情况下基本都⽤列表。

• 创建元组：使⽤()创建
  如果元组不是空的，它里面至少得有一个逗号，当元组不是空元组时括号可以省略。

tup = 1,2,3,4,5    # (1, 2, 3, 4, 5) <class 'tuple'>
print(tup,type(tup))

• 元组的解包：指将元组当中的每⼀个元素都赋值给⼀个变量。当变量比元素少的时候，在一个变量前加*，注意只能给一个变量加
  解包也适用于列表和字符串

tup = 10,20,30,40
a,b,c,d = tup    # 元组解包  a = 10, b = 20, c = 30, d = 40
# a,b=tup    # ValueError: too many values to unpack (expected 2)
a,b,*c=tup
print('a=',a)   # a= 10
print('b=',b)   # b= 20
print('c=',c)   # c= [30, 40]

a,*b,*c='python'    # SyntaxError: two starred expressions in assignment

2.字典

2.1 字典的基本介绍

字典属于一种新的数据结构，映射（mapping）
作用：用来存储对象的容器
列表存储数据的性能特别好，但是查询数据的性能比较差，字典正好与之相反。
字典当中每一个元素都有唯一的名字，通过这个唯一的名字快速查找到指定的元素。
唯一的名字称之为key，通过key来查询值，值又称之为value。键值对（key-value，一项称之为item。
创建一个空字典：d = {}
语法：{key:value,key:value…}
字典的value可以是任意对象
字典的key 可以是任意的不可变对象 （int str bool tuple…)

d = {'name':'葫芦娃','age':20,'sex':'男'}
print(d,type(d))   # {'name': '葫芦娃', 'age': 20, 'sex': '男'} <class 'dict'>

字典的键是不能重复的，如果重复，后面的会替换前面的。
根据键来获取值

print(d['name'],d['age'],d['sex'])  # 葫芦娃 20 男

2.2 字典的使用

使用dict()这个函数来创建字典

d = dict(name='葫芦娃', age=18, sex='男')  # 往函数中传递了3个参数 {'name': '葫芦娃', 'age': 18, 'sex': '男'}

# 双值子序列
# 双值序列，序列中有两个值 [3,4] 'mn' ('w',8)
# 子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列 [(3,4),(5,6)]
d = dict([('name','葫芦娃'),('age',18)])  # {'name': '葫芦娃', 'age': 18}

len() 获取字典中键值对的个数
in 检查字典中是否包含指定的键
not in 检查字典中是否不包含指定的键
根据键来获取字典当中的值 语法: dict[key]
get(key[,default]) 该方法根据字典中的key来获取值，如果你的key不存在则返回None。也可以指定第二个参数，当这个key值不存在的时候回返回默认值。

print(d.get('n', 'key值不在'))  # 'key值不在'

修改字典：

d['name'] = '钢铁侠'     # 修改字典的key-value
d['phone'] = 1234566     # 向字典中添加key-value
print(d)

d.setdefault(key[,default]) 可以向字典中来添加k-v。
如果key已存在字典当中，则返回key的值，不会对字典作任何操作。
如果key不存在，则向字典中添加这个key 并设置value。

d = {'name': '葫芦娃', 'age': 18}
d.setdefault('name', '侠')    # 返回 '葫芦娃'
r = d.setdefault('num', 12245)  
print(r)      # 12245
print(d)      # {'name': '葫芦娃', 'age': 18, 'num': 12245}

update() 将其他字典的k-v添加到当前的字典中。
如果有重复的key，后面的会替换前面的。

d1 = {'a': 1, 'b': 2}
d2 = {'d': 4, 'e': 5, 'a': 8}
d1.update(d2)
print(d1)    # {'a': 8, 'b': 2, 'd': 4, 'e': 5}

删除：
del 来删除字典中的k-v

del d1['a']
del d1['b']
print(d1)    # {'d': 4, 'e': 5}

popitem() 随机删除一个k-v，一般都会删除最后一个。
有返回值，删除之后会将删除的元素以元组的形式返回。

d1 = {'a': 8, 'b': 2, 'd': 4, 'e': 5}
r = d1.popitem()
print(r)     # ('e', 5)
print(d1)    # {'a': 8, 'b': 2, 'd': 4}

pop(key[,default) 根据key来删除字典中的k-v，会将删除的value返回。
第⼆个参数可以指定⼀个默认值，当获取不到值的时候会返回默认值。

d1 = {'a': 8, 'b': 2, 'd': 4, 'e': 5}
r = d1.pop('w', '这个key值不存在')
print(r)     # '这个key值不存在'
print(d1.pop('a'))   # 8
print(d1)    # {'b': 2, 'd': 4, 'e': 5}

2.3 浅复制

copy()
复制以后的对象和原对象是独立的，修改其中一个不会影响另一个。
浅复制只会复制字典本身，如果字典中还有个字典是不会被复制。
这个值也可以是一个可变对象，这个可变对象也不会被复制。

d = {'a':{'name':'葫芦娃','age':20},'b':2,'c':3,'d':4}
d2 = d.copy()
d2['a']['name'] = '黑猫警长'
print('d=',d,id(d))    # d= {'a': {'name': '黑猫警长', 'age': 20}, 'b': 2, 'c': 3, 'd': 4} 2202923196280
print('d2=',d2,id(d2))   # d2= {'a': {'name': '黑猫警长', 'age': 20}, 'b': 2, 'c': 3, 'd': 4} 2202953050224

2.4 遍历字典

keys() 该方法会返回字典所有的key。

d = dict(name='葫芦娃', age=18, sex='男')
print(d.keys())    # dict_keys(['name', 'age', 'sex'])
for k in d.keys():
    print(d[k])     # 葫芦娃
                    # 18
                    # 男

values() 该方会返回一个序列，序列中保存所有字典的值。

print(d.values())   # dict_values(['葫芦娃', 18, '男'])
for v in d.values():
    print(v)        # 葫芦娃
                    # 18
                    # 男

items() 该方法会返回字典所有的项。它返回⼀个序列，序列中包含有双值⼦序列 双值分别是字典中的key和value。

print(d.items())     # dict_items([('name', '葫芦娃'), ('age', 18), ('sex', '男')])
for k,v in d.items():
    print(k,'=',v)   # name = 葫芦娃
                     # age = 18
                     # sex = 男

3.集合

3.1 集合简介

集合表现形式set
s = {1,2,3,4}
集合和列表⾮常相似。
不同点：
1.集合只能存储不可变对象。
2.集合中存储的对象是⽆序的。
3.集合不能出现重复元素。
使⽤{}来创建集合。
可以通过set()来将序列和字典转换成集合。
使用in not in 来检查集合中的元素。

s = {'a', 'b', 1, 2, 3}
print('b' in s)    # True

len() 使⽤len()来获取集合中元素的数量。

print(len(s))    # 5

add()像集合中添加元素。

s.add(50)
s.add(100)
print(s)     # {1, 2, 3, 'b', 100, 50, 'a'}

update()将⼀个集合中的元素添加到另⼀个集合当中。

s2=set('python')
s.update(s2)   
print(s)     # {1, 2, 3, 'b', 100, 'h', 't', 'y', 50, 'p', 'a', 'o', 'n'}

pop()随机删除集合中的⼀个元素⼀般是删除最后⼀个元素。

r=s.pop()
print(r)   # 1
print(s)   # {2, 3, 'b', 100, 'h', 't', 'y', 50, 'p', 'a', 'o', 'n'}

remove() 删除集合中指定的元素。

s.remove(3)
print(s)   # {2, 'b', 100, 'h', 't', 'y', 50, 'p', 'a', 'o', 'n'}

clear() 清空集合。

s.clear()
print(s)   # set()

3.2 集合的运算

• & 交集运算

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
result = s1 & s2   # {3, 4, 5}
print(s1,s2,result)

• | 并集运算

result = s1 | s2   # {1, 2, 3, 4, 5, 6, 7}

• - 差集运算

result = s1 - s2   # {1, 2}
result = s2 - s1   # {6, 7}

• ^ 亦或集 集合里面不相交的

result = s1 ^ s2   # {1, 2, 6, 7}
print(s1,s2,result)

• <= 检查⼀个集合是否是另⼀个集合的⼦集
• < 检查⼀个集合是否是另⼀个集合的真⼦集
• >=检查⼀个集合是否是另⼀个集合的超集
• >检查⼀个集合是否是另⼀个集合的真超集

a = {1,2,3,4,5}
b = {1,2,3,4,5}
result = a <= b  # True a是b的子集 b是a的超集
result = a < b   # False
a = {1,2,3}
b = {1,2,3,4,5}
result = a < b    # True a是b的真子集 b是a的真超集
print(result)