Python之字典、元组、集合

一、字典

列表：有序序列（第一个放进列表的元素在第一个位置）
字典：无序序列（第一个放进字典的元素可能不在第一个位置）,key不允许重复，value可以重复
放在字典中的键：不可变序列（即键不可以为list等），不可执行增删改

'''可变序列：列表、字典、集合，对象地址不发生改变'''
'''不可变序列：字符串、元组'''

1、创建字典

# 1、使用花括号{}创建
scores = {'张三':100,'李四':90,'王五':98} # 键值对{key:value}
print(scores,type(scores)) # {'张三': 100, '李四': 90, '王五': 98} <class 'dict'>
# 2、使用内置函数创建
s = dict(name='jace',age=20) # {'name': 'jace', 'age': 20}
print(s)
# 空字典
d = {} 
print(d) # {}

2、字典元素的获取

scores = {'张三':100,'李四':90,'王五':98}

# 方法一 当查找的键不存在，会报错
print(scores['张三']) # 100
# 方法二 当查找的键不存在，不会报错，默认返回None
print(scores.get('张三')) # 100
print(scores.get('ddd',11111)) # 不会报错 11111

3、key的判断

scores = {'张三':100,'李四':90,'王五':98}
print('张三' in scores) # Ture
print('张三' not in scores) # False

4、字典元素的增删改

scores = {'张三':100,'李四':90,'王五':98}
# 1、字典元素删除
del scores['张三'] 
# scores.clear() # 清空字典所有元素
print(scores) # {'李四': 90, '王五': 98}
# 2、字典元素新增
scores['ddd'] = 99
print(scores) # {'李四': 90, '王五': 98, 'ddd': 99}
# 3、字典修改
scores['王五'] = 100
print(scores) # {'李四': 90, '王五': 100, 'ddd': 99}

5、获取字典视图

keys = scores.keys() # 获取所有键
values = scores.values() # 获取所有值
items = scores.items() # 获取所有键值对
print(keys,values,items) # dict_keys(['李四', '王五', 'ddd']) dict_values([90, 100, 99]) dict_items([('李四', 90), ('王五', 100), ('ddd', 99)])
print(list(keys),list(values),list(items)) # ['李四', '王五', 'ddd'] [90, 100, 99] [('李四', 90), ('王五', 100), ('ddd', 99)]

6、字典的遍历

for i in scores:
    print(i,scores[i],scores.get(i))
# 李四 90 90
# 王五 100 100
# ddd 99 99

7、字典生成式

# 内置函数zip()：用于将可迭代的对象作为参数，将对象中的元素打包成一个元组，然后返回由这些元组组成的列表
# {item.upper():price for item,price in zip(item,prices)}
items = ['ss','dd','ff']
prices = [1,2,3]
lst = zip(items,prices)
print(list(lst)) # [('ss', 1), ('dd', 2), ('ff', 3)]

二、元组

# 1、元组创建方式
# （1）使用小括号
t1 = ('Python','world',11) # 或 t1 = 'Python','world',11
print(t1,type(t1)) # ('Python', 'world', 11) <class 'tuple'>

# (2)使用内置函数tuple()
t2 = tuple(('Python','world',22))
print(t2,type(t2)) # ('Python', 'world', 22) <class 'tuple'>

# 只包含一个元组的元素需要使用逗号和小括号
t3 = ('Python',)
print(t3,type(t3)) # ('Python',) <class 'tuple'>
# 空元组
t0 = ()
t00 = tuple()

t = (10,[2,3,4],44)
# 不可以执行t[1]=100，但可以修改列表里的内容，列表id不变
t[1].append(100)
print(t) # (10, [2, 3, 4, 100], 44)

# 2、元组的遍历
for i in t:
    print(i)
# 10
# [2, 3, 4, 100]
# 44

元组相加：

t1 = (1,2,3,4)
t2 = (5,6,7,8)
print(t1 + t2)  # (1, 2, 3, 4, 5, 6, 7, 8)
print(t1 + (t2,))  # (1, 2, 3, 4, (5, 6, 7, 8))

元组与列表的区别：

元组是不可变的，列表是可变的

