字典基础

一、字典基础

1.什么是字典(dict)

字典是容器型数据类型，将{ }作为容器的标志，多个元素用逗号隔开（字典的元素都是键值对）：{键1:值1, 键2:值2, 键3:值3, …}
字典是可变的（支持增删改），字典无序（不支持下标操作）

字典中元素：键值对
键 - 不可变，唯一 （一般是字符串）
值 - 任何类型的数据，可以重复
字典在保存数据的时候，真正想保存的是值，键是用来对值进行区分和说明

空字典

dict1 = {}

dict2 = {2: 23, "abc": "hello",(1, 2): 200}
print(dict2)

字典中key不可变

dict3 = {[1, 2]: 100, "abc": 200}
print(dict3)            # 报错

字典中key只保留一个

dict3 = {"a": 10, "b": 20, "a": 100}
print(dict3)        # {'a': 100, 'b': 20}

字典是无序的

print({"a": "b", "c": "d"} == {"c": "d","a": "b"})      # True

2.获取字典的值
1）获取单个元素对应的值
“”"
a.
字典[key] - 获取字典中指定 key 对应的值（如果key不存在会报错）
“”"

dog = {"name": "财财", "age": 3, "breed": "土狗", "gender": "母", "weight": 10}
print(dog["name"])
print(dog["gender"])
print(dog["height"])        # 报错：KeyError: 'height'

b.
字典.get(key) - 获取字典中指定 key 对应的值（如果key不存在，不会报错，返回 None）
字典.get(key, 默认值) - 获取字典中指定 key 对应的值（如果key不存在，返回 默认值）

dog = {"name": "财财", "age": 3, "breed": "土狗", "gender": "母", "weight": 10}
print(dog.get("breed"))
print(dog.get("height"))        # None

print(dog.get("age", 0))        # 3
print(dog.get("height", 40))        # 40

2）遍历
“”"
a.需要掌握和使用的遍历方法（效率最高）

for 变量 in 字典：
    循环值

注意：变量取到的是字典中所有的key

dog = {"name": "财财", "age": 3, "breed": "土狗", "gender": "母", "weight": 10}
for x in dog:
    print(x, dog[x])

b.其他两种情况1（知道就行）

for 变量 in 字典.values():
    循环体

变量取到的是字典中的所有的值

for x in dog.values():
    print(x)

c.其他两种情况2（知道就行）

for 变量1, 变量2 in 字典.items():
    循环体

变量1能取到字典所有的key，变量2取到的是字典中所有的值

for x, y in dog.items():
    print(x, y)

练习1：声明一个变量，同时保存4个学生的信息（每个学生需要包含：姓名、年龄、电话、成绩）
练习2：统计上面4个学生中成年人未的个数

stu = {
    "张三": {"name": "张三", "age": 21, "phone": "12444", "score": 84},
    "李四": {"name": "李四", "age": 16, "phone": "13555", "score": 76},
    "王五": {"name": "王五", "age": 23, "phone": "15666", "score": 84},
    "周六": {"name": "周六", "age": 31, "phone": "19888", "score": 96}
}
print(stu["李四"])
count = 0
for x in stu.values():
    if x["age"] < 18:
        count += 1
print(count)

二、字典元素的增删改

1.增/改

语法1：
字典[key] = 值

如果key存在，就将key对应的值修改成指定的值（改）
如果key不存在，以"key:值"的形式添加一个键值对（增）

语法2：
字典.setdefault(键，值) - 添加键值对（不存在修改功能）

movie = {'name': '西游记', 'time': '1978-10-23', 'author': '吴承恩'}
print(movie)

改:

movie['time'] = '1989-10-25'
print(movie)

增

movie['score'] = 9.0
print(movie)

不会修改

movie.setdefault('score', 8.0)
print(movie)        # 'score': 9.0

可以增加

movie.setdefault('type', '神话')
print(movie)        # 'score': 9.0, 'type': '神话'

3.删

1）del
del 字典[key] - 删除指定key对应的键值对(key不存在会报错)

movie = {'name': '西游记', 'time': '1989-10-25', 'author': '吴承恩', 'score': 9.0, 'type': '神话'}
del movie['author']
print(movie)

