07元组、字典和集合

要熟练掌握元组、字典和集合的不同功能的方法

1.元组简介

• 元组是不可变序列，通过（）可以创建，或者不用（）而直接用‘，’将各个元素分隔开也可以

tup=()
print(tup,type(tup))  # () <class 'tuple'>

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

tup=(1,2,3,4,5)
print(tup.index(1)) # 0  返回了1的索引值

print(tup[1]) # 2  注意这里依然是[]来调用，tup[1]是索引为1的元组的值
print(tup) # (1,2,3,4,5)  注意这里tup是一个变量对象
tup[1]=9  # 不可变序列给序列重新赋值是不允许的  TypeError: 'tuple' object does not support item assignment
tup=9	# 这是给变量对象重新赋值，是允许的

''' 
将元组的元素赋值给变量的过程就叫做解包
——赋值时变量个数与元组内的元素个数必须保持一致
——如果元组元素在解包时不逐个分解，可通过*c的方式可以将多个元素放入列表中
——字符串和列表同样适用这些解包的方法
'''
tup=10,20,30,40
a,b,c=tup  #  ValueError: too many values to unpack (expected 3)
a,b,c,d,e=tup   #   ValueError: not enough values to unpack (expected 5, got 4)
a,b,c,d=tup  #	变量个数与元组内的元素个数必须保持一致
'''变量个数与元组内的元素个数必须不一致时采用以下方法'''
a,b,*c=tup          #   a=tup[0],b=tup[1],*c表示剩下的都给了列表c，c=[tup[2],tup[3]]
a,*b,c=tup          #   a=tup[0],c=tup[3],*b表示剩下的都给了列表b，b=[tup[1],tup[2]]
*a,b,c=tup          #   b=tup[2],c=tup[3],*a表示剩下的都给了列表a，a=[tup[0],tup[1]]
# 以下打印结果是省略版
print('a =',a)      #   a = 10      a = 10      a = [10, 20]
print('b =',b)      #   b = 20      b = [20, 30]        b = 30
print('c =',c)      #   c = [30, 40]        c = 40      c = 40

''' 遍历、索引、切片、解包等方式在列表、字符串、元组中都是可以通用的，这些操作本质上都没有对原来序列进行变更 '''
# 字符串的解包
a,b,*c='python'
print('a =',a)      #   a = p
print('b =',b)      #   b = y
print('c =',c)      #   c = ['t', 'h', 'o', 'n']

# 列表的解包
a,b,*c=[1,2,3,4,5,6,7,7]
# a,*b,*c=[1,2,3,4,5,6,7,7]    # 不能出现多个*  SyntaxError: two starred expressions in assignment
print('a =',a)      #   a = 1
print('b =',b)      #   b = 2
print('c =',c)      #   c = [3, 4, 5, 6, 7, 7]

2.字典简介

2.1字典的基本介绍

• 字典属于一种新的数据结构，被称之为映射（mapping）
• 字典的作用和列表类似，都是用来存储对象的一种容器
• 列表对数据的存储比较在好，但数据的查询检索则相对差一些，而字典正好与之相反
• 字典中的每一个元素都有一个唯一的名字，通过这个名字可以快速查找到指定元素
• 唯一的名字被称之为Key，通过key来查询的值称之为Value，键值对（Key—Value）一项成为Item

'''
创建字典{}
语法：{key:value，key:value,....}
创建字典dict()
语法：dict(key=value，key=value,....)
字典的value可以是任意的对象
字典的key是不可变的对象，如int、str、bool、tuple...
'''
d={}
print(d,type(d))  # {} <class 'dict'>

d={'name':'李雷','age':12,'sex':'男'}   # {'name': '李雷', 'age': 12, 'sex': '男'} <class 'dict'>
d=dict(name='李雷',age=12,sex='男')   # {'name': '李雷', 'age': 12, 'sex': '男'} <class 'dict'>
print(d,type(d))    

''' 字典的键是不能重复的，如果重复，后面的值会替换前面的值 '''
d={'name':'李雷','age':12,'sex':'男','name':'韩梅梅'}
print(d,type(d))    # {'name': '韩梅梅', 'age': 12, 'sex': '男'} <class 'dict'>

# 另一种书写格式
header={
    'name':'李雷',
    'age':12,
    'sex':'男'
}

# 根据键key来获取值value
print(d['name'],d['age'],d['sex']) 	# 韩梅梅 12 男

2.2字典的使用

# 创建字典

# # 使用dict()函数
# d=dict(name='李雷',age='15',sex='男')  # {'name': '李雷', 'age': '15', 'sex': '男'} <class 'dict'>
# print(d,type(d))

'''
dict（）函数通过双值子序列创建字典
双值序列：序列中有两个元素[1,2]，(m,n)，'ab'
子序列：如果序列中的元素也是个序列，我们称之为子序列[(1,2),(3,4)]
'''

d=dict([('name','李雷'),('age','15')])    # {'name': '李雷', 'age': '15', 'sex': '男'} <class 'dict'>
print(d,type(d))

