一、字典
1.什么是字典（dict）
1）字典是容器型数据类型（序列），将{}作为容器的标志，里面有多个元素用逗号隔开
特点：可变（支持增删改）、无序（不支持下标操作）
2）字典中的元素
字典总的元素都是键值对，以'键: 值'的形式成对出现
{键1: 值1, 键2: 值2, ...}
字典存储数据主要是为了存值，键只是为了区分不同的值而存在的
- 键值对中的键：不可变（可hashable，数字 / 字符串 / 元祖）；唯一的
- 键值对中的值：和列表元素一样，任何数据都可以作为值
# key是唯一的
list3 = {'x': 200, 'y': 150}
print(list3) # {'x': 200, 'y': 150}
2.字典的增删改查
1）查（获取字典的值）
a. 获取单个元素的值
- 字典[字典]：获取字典中指定key对应的值；如果key值不存在，会报错；
- 字典.get(key) / 字典.get(key, 默认值)：获取字典中指定key对应的值；如果key不存在返回None或者默认值
# a. 获取单个元素
dog = {'name': '旺财', 'age': 3, 'type': '土狗',
'color': 'yellow', 'gender': '母狗'
}
print(dog['name'], dog['gender'])
# print(dog['weight']) # KeyError: 'weight'
print(dog.get('age'), dog.get('color'))
print(dog.get('weight')) # None
print(dog.get('weight', 'error'))
b. 遍历
for-in 字典直接拿到的是字典中所有的key
for key in 字典:
pass
for value in 字典.values():
pass
# b. 遍历
print('===================1===================')
# 常用的遍历方式(直接拿key)
for key in dog:
print(key, dog[key])
# 后面两种不能用，保证能看懂
print('===================2===================')
print(dog.values())
for value in dog.values():
print(value)
print('===================3===================')
print(dog.items())
for key, value in dog.items():
print(key, value)
dict1 = {'a': 10, 'b': 20, 'c': 30}
n = dict((value, key) for key, value in dict1.items())
print(n) # {10: 'a', 20: 'b', 30: 'c'}
m = dict((dict1[key], key) for key in dict1)
print(m)
2） 增 / 改
增：添加键值对；
改：修改字典中某个key对应的值
语法：字典[key] = 值，当key不存在就在字典中添加键值对'key: 值'；当key存在就修改字典中key对应的值
dict2 = {'a': 1, 'b': 2}
print(dict2) # {'a': 1, 'b': 2}
dict2['c'] = 3
print(dict2) # {'a': 1, 'b': 2, 'c': 3}
dict2['a'] = 100
print(dict2) # {'a': 100, 'b': 2, 'c': 3}
3）删（删除对应的key对应的值）
a. del 字典[key]
删除指定key对应的键值对
dict2 = {'a': 100, 'b': 2, 'c': 3}
del dict2['b']
print(dict2) # {'a': 100, 'c': 3}
b. 字典.pop(key)
取出字典中key对应的值，返回被取出来的值
dict2 = {'a': 100, 'b': 2, 'c': 3}
val = dict2.pop('c')
print(val) # 3
3.字典相关操作和方法
1）相关操作
字典不支持+，*，>，<，>=，<=
支持：==，!=
# print({'a': 10} + {'b': 20})
# TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
print({'a': 10, 'b': 20} == {'a': 10, 'b': 20}) # True
print({'a': 10, 'b': 20} == {'b': 20, 'a': 10}) # True
2）相关操作：in / not in; max; min; sum; len
- key in 字典：判断字典中是否存在某个值
- max, min, sum：针对的是key操作
- dict(数据)：将指定数据转换成字典
转换成字典的数据要求：a.数据本身是一个序列；b.序列中元素必须是有且只有两个元素的小序列
[[元素11, 元素12], [元素21, 元素22], 'ab', ...]
print(2 in {'a': 1, 'b': 2}) # False
print('a' in {'a': 1, 'b': 2}) # True
dict1 = {'a': 1, 'z': 2, 'c': 3}
# max / min
print(max(dict1)) # z
print(min(dict1)) # a
# print(sum(dict1))
# TypeError: unsupported operand type(s) for +: 'int' and 'str'
dict2 = {1: 'c', 2: 'b', 3: 'a'} # key为hashable，数字、字符串、元组
# sum
print(sum(dict2))
# len
print(len(dict2))
# 转换
print(dict([['3', 2], ('c', 3), 'ab']))
3）相关方法
clear()、copy()、get()、items()、fromkeys()、values()、keys()、setdefault()、update()
student = {'name': '小明', 'age': 18, 'gender': '男'}
student.clear() # {}
print(student)
# a. dict.fromkeys(序列, 值1=None) - 创建一个新的字典，
# 将序列中的元素作为字典中的key，将值1作为每个key对应的value
new_dict = dict.fromkeys('abc')
print(new_dict) # {'a': None, 'b': None, 'c': None}
new_dict = dict.fromkeys(range(10, 14), 100)
print(new_dict) # # {10: 100, 11: 100, 12: 100, 13: 100}
# b. 字典.items() - 将字典中的键值对转换成元组作为容器中的元素
student = {'name': '小明', 'age': 18, 'gender': '男'}
print(student.items())
# c. 字典.values()，列表.keys()
print(student.values(), student.keys()) # 不是列表，是序列
# d. 字典.setdefault(key, value=None)
# - 字典中添加键值对（key存在的时候不会有修改作用）
student.setdefault('height', 180)
print(student)
student.setdefault('name', '小花')
print(student) # name键值存在，'小花将不会添加进去'
#e. 字典1.update(字典2) - 将字典2中的键值对全部添加到字典1中
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'x': 100, 'y': 200, 'c': 300}
dict1.update(dict2) # {'a': 1, 'b': 2', 'c': 300, x': 100, 'y': 200}
print(dict1)
dict1.update([(2, 3), (4, 5)])
print(dict1) # {'a': 1, 'b': 2', 'c': 300, x': 100, 'y': 200, 2: 3, 4: 5}
练习：用一个列表保存5只狗的信息，每只狗有：名字、年龄、颜色和体重
1）求5只狗的平均年龄
2）找到5只狗体重最大的狗的名字
print('==================方法一==================')
# 体重最大的够=狗只有一只
dogs = [
{'name': 'a1', 'age': 2, 'color': 'white', 'weight': 20},
{'name': 'a2', 'age': 5, 'color': 'gray', 'weight': 28},
{'name': 'a3', 'age': 5, 'color': 'black', 'weight': 30},
{'name': 'a4', 'age': 2, 'color': 'yellow', 'weight': 12},
{'name': 'a5', 'age': 4, 'color': 'white', 'weight': 16}
]
total_age = 0
weight_name = 0
max_weight = 0
for dog in dogs:
total_age += dog['age']
if max_weight < dog['weight']:
max_weight = dog['weight']
weight_name = dog['name']
counts = len(dogs)
average_age = total_age / counts
print(average_age, weight_name)
print('==================方法二==================')
# 体重最大的狗有多只
dogs = [
{'name': 'a1', 'age': 2, 'color': 'white', 'weight': 20},
{'name': 'a2', 'age': 5, 'color': 'gray', 'weight': 28},
{'name': 'a3', 'age': 5, 'color': 'black', 'weight': 30},
{'name': 'a4', 'age': 2, 'color': 'yellow', 'weight': 12},
{'name': 'a5', 'age': 4, 'color': 'white', 'weight': 16},
{'name': 'a6', 'age': 6, 'color': 'gray', 'weight': 30}
]
total_age = 0
weight_name = 0
max_weight = 0
for dog in dogs:
total_age += dog['age']
if max_weight < dog['weight']:
max_weight = dog['weight']
counts = len(dogs)
average_age = total_age / counts
for dog in dogs:
if max_weight == dog['weight']:
print(dog['name'])
print(average_age)
二、集合
1.什么是集合(set)
1）集合
集合是容器型数据类型（序列）；将{}作为容器的标志，多个元素用逗号隔开（和字典不一样，集合的元素式独立的数据不是键值对）
特点：可变（增删）、无序（不支持下标操作）
注意：{}表示的是空字典
2）元素
不可变的数据；同一个元素只能有一个（唯一性）
set1 = {}
print(type(set1)) # <class 'dict'>
set1 = set()
print(type(set1)) # <class 'set'>
# 集合元素是不可变的数据
# set2 = {'abc', [1, 2]}
# TypeError: unhashable type: 'list'
# set3 = {{'a': 'b'}, True}
# TypeError: unhashable type: 'dict'
# a = 10
# set4 = {10, True, {11, 2}}
# TypeError: unhashable type: 'set'
# 集合自带去重功能
set5 = {1, 3, 3, 4, 1, 1}
print(set5)
scores = {34, 90, 89, 23, 24, 89, 100, 90}
scores = list(set(scores))
print(scores)
print(list(set([2, 3, 89, 9])))
2.集合元素的增删改查
1）查
只支持遍历，不能单独获取具体某一个元素
names = {'小明', '路飞', '纳兹', '哈皮'}
for item in names:
print(item)
2）增（添加元素）
集合.add(元素)：在集合中添加一个元素
集合.updata(序列)：将序列中所有的元素都添加到集合中
names = {'小明', '路飞', '纳兹', '哈皮'}
names.add('夏洛克')
print(names) # {'小明', '路飞', '纳兹', '哈皮', '夏洛克'}
names.update({100, 200})
print(names)
# {'小明', '路飞', '纳兹', '哈皮', '夏洛克', 100, 200}
names.update('yes')
print(names)
# {'哈皮', 100, '纳兹', 'e', 200, 'y', 's', '小明', '路飞', '夏洛克'}
3）删（删除元素）
a. 集合.remove(元素)：删除集合中指定的元素
b. 集合.discard(元素)：用于移除指定的集合元素，该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
names = {'小明', '路飞', '纳兹', '哈皮'}
names.remove('小明')
print(names) # {'路飞', '哈皮', '纳兹'}
4）改（集合不支持修改元素的操作）
三、集合相关操作
1.数学集合运算：|、&、-、^、>、<
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 9}
# 1）求并集：集合1 | 集合2 - 将两个集合的元素合并，并去重
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 2）求交集：集合1 & 集合2 - 获取两个集合的公共部分
print(set1 & set2) # {4, 5, 6}
# 3）求差集：集合1 - 集合2 - 获取集合1中能够除了集合2中的元素剩下的部分
print(set1 - set2) # {1, 2, 3}
print(set2 - set1) # {8, 9, 7}
# 4）对称差集：集合1 ^ 集合2 - 两个集合除了公共部分的剩下部分
print(set1 ^ set2)
# 5）集合1 > 集合2 - 判断集合1是否包含集合2
print({9, 10, 11, 12} > {1, 2, 3}) # False
print({9, 10, 11, 12} > {9, 10, 11}) # True
# 6）集合1 < 集合2 - 判断集合2中是否包含集合1
print({9, 10, 11, 12} < {9, 11}) # False