2）pop
字典.pop(key) - 取出字典中指定key对应的值，并且返回被取出的值

value = movie.pop('type')
print(movie, value)

三、字典的相关操作和方法

1.字典相关操作
字典不支持加法和乘法运算
1）比较运算
字典只支持比较相等，不支持比较大小

print({'a': 1, 'b': 2} == {'b': 2, 'a': 1})     # True

2）in 和 not in

数据 in 字典 - 判断字典中是否存在指定的key
数据 not in 字典 - 判断字典中是否不存在指定的key

cat = {'name': '花花', 'gae': 2, 'color': '白色'}
print('name' in cat)      # True
print('花花' in cat)      # False

3）相关函数

a.
len(字典) - 统计字典中键值对的个数

cat = {'name': '花花', 'gae': 2, 'color': '白色'}
print(len(cat))     # 3

b.
dict(数据) - 将指定的数据转换成字典

数据的要求：1.是容器型数据类型 2.数据中的元素是有且只有两个元素的容器（小容器） 3.小容器中的第一个元素是不可变的

x = [(1, 2), (3, 4), [5, 6]]
dict1 = dict(x)
print(dict1)        # {1: 2, 3: 4, 5: 6}

x = ('ab', 'cd', 'xy')
dict2 = dict(x)
print(dict2)        # {'a': 'b', 'c': 'd', 'x': 'y'}

c.
字典转换成其他的数据类型
bool(字典) - 空字典会转换成False,其他都是 True
list(字典) - 将字典所有的key作为列表的元素
tuple(字典) - 将字典所有的key作为元组的元素

cat = {'name': '花花', 'gae': 2, 'color': '白色'}
print(list(cat))        # ['name', 'gae', 'color']

2.相关方法
1）clear
字典.clear() - 清空字典

cat.clear()
print(cat)      # {}

2）copy
字典.copy() - 复制字典产生一个新的字典并且返回

cat = {'name': '花花', 'gae': 2, 'color': '白色'}
cat1 = cat
cat1['name'] = '弟弟'
print(cat)      # {'name': '弟弟', 'gae': 2, 'color': '白色'}

cat = {'name': '花花', 'gae': 2, 'color': '白色'}
cat2 = cat.copy()
cat2['name'] = '弟弟'
print(cat)      # {'name': '花花', 'gae': 2, 'color': '白色'}

3）fromkeys

dict.fromkeys(序列) - 创建一个新的字典，字典的key是序列中的元素，值是 None
dict,fromkeys(序列，值) - 创建一个新的字典，字典的key是序列中的元素，值是指定的值

dict3 = dict.fromkeys('abc')
print(dict3)        # {'a': None, 'b': None, 'c': None}

stu = dict.fromkeys(['name', 'age', 'gender', 'tel', 'address', 'score'])
print(stu)

message = ['张三', '李四', '王五']
for name in message:
    new_stu = stu.copy()
    new_stu['name'] = name
    print(new_stu)

stu = dict.fromkeys(['name', 'age', 'gender', 'tel', 'address', 'score'], 0)
print(stu)

4）items, keys, values

字典.keys() - 获取字典所有的key，返回一个容器（这个容器不是列表）
字典.values() - 获取字典所有的值，返回一个容器（这个容器不是列表）
字典.items() - 获取字典所有的key和值，返回一个容器，容器中的元素是元组，每个元组对应一个键值对（这个容器不是列表）

cat = {'name': '花花', 'gae': 2, 'color': '白色'}
print(cat.keys())       # dict_keys(['name', 'gae', 'color'])
print(cat.values())     # dict_values(['花花', 2, '白色'])
print(cat.items())      # dict_items([('name', '花花'), ('gae', 2), ('color', '白色')])

5）update

字典.update(序列) - 用序列生成的字典去更新原字典（更新方式：不存在就添加，存在就修改）

dict4 = {'a': 10, 'b': 20, 'c': 30}
dict4.update({'a': 10, 'd': 40})
print(dict4)        # {'a': 10, 'b': 20, 'c': 30, 'd': 40}