Python（9）字典和集合

字典是Python中唯一实现映射关系的内置类型

什么是映射关系

类似于摩斯密码

部分摩斯密码表

其中 A 和._就是一对映射关系 K和._.又是另一对映射关系

字典基本使用

可 hash 的值才能作为 key

一般来说不可变的都可hash 可变的都不可哈希

创建

直接创建

# 字典由 {} key : value组成
x = {"key": "value"}
print(x, type(x))  # {'key': 'value'} 
1
2
3

fromkeys

# 也是一种创建字典的方式 第一个参数是一个可迭代对象，第二个参数是默认值
x = dict.fromkeys("abcd", 123)
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123}

1
2
3
4

查询

# 字典由 {} key : value组成
x = {"吕布": "lb", "关羽": "gy", "张飞": "zf"}

# 输入kye就可以查出对应的value
print(x['吕布'])  # lb
1
2
3
4
5

get()

如果字典中没有对应key那么回返回你指定的默认值，不会报错

x = dict.fromkeys("abcd", 123)
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123}

# 如果字典中没有对应key那么回返回你指定的默认值，不会报错
print(x.get('a', '没有'))  # 123
print(x.get('e', '没有'))  # 没有

1
2
3
4
5
6
7

setdefault()

如果字典中有key则返回，如果没有则新增对应key后返回

x = dict.fromkeys("abcd", 123)
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123}

# 如果字典中有key则返回，如果没有则新增对应key后返回
print(x.setdefault('a', 456))  # 123
print(x.setdefault('e', 456))  # 456
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123, 'e': 456}
1
2
3
4
5
6
7

添加和修改

# 字典由 {} key : value组成
x = {"吕布": "lb", "关羽": "gy", "张飞": "zf"}

# 指定一个key，并给其赋值。如果key不在原字典中则可以实现新增的功能
x['刘备'] = "lb"
print(x)  # {'吕布': 'lb', '关羽': 'gy', '张飞': 'zf', '刘备': 'lb'}

# 如果这个key已经存在于原本的字典中，那么就可以实现修改的操作
x['刘备'] = "lb2"
print(x)  # {'吕布': 'lb', '关羽': 'gy', '张飞': 'zf', '刘备': 'lb2'}
1
2
3
4
5
6
7
8
9
10

修改还可以使用 update()

x = dict.fromkeys("abcd", 123)
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123}

# 传入另一个字典
x.update({"a": 456, "d": 789})
print(x)  # {'a': 456, 'b': 123, 'c': 123, 'd': 789}

# 将key当参数传入
x.update(a=147, d=258)
print(x)  # {'a': 147, 'b': 123, 'c': 123, 'd': 258}

1
2
3
4
5
6
7
8
9
10
11

删

# 也是一种创建字典的方式 第一个参数是一个可迭代对象，第二个参数是默认值
x = dict.fromkeys("abcd", 123)
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123}

# 删除指定键值对
x.pop('a')
print(x)  # {'b': 123, 'c': 123, 'd': 123}

# 3.7之后是删除最后一个加进来的键值对，3.7之前是随机的，因为3.7之前字典是无序的
x.popitem()
print(x)  # {'b': 123, 'c': 123}

# 清空字典
x.clear()
print(x)  # {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

items()、keys()、values()

分别用于获取 键值对、健和值的视图对象

视图对象:

视图对象是字典的动态视图，这就意味着当字典的内容发生改变的时候，视图对象的内容也会相应的跟着改变

如下所示

x = dict.fromkeys("abcd", 123)
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123}

items = x.items()
keys = x.keys()
values = x.values()

print(items)  # dict_items([('a', 123), ('b', 123), ('c', 123), ('d', 123)])
print(keys)  # dict_keys(['a', 'b', 'c', 'd'])
print(values)  # dict_values([123, 123, 123, 123])

# 删除key a
x.pop('a')
# 再次输出发现字典的动态视图也发生了改变
print(x)  # {'b': 123, 'c': 123, 'd': 123}
print(items)  # dict_items([('b', 123), ('c', 123), ('d', 123)])
print(keys)  # dict_keys(['b', 'c', 'd'])
print(values)  # dict_values([123, 123, 123])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

其他方法

x = dict.fromkeys("abcd", 123)
print(x)  # {'a': 123, 'b': 123, 'c': 123, 'd': 123}

# 生成迭代器 iter()
e = iter(x.items())
# e = iter(x.values())
# e = iter(x.keys())
for i in e:
    print(i)
    """
        ('a', 123)
        ('b', 123)
        ('c', 123)
        ('d', 123)
    """

# 字典反转 reversed
a = dict(reversed(x.items()))
print(a)  # {'d': 123, 'c': 123, 'b': 123, 'a': 123}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

字典的嵌套

字典套字典

x = {"吕布": {"数学": 50, "语文": 80, "英语": 20}, "关羽": {"数学": 80, "语文": 70, "英语": 60}, "张飞": {"数学": 10, "语文": 20, "英语": 10}}

# 查询吕布的数学成绩
print(x['吕布']['数学'])  # 50
1
2
3
4

字典套列表

x = {"吕布": [50, 60, 70], "关羽": [60, 80, 90], "张飞": [10, 20, 10]}

# 查询吕布第一科成绩
print(x['吕布'][0])  # 50
1
2
3
4

字典推导式

a = {'a': 123, 'b': 456, 'c': 789}

# 字典推导式实现key和value互换位置
b = {v: k for k, v in a.items()}
print(b)  # {123: 'a', 456: 'b', 789: 'c'}
1
2
3
4
5

集合

集合内的元素是无序的是唯一的

集合可以是可变的可以是不可变的

set()可变 frozenset() 不可变