Python dict 字典

目录

dict字典

创建字典

使用 { } 创建字典

通过 fromkeys() 方法创建字典

通过 dict() 映射函数创建字典

访问字典

删除字典

dict字典基本操作

字典添加键值对

字典修改键值对

字典删除键值对

判断字典中是否存在指定键值对

字典其他常用方法

查看dict的函数:

清空：

keys()、values() 和 items() 方法

copy() 方法

update() 方法

pop() 和 popitem() 方法

setdefault() 方法

使用字典格式化字符串

---

dict字典

字典类型是 Python 中唯一的映射类型。字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。

创建字典

使用 { } 创建字典

字典中每个元素都包含两部分，分别是键（key）和值（value），创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。

dictname = { 'key' : 'value1' ,  'key2 ': 'value2' , ...,  'keyn' : valuen }

dir = {"num1":"这里是1号","num2":2,"num3":["我是",4,"号"]}

print type(dir)
print(dir)

结果：

<class 'dict'>

{'num1': '这里是1号', 'num2': 2, 'num3': ['我是', 4, '号']}

通过 fromkeys() 方法创建字典

dictname = dict.fromkeys(list，value=None)

其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。

#用元组同理
name = ["num1","num2","num3"]
content = ["这里是1号",2,["我是",4,"号"]]


dictionary = dict.fromkeys(name,content)

print(dictionary)

结果：

{'num1': ['这里是1号', 2, ['我是', 4, '号']], 'num2': ['这里是1号', 2, ['我是', 4, '号']], 'num3': ['这里是1号', 2, ['我是', 4, '号']]}

通过 dict() 映射函数创建字典

dict() 函数创建字典

创建格式	注意事项
a = dict(str1=value1, str2=value2, str3=value3)	str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号。
#方式1 demo = [('two',2), ('one',1), ('three',3)] #方式2 demo = [['two',2], ['one',1], ['three',3]] #方式3 demo = (('two',2), ('one',1), ('three',3)) #方式4 demo = (['two',2], ['one',1], ['three',3]) a = dict(demo)	向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。
keys = ['one', 'two', 'three'] #还可以是字符串或元组 values = [1, 2, 3] #还可以是字符串或元组 a = dict( zip(keys, values) )	通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。

注意，无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键。

demo1 = [('two',2), ('one',1), ('three',3)]
a = dict(demo1)
print(a)

demo2 = [['two',2], ['one',1], ['three',3]]
a = dict(demo2)
print(a)

demo3 = (('two',2), ('one',1), ('three',3))
a = dict(demo3)
print(a)

demo4 = (['two',2], ['one',1], ['three',3])
a = dict(demo4)
print(a)

keys = ['one', 'two', 'three']
values = [1, 2, 3]
a = dict( zip(keys, values) )
print(a)

结果都为：

{'one': 1, 'two': 2, 'three': 3}

如果不为 dict() 函数传入任何参数，则代表创建一个空的字典

# 创建空的字典
d = dict()

print(d)

运行结果为：

{}

访问字典

Python 访问字典元素的具体格式为：

dictname[key]

其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

demo1 = [('two',2), ('one',1), ('three',3)]
a = dict(demo1)

two = a['two']
print(two)

结果：

2

Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。

get() 方法的语法格式为：

dictname.get(key[,default])

其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

demo1 = [('two',2), ('one',1), ('three',3)]
a = dict(demo1)

two = a.get('two')
print(two)

four = a.get("four","不存在four")
print(four)

结果：

2
不存在four

删除字典

删除列表、元组一样，手动删除字典也可以使用 del 关键字

del dictname

dict字典基本操作

字典添加键值对

为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：

dictname[key] = value

对各个部分的说明：

• dictname 表示字典名称。
• key 表示新的键。
• value 表示新的值，只要是 Python 支持的数据类型都可以。

a = {'数学':95}
print(a)

#添加新键值对
a['语文'] = 89
print(a)

#再次添加新键值对
a['英语'] = 90
print(a)

运行结果：
{'数学': 95}
{'数学': 95, '语文': 89}
{'数学': 95, '语文': 89, '英语': 90}

字典修改键值对

Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。

字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。

a = {'数学': 95, '语文': 89, '英语': 90}
print(a)

a['语文'] = 100
print(a)

运行结果：

{'数学': 95, '语文': 89, '英语': 90}
{'数学': 95, '语文': 100, '英语': 90}

字典删除键值对

使用 del 语句.

#使用del语句删除键值对
a = {'数学': 95, '语文': 89, '英语': 90}

del a['语文']
del a['数学']

print(a)

运行结果为：

{'英语': 90}

判断字典中是否存在指定键值对

首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。

需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

a = {'数学': 95, '语文': 89, '英语': 90}

# 判断 a 中是否包含名为'数学'的key
print('数学' in a) # True

# 判断 a 是否包含名为'物理'的key
print('物理' in a) # False

运行结果为：

True
False

字典其他常用方法

查看dict的函数:

dir(dict)

demo1 = [('two',2), ('one',1), ('three',3)]
a = dict(demo1)

print(dir(dict))
print(a)

结果：

