9.Python基础数据类型之字典

Python基础数据类型之字典

字典（dict）
- 虽然列表可以存储大量数据，但由于列表的数据关联性不强，且列表的查询速度比较慢，因此产生了字典；
- 字典是另一种可变容器模型，且可存储任意类型对象。
- 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号{ }中 ,格式如下所示：
```
d = {key1 : value1, key2 : value2 }

# 字典实例
d = {"张三":{"年龄":18, "性别":"男"},"李四":{"年龄":20, "性别":"女"}}
```
  其中键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的数据类型，如字符串、数字、布尔值或元组。
- 数据类型的分类（按照可变与不可变进行分类）：
  - 可变（不可哈希）的数据类型：列表（list）、字典（dict）、集合（set）
  - 不可变（可哈希）的数据类型：字符串（str）、数值（int）、布尔值（bool）、元组（tuple）
字典特点
- 字典在Python 3.5版本及之前版本是无序的。而在Python 3.6版本以后，字典会按照初次建立的顺序排列，但学术上仍然认为Python字典不是有序的。在Python 3.7及以后版本中，字典都是有序的了。
- 字典的优点：字典查询速度非常快，比列表的查询速度要快的多。可以存储关联性数据。
- 字典的缺点：空间换时间。字典查询速度快的代价就是浪费空间。

字典的创建方式

创建一个空字典
```
d = dict()
```

方式一（元组的拆包）

d = dict((("one",1), ("two",2), ("three",3)))
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3}

方式二（键值对形式）

d = dict(one=1, two=2, three=3)
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3}

方式三（官方推荐）

d = dict({"one":1, "two":2, "three":3})
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3}

方式四（直接花括号）
```
d = {'one': 1, 'two': 2, 'three': 3}
```
方式五（dict.formkeys()：字典的键时来自一个可迭代的对象，把可迭代的对象每一个值当作一个键，所有的键共用一个值，正因为所有键都公用一个值，因此，当键值为可变数据类型时，一个键的值更改，其他键的值也会随着更改）
```
d = dict.fromkeys([1,2,3],"字典")
print(d)
# 输出结果：{1: '字典', 2: '字典', 3: '字典'}

d = dict.fromkeys([1,2,3],[6])
print(d)
d[1].append(666)
print(d)
'''
输出结果：
{1: [6], 2: [6], 3: [6]}
{1: [6, 666], 2: [6, 666], 3: [6, 666]}
'''
```
方式六

字典的增、删、改、查

增

方式一（直接增加）

d = {'one': 1, 'two': 2, 'three': 3}
d['four'] = 4
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3, 'four': 4}

# 如果增加的键值对的键与字典中的键重复，则新键值对会覆盖掉原有键值对，也叫“有则改之，无则增加”
d = {'one': 1, 'two': 2, 'three': 3}
d['one'] = 4
print(d)
# 输出结果：{'one': 4, 'two': 2, 'three': 3}

方式二（通过内置函数setdefault增加）

d = {'one': 1, 'two': 2, 'three': 3}
d.setdefault('four',4)
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3, 'four': 4}
# 如果增加的键值对的键与字典中的键重复，则新键值对不会覆盖掉原有键值对，也叫“有则不改，无则增加”

方式三（通过update方法增加）

d = {'one': 1, 'two': 2, 'three': 3}
d.update(four=4,five=5)
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}

方式四（通过update方法和元组的拆包增加）

d = {'one': 1, 'two': 2, 'three': 3}
d.update([('four',4),('five',5)])
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}

方式五（通过update将一个列表更新到另一个列表）

dict_1 = {'one': 1, 'two': 2, 'three': 3}
dict_2 = {'one': 0, 'four': 4}
dict_1.update(dict_2)
print(dict_1)
# 输出结果：{'one': 0, 'two': 2, 'three': 3, 'four': 4}
# update()方法特点：有则改之，无则增加

删

方式一（通过内置函数pop进行删除）（推荐使用此方式）

d = {'one': 1, 'two': 2, 'three': 3}
d.pop('three')
print(d)
# 输出结果：{'one': 1, 'two': 2}
# 所有删除方法，只有pop有返回值，返回的值是删除的值

# 当不确定删除的键值在不在字典中，为了防止报错，可以在删除的简直后面增加一个空键值，如果没有要删除的键值，不会报错
d = {'one': 1, 'two': 2, 'three': 3}
d.pop('four',"")
print(d)
# 输出结果：{'one': 1, 'two': 2, 'three': 3}

方式二（通过del方式删除）