三、集合

集合是没有value的字典，元素不能重复

1、集合的创建

# （1）直接{}
s1 = {1,2,3,4,4,5,6} # 集合中的元素不能重复，重复的会被去掉
print(s1,type(s1)) # {1, 2, 3, 4, 5, 6} <class 'set'>

# （2）使用内置函数set()
s2 = set(range(5))
print(s2,type(s2)) # {0, 1, 2, 3, 4} <class 'set'>

s3 = set([1,1,2,3,4,4,4,5]) # 列表转集合
print(s3,type(s3)) # {1, 2, 3, 4, 5} <class 'set'>

s4 = set((1,2,2,3,4,55)) # 元组转集合
print(s4,type(s4)) # {1, 2, 3, 4, 55} <class 'set'>

s5 = set('Python') # 字符串转集合
print(s5) # {'t', 'h', 'P', 'y', 'n', 'o'}

s6 = set({1,2,5,3,66}) # 集合转集合
print(s6) # {1, 66, 2, 3, 5}

# 空集合
s7 = {} # 默认为空字典
s8 = set() # 空集合
print(s7,type(s7),s8,type(s8)) # {} <class 'dict'> set() <class 'set'>

2、集合的相关操作

# （1）判断 in、not in
ss = {1,2,3,4,5}
print(1 in ss) # True
print(1 not in ss) # False

# （2）新增
# add() 添加一个
# update() 添加一个或多个
ss.add(222)
print(ss) # {1, 2, 3, 4, 5, 222}
ss.update({33,44,55})
print(ss) # {1, 2, 3, 4, 5, 33, 44, 55, 222}
ss.update((2222,4444))
print(ss)
ss.update([77,88])
print(ss) # {1, 2, 3, 4, 5, 33, 44, 77, 2222, 55, 88, 4444, 222}

# （3）删除
# remove() 一次删除一个指定元素，如果指定元素不存在就抛出KeyError
# discard() 一次删除一个指定元素，如果指定元素不存在不抛出异常
# pop() 一次只删除一个任意元素，不能添加参数
# clear() 清空集合
ss.remove(222)
print(ss) # {1, 2, 3, 4, 5, 33, 44, 77, 2222, 55, 88, 4444}
# ss.remove(1000)
# print(ss)  KeyError: 1000
ss.discard(1000)
print(ss) # {1, 2, 3, 4, 5, 33, 44, 77, 2222, 55, 88, 4444}
ss.pop()
print(ss) # {2, 3, 4, 5, 33, 44, 77, 2222, 55, 88, 4444}

3、集合间的关系

# （1）相等 使用==、！=判断
ss1 = {1,2,3}
ss2 = {1,2,4}
ss3 = {3,2,1}
print(ss1==ss2) # False
print(ss1!=ss2) # True
print(ss1==ss3) # True 集合的元素相同、位置不同，集合相等
# （2）子集 调用issubset
ss4 = {1,2,3,5,6}
print(ss1.issubset(ss4)) # True ss1是ss4的子集
print(ss2.issubset(ss4)) # False
# （3）超集 调用issuperset
print(ss4.issuperset(ss1)) # True ss4是ss1的超集
print(ss4.issuperset(ss2)) # False
# （4）交集 调用isdisjoint，是否没有交集
print(ss1.isdisjoint(ss2)) # False

4、集合的数学操作

# (1)交集 intersection()或&
s1 = {1,2,3,4}
s2 = {1,2,3,5}
print(s1.intersection(s2)) # {1, 2, 3}
print(s1 & s2) # {1, 2, 3}

# (2)并集 union()或|
print(s1.union(s2)) # {1, 2, 3, 4, 5}
print(s1|s2) # {1, 2, 3, 4, 5}

# (3)差集 difference或-
print(s1.difference(s2)) # {4}
print(s1-s2) # {4}
print(s2-s1) # {5}

# (4)对称差集symmetric_difference()或^
print(s1.symmetric_difference(s2)) # {4, 5}
print(s1^s2) # {4, 5}

5、集合生成式

# 与列表生成式类似
s = {i*i for i in range(10)}
print(s) # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}