['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

{'two': 2, 'one': 1, 'three': 3}

清空：

clear(dictname)

demo1 = [('two',2), ('one',1), ('three',3)]
a = dict(demo1)

print(a)

print(a.clear())
print(a)

结果：

{'two': 2, 'one': 1, 'three': 3}

None

{}

keys()、values() 和 items() 方法

它们都用来获取字典中的特定数据：

• keys() 方法用于返回字典中的所有键（key）；
• values() 方法用于返回字典中所有键对应的值（value）；
• items() 用于返回字典中所有的键值对（key-value）。

scores = {'数学': 95, '语文': 89, '英语': 90}

print(scores.keys())
print(scores.values())
print(scores.items())

运行结果：

dict_keys(['数学', '语文', '英语'])

dict_values([95, 89, 90])

dict_items([('数学', 95), ('语文', 89), ('英语', 90)])

keys()、values() 和 items() 返回值的类型分别为 dict_keys、dict_values 和 dict_items。

使用 list() 函数，将它们返回的数据转换成列表，例如：

a = {'数学': 95, '语文': 89, '英语': 90}
b = list(a.keys())

print(b)

运行结果为：

['数学', '语文', '英语']

使用 for in 循环遍历它们的返回值，例如：

a = {'数学': 95, '语文': 89, '英语': 90}

for k in a.keys():
    print(k,end=' ')
print("\n---------------")

for v in a.values():
    print(v,end=' ')
print("\n---------------")

for k,v in a.items():
    print("key:",k," value:",v)

运行结果为：

数学 语文 英语
---------------
95 89 90
---------------
key: 数学  value: 95
key: 语文  value: 89
key: 英语  value: 90

copy() 方法

copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典，例如：

a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()

print(b)

运行结果为：

{'one': 1, 'two': 2, 'three': [1, 2, 3]}

注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。

拿拷贝字典 a 为例，copy() 方法只会对最表层的键值对进行深拷贝，也就是说，它会再申请一块内存用来存放 {'one': 1, 'two': 2, 'three': []}；

而对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，b 中的 [1,2,3] 的值不是自己独有，而是和 a 共有。

a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()

#向 a 中添加新键值对，由于b已经提前将 a 所有键值对都深拷贝过来，因此 a 添加新键值对，不会影响 b。
a['four']=100
print(a)
print(b)

#由于 b 和 a 共享[1,2,3]（浅拷贝），因此移除 a 中列表中的元素，也会影响 b。
a['three'].remove(1)
print(a)
print(b)

运行结果为：
{'one': 1, 'two': 2, 'three': [1, 2, 3], 'four': 100}
{'one': 1, 'two': 2, 'three': [1, 2, 3]}
{'one': 1, 'two': 2, 'three': [2, 3], 'four': 100}
{'one': 1, 'two': 2, 'three': [2, 3]}

update() 方法

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。

在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；

如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

a = {'one': 1, 'two': 2, 'three': 3}
a.update({'one':4.5, 'four': 9.3})

print(a)

运行结果为：

{'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3}

pop() 和 popitem() 方法

pop() 和 popitem() 都用来删除字典中的键值对，不同的是，

pop() 用来删除指定的键值对，

popitem() 用来随机删除一个键值对（popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了“出栈”的操作。），

它们的语法格式如下：

dictname.pop(key)
dictname.popitem()

其中，dictname 表示字典名称，key 表示键。

a = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
print(a)

a.pop('化学')
print(a)

a.popitem()
print(a)

运行结果：

{'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98}

setdefault() 方法

setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：

dictname.setdefault(key, defaultvalue)

说明，dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，不写的话是 None）。

当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。

也就是说，setdefault() 方法总能返回指定 key 对应的 value：

• 如果该 key 存在，那么直接返回该 key 对应的 value；
• 如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。

a = {'one': 1, 'two': 2, 'three': [1,2,3]}

print(a.setdefault("two",1))
print(a.setdefault("four",1))

结果：

2
1

使用字典格式化字符串

在字符串模板中按 key 指定变量，然后通过字典为字符串模板中的 key 设置值。
 

#字符串模板中使用key
temp = '你好啊，我是:%(name)s, 体重是是:%(weight)4.2f, 身高是:%(height)d'

info = {'name':'小明', 'weight': 132.1, 'height': 178.3}

# 使用字典为字符串模板中的key传入值
print(temp % info)

info = {'name':'小红', 'weight':100.2, 'height': 165}

# 使用字典为字符串模板中的key传入值
print(temp % info)
print(temp , info)

结果：

你好啊，我是:小明, 体重是是:132.10, 身高是:178
你好啊，我是:小红, 体重是是:100.20, 身高是:165
你好啊，我是:%(name)s, 体重是是:%(weight)4.2f, 身高是:%(height)d {'name': '小红', 'weight': 100.2, 'height': 165}

哈希表插入数据

当向字典中插入数据时，Python 会首先根据键（key）计算出对应的哈希值（通过 hash(key) 函数），而向集合中插入数据时，Python会根据该元素本身计算对应的哈希值（通过 hash(valuse) 函数）。

dic = {"name":1}

print(hash("name"))
print(hash(1))

结果：

1459844957350668614 #该取值随机
1

得到哈希值（例如为 hash）之后，再结合字典或集合要存储数据的个数（例如 n），就可以得到该元素应该插入到哈希表中的位置（比如，可以用 hash%n 的方式）。

如果哈希表中此位置是空的，那么此元素就可以直接插入其中；反之，如果此位置已被其他元素占用，那么 Python 会比较这两个元素的哈希值和键是否相等：

• 如果相等，则表明该元素已经存在，再比较他们的值，不相等就进行更新；
• 如果不相等，这种情况称为哈希冲突（即两个元素的键不同，但求得的哈希值相同）。这种情况下，Python 会使用开放定址法、再哈希法等继续寻找哈希表中空余的位置，直到找到位置。