''' len（）获取字典中键值对的个数 '''
print(len(d))   # 2

''' in/not in：检查字典中是否 包含/不包含 指定的键 '''
print('name' in d)  # True
print('sex' not in d)  # True

''' 
通过键值来获取字典中的对应Value值
d[key]
get(key[,default])当字典中不存在前面的key时，返回default的内容
'''
print(d['name'])   # 李雷
# print(d['sex'])     # KeyError: 'sex'当键值为其他错误值时这种方式取值会直接抛出异常
# get(key[,default]) 该方法根据字典中key值获取相应value值
# default为第二个参数，当key值不存在时指定返回值
print(d.get('sex'))    # None 同过get方法获取时，当键值错误会返回一个none，这样就不会影响程序的运行啦
print(d.get('sex','字典中不存在sex这个key'))    # 字典中不存在sex这个key

''' 
修改字典：
=
setdefault()
update()
'''
# 通过赋值直接修改key——value
d['name']='超人'  # {'name': '超人', 'age': '15'}
# 通过赋值直接添加新的key——value
d['sex']='男'    # {'name': '超人', 'age': '15', 'sex': '男'}
# 通过setdefault方法添加新的key——value，如果key已经存在则不会对原值修改，而是返回原值
r=d.setdefault('name','死亡之神')   # 超人
# 通过update方法向一个字典中添加另一个字典（key-value）
# 如果key已经存在则对原值修改
# 如果value已经存在，并不影响修改key-value
d1={'a':1,'b':2,'c':3}
d2={'d':7,'e':8,'f':9}
# d1.update(d2)   #{'a': 1, 'b': 2, 'c': 3, 'd': 7, 'e': 8, 'f': 9}
d3={'b':7,'c':8,'f':9}
# d1.update(d3)   #{'a': 1, 'b': 7, 'c': 8, 'f': 9}
d4={'d':1,'e':2,'f':9}
# d1.update(d4)   #{'a': 1, 'b': 2, 'c': 3, 'd': 1, 'e': 2, 'f': 9}

'''
删除
del通过键值删除
popitem方法随机删除一个key-value，一般是最后一个
popitem方法有返回值，以元组形式返回删除的key-value
pop根据一个key删除一个key-value，有返回值（删除的value）
pop(key[,default])当字典中不存在前面的key时，返回default的内容
'''
# del
# del d1['a']     # {'b': 2, 'c': 3}
# popitem
# r=d1.popitem()    # ('c', 3)
# pop
# r=d1.pop('b')   # 2
# r=d1.pop('f','字典中没有这个键值对')    #字典中没有这个键值对
# r=d1.pop('b','字典中没有这个键值对')    # 2
print(r)

2.3 copy（）、浅复制

d1={'a':1,'b':2,'c':3}
'''
d2=d1,这种情况不属于复制，而是变量赋值，对d2的修改直接修改d1
'''
d2=d1  # {'a': 1, 'b': 2, 'c': 3}
d2['a']=8
print('d2 =',d2)    # d2 = {'a': 8, 'b': 2, 'c': 3}
print('d1 =',d1)    # d1 = {'a': 8, 'b': 2, 'c': 3}

d1={'a':1,'b':2,'c':3}
'''
d2=d1.copy(),复制，对d2的修改不影响d1
'''
d2=d1.copy()
d2['a']=8
print('d2 =',d2)    # d2 = {'a': 8, 'b': 2, 'c': 3}
print('d1 =',d1)    # d1 = {'a': 1, 'b': 2, 'c': 3}

'''
浅复制，针对多层结构的字典而言，对内层的字典不属于复制，新字典内层的修改也会对源字典内层修改
'''
d={'a':{'name':'李雷','age':15},'b':2,'c':3}
d3=d.copy()
d3['a']['sex']='男'
print('d3 =',d3)    # d3 = {'a': {'name': '李雷', 'age': 15, 'sex': '男'}, 'b': 2, 'c': 3}
print('d =',d)      # d = {'a': {'name': '李雷', 'age': 15, 'sex': '男'}, 'b': 2, 'c': 3}

3.遍历字典

'''
遍历方式
keys()返回字典所有的key值
values()返回字典所有的value值
items()返回所有的key-value值
'''
d={'name': '李雷', 'age': 12, 'sex': '男'}

# keys()
print(d.keys())   # dict_keys(['name', 'age', 'sex'])
for k in d.keys():
    print('k =', k)
    # 结果是：
    # k = name
    # k = age
    # k = sex
# values()
print(d.values())   # dict_values(['李雷', 12, '男'])
for v in d.values():
    print('v =', v)
    # 结果是:
    # v = 李雷
    # v = 12
    # v = 男
# items
print(d.items())    # dict_items([('name', '李雷'), ('age', 12), ('sex', '男')])
for t in d.items():
    print('t =', t)
    # 结果是:
    # t = ('name', '李雷')
    # t = ('age', 12)
    # t = ('sex', '男')