d = {'one': 1, 'two': 2, 'three': 3}
del d['two']
print(d)
# 输出结果：{'one': 1, 'three': 3}
# 如果删除的键字典中没有会报错，因此不推荐此方法

方式三（通过内置函数clear清空字典，并非删除字典）

d = {'one': 1, 'two': 2, 'three': 3}
d.clear()
print(d)
# 输出结果：{}

改

方式一（直接改）

d = {'one': 1, 'two': 2, 'three': 3}
d['one'] = 4
print(d)
# 输出结果：{'one': 4, 'two': 2, 'three': 3}

方式二（通过update方法改）

d = {'one': 1, 'two': 2, 'three': 3}
d.update(one=4)
print(d)
# 输出结果：{'one': 4, 'two': 2, 'three': 3}

查

方式一（直接查，不推荐）

d = {'one': 1, 'two': 2, 'three': 3}
print(d['three'])
# 输出结果：3
# 如果查询的键字典中没有会报错，因此不推荐此方法

方式二（通过内置函数get查询）

d = {'one': 1, 'two': 2, 'three': 3}
d1 = d.get('two')
print(d1)
# 输出结果：2
# # 如果查询的键字典中没有也不会报错，默认返回值是None，返回值可以设置，因此推荐此方法

d = {'one': 1, 'two': 2, 'three': 3}
d1 = d.get('four', '没有此键')
print(d1)
# 输出结果：没有此键

通过内置方法 keys() 查询字典内所有的键

d = {'one': 1, 'two': 2, 'three': 3}
print(d.keys())
# 输出结果：dict_keys(['one', 'two', 'three'])

# 此方式可将键名称转换成列表
print(list(d.keys()))
# 输出结果：['one', 'two', 'three']

# 也可以通过for循环列出所有的键
d = {'one': 1, 'two': 2, 'three': 3}
for key in d:
    print(i)
'''
输出结果：
one
two
three
'''

通过内置方法 values() 查询字典内所有的值

d = {'one': 1, 'two': 2, 'three': 3}
print(d.values())
# 输出结果：dict_values([1, 2, 3])

# 同理，也可以转换成列表及使用for循环列出所有的值

通过内置方法 item() 查询所有的键值对

d = {'one': 1, 'two': 2, 'three': 3}
print(d.items())
# 输出结果：dict_items([('one', 1), ('two', 2), ('three', 3)])

# 将键值对转换成列表
d = {'one': 1, 'two': 2, 'three': 3}
print(list(d.items()))
# 输出结果：[('one', 1), ('two', 2), ('three', 3)]

# 使用for循环列出所有的键值对（使用到了元组的拆包）
d = {'one': 1, 'two': 2, 'three': 3}
for key,value in d.items():
    print(key,value)
'''
输出结果：
one 1
two 2
three 3
'''

字典的嵌套

d = {
    '姓名': '张三',
    '性别': '男',
    '配偶':{'姓名': '李四', '性别': '女'},
    '联系方式':[{'手机':12345678, '电话':123456},]
    }

获取张三的名字
```
print(d.get('姓名'))
```
获取联系方式中的字典
```
print(d.get('联系方式')[0])
```

获取手机号

print(d.get('联系方式')[0].get('手机'))

获取配偶的姓名
```
print(d.get('配偶').get('姓名'))
```

字典的for循环

循环一个字典时，如果改变字典的大小（增加或删除元素），就会报错。

# 将下面字典中所有含t的键值对删掉如何处理呢？
# 首先我们会想到，循环字典，判断字典的键是否含有"t"，可循环字典时改变字典大小就会报错。
# 那么，我们换种思路，不循环字典时删除键值就好了，只要找到满足有两种方法。

# 方法一：先for循环字典，将满足条件的键放入到一个列表中，然后循环列表，删除满足条件的键值
d = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
l = []
for key in d:
    if 't' in key:
        l.append(key)
for i in l:
    d.pop(i)
print(d)
# 输出结果：{'one': 1, 'four': 4}

# 方法二：通过内置方法keys()生成字典中所有键的列表，然后通过循环键的列表删除满足条件的键值
d = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
l = list(d.keys()) # 由于d.keys()生成的列表仍与字典d有关系，直接循环删键值对仍然会报错，因此创建一个新的列表
for key in l:
    if 't' in key:
        d.pop(key)
print(d)

字典推导式

# 将两个列表通过一行代码生成一个字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]

dic = {keys[i]:values[i] for i in range(len(keys))}

print(dic)    # {'a': 1, 'b': 2, 'c': 3}

9.Python基础数据类型之字典

你可能感兴趣的:(9.Python基础数据类型之字典)