'''
关于items还可以换一种方法
这样看起来就很不错
'''
for k,v in d.items():
    print(k, '=', v)
    # 结果是：
    # name = 李雷
    # age = 12
    # sex = 男

4.集合set

4.1集合简介

• 类似列表，但各方面和列表略有不同
• 集合中存储的元素没有固定顺序，所以也没法被直接访问
• 集合中的元素也不可以由重复的，必须是唯一的，重复的会被删掉
• 集合中的元素是不可变的？？？

'''
集合
无序而唯一
{x,y,z...}创建集合
set（[...]）将序列和字典转换成集合
'''
# 同样是{}，但是集合与列表不同
n={}
print(n,type(n))    # {} <class 'dict'>
s={1,2,3}
print(s,type(s))    # {1, 2, 3} <class 'set'>
b={'a':1,'b':2,'c':3}
print(b,type(b))    # {'a': 1, 'b': 2, 'c': 3} <class 'dict'>

# set()
'''
set将列表转换为集合
'''
s=set(['python'])
print(s,type(s))    # {'python'} <class 'set'>
'''
set将字典转换为集合时，取其key值，舍掉value值
'''
s=set({'a':1,'b':2,'c':3})
print(s,type(s))    # {'a', 'b', 'c'} <class 'set'>

# 集合的无序与排重性
s1={1,1,3,5,6,8,'a','k','e'}
print('s1 =',s1)    # s1 = {1, 3, 5, 6, 'k', 8, 'e', 'a'}

#集合转化为list
s2={'教皇','比比东','大师'}
print(s2,type(s2))  # {'比比东', '大师', '教皇'} <class 'set'>
L1=list(s2)
# d1=dict(s2)
print(L1,type(L1))  # ['大师', '比比东', '教皇'] <class 'list'>

# 不能直接访问集合
# print(s2[1])    # TypeError: 'set' object does not support indexing
print(list(s2)[1])  # 比比东

• len（）、add（）、update（）、pop（）、remove（）、clear（）

s={'唐三','小舞','沐白','竹清'}
# in 、not in
print('a' in s) # False
print('a' not in s) # True
# len(),add(),update(),pop(),remove(),clear()
# len()获取集合中元素个数
print(len(s)) # 4
# add()向集合中随机位置添加元素
s.add('荣荣')
print(s)    # {'唐三', '小舞', '沐白', '荣荣', '竹清'}
# update() 将一个集合中的元素添加到另一个集合当中
s1={1,2,3,4}
s.update(s1)
print(s)    # {1, 2, '小舞', 3, 4, '竹清', '沐白', '唐三', '荣荣'}
# pop() 随机删除一个元素,会返回删除的元素
a=s1.pop()
print(a)    # 1
print(s1)   # {2, 3, 4}
# remove() 删除集合中的指定元素
b=s1.remove(3)
print(b)    # None 说明没有返回值
print(s1)   # {2, 4}
# clear（）清空集合
s1.clear()
print(s1)   # set()

4.2集合运算

• 交集运算 &
• 并集运算 |
• 差集运算 -
• 亦或集 ^
• 检查一个集合是否是另一个集合的子集 <=
• 检查一个集合是否是另一个集合的真子集 <
• 检查一个集合是否是另一个集合的超集 >=
• 检查一个集合是否是另一个集合的真超集 >

'''
交集运算 &
并集运算 |
差集运算 -
亦或集  ^
检查一个集合是否是另一个集合的子集   <=
检查一个集合是否是另一个集合的真子集  <
检查一个集合是否是另一个集合的超集  >=
检查一个集合是否是另一个集合的真超集  >
'''
s1={1,2,3,4,5}
s2={3,4,5,6,7}
t={1, 2, 3, 4, 5, 6, 7}
# 交集运算 &
s=s1&s2
print(s)    # {3, 4, 5}
# 并集运算 |
s=s1|s2
print(s)    # {1, 2, 3, 4, 5, 6, 7}
# 差集运算 -
'''
值得注意的是差集求的是第一个集合中存在而第二个集合中不存在的
不是两个集合中不同的元素
'''
a=s1-s2
b=s2-s1
print('s1-s2=',a)   # s1-s2= {1, 2}
print('s2-s1=',b)   # s2-s1= {6, 7}
# 亦或集  ^
'''
值得注意的是两个集合的异或集求的是两个集合中不同的元素
'''
c=s1^s2
d=s2^s1
print('s1^s2=',c)   # s1-s2= {1, 2}
print('s2^s1=',d)
# 检查一个集合是否是另一个集合的子集   <=
print(1)if s1<=s else print(0) #1
print(1)if t<=s else print(0) #1
# 检查一个集合是否是另一个集合的真子集  <
print(1)if s1<s else print(0) # 1
# 检查一个集合是否是另一个集合的超集  >=
print(1)if s>=s1 else print(0) # 1
print(1)if t>=s else print(0) #1
# 检查一个集合是否是另一个集合的真超集  >
print(1)if s>s1 else print(0) # 1