Python教程017 标准数据类型 字典dict

字典dict定义

字典是一种映射类型，字典用{}标识，它是一个无序的键(key) : 值(value)的集合。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典可以用多种方式构建:

使用一对大括号表示空字典: {}
使用大括号，用逗号分隔的key:value对: {‘a’:1,‘b’:2}
使用类型构造函数: dict() 或 dict(iterable)

例如：

1
2
3
4
5
6
7
8
9


d1 = {'a':1,'b':2,'c':3}  # 字典d1有三个元素，分别是键值对'a':1，键值对'b':2，键值对'c':3
d2 = {}                   # d2是空字典。
d3 = dict()               # 构造函数生成空字典
d4 = dict(a=1,b=2,c=3)    # 构造函数生成字典

print(d1)
print(d2)
print(d3)
print(d4)

执行以上程序会输出如下结果：

1
2
3
4


{'a': 1, 'b': 2, 'c': 3}
{}
{}
{'a': 1, 'b': 2, 'c': 3}

其中，用逗号分割的字典，最后一个逗号是可选的。
{‘a’:1,‘b’:2,‘c’:3} 和 {‘a’:1,‘b’:2,‘c’:3,}都是合法的字典。

构造函数dict()可以直接从键值对序列中构建字典如下：

1
2


>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}

字典推导

除了上面介绍的方法生成字典外，还可以使用字典推导来生成字典。推导comprehensions（又称解析式），是Python的一种独有特性。推导是可以从一个数据序列构建另一个新的数据序列的结构体。字典推导就是利用其他数据序列构建字典。

字典推导语法：
{ x:y for x,y in iterable if 条件}

其中if语句是可以省略的。

例如：

1
2
3
4
5


L = [(1,"a"),(2,"b"),(3,"c")]
d1 = {x:y for x,y in L}
d2 = {x:y for x,y in L if x < 3}
print(d1)
print(d2)

执行以上程序会输出如下结果：

1
2


{1: 'a', 2: 'b', 3: 'c'}
{1: 'a', 2: 'b'}

索引操作

字典支持索引来获取值，修改值或者添加键值对。

d[key]
返回key指定的值。如果键不在字典中，则引发keyError。

d[key] = value
将d[key]设置为value。

del d[key]
从d中删除d[key]。如果键不在字典中，则会引发KeyError。

例如：

1
2
3
4
5
6
7
8


d = {'name': 'jack', 'age': 22,1:100}
print(d)             # 打印字典d
print(d['name'])     # 输出键为 'name' 的值
print(d[1])          # 输出键为1的值
d['name'] = 'bruce'  # 键为 'name' 的值修改为'bruce'
print(d)             # 打印修改后的字典d
d[2] = 200           # 添加键值对2:200
print(d)             # 打印添加键值对后的字典d

执行以上程序会输出如下结果：

1
2
3
4
5


{'name': 'jack', 'age': 22, 1: 100}
jack
100
{'name': 'bruce', 'age': 22, 1: 100}
{'name': 'bruce', 'age': 22, 1: 100, 2: 200}

引用不存在的key，会引发keyError异常。例如：

1
2


d = {'name': 'jack', 'age': 22, 1:100}
print(d[3]) # 不存在键为3的键值对，引发keyError。

错误如下

1
2
3
4


Traceback (most recent call last):
  File "main.py", line 2, in <module>
    print(d[3]) #不存在键为3的键值对，引发keyError。
KeyError: 3

键(key)必须是可哈希的，也就是不可变类型。在同一个字典中，键(key)必须是唯一的。不可哈希的值，包括列表、字典或其他可变类型（按值而不是按对象标识进行比较）的值不能用作键。
d = {'name': 'jack', 'age': 22,['a']:100}
[‘a’]用作字典的键，报出以下错误。

1
2
3


Traceback (most recent call last):
  File "main.py", line 1, in <module>
    d = {'name': 'jack', 'age': 22,['a']:100} TypeError: unhashable type: 'list'

如果两个数字比较相等（如1和1.0），则可以互换使用它们来索引同一字典条目。（但是请注意，由于计算机将浮点数字存储为近似值，因此将它们用作字典键通常是不明智的。）

例如：

1
2
3


d = {1:100}   # 字典d，有一个键值对1:100。
d[1.0] = 200  # 添加键值对1.0:200。 由于整数1和浮点数1.0的值是相等的，所以d[1]和d[1.0]指向同一个值。
print(d)      # 结果是{1: 200}。

测试字典key是否存在。 key in d d如果存在key，返回True，否则返回False。

key not in d 相当于not key in d.

1
2
3
4
5


d = {'name': 'jack', 'age': 22,1:100}
if 'name' in d:
    print('字典d中存在name键')
else:
    print('字典d中不存在name键')

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：二是通过dict提供的get方法，如果key不存在，可以返回None，或者指定的value： d = {‘Michael’: 95, ‘Bob’: 75, ‘Tracy’: 85} d.get(‘Bruce’) #字典d中不存在键为Bruce的键值对，结果为None d.get(‘Thomas’, -1) #字典d中不存在键为Thomas的键值对，结果为-1

字典支持的方法

clear()

从字典中删除所有项，返回None。

例如：

1
2
3


d = {"one": 1, "two": 2, "three": 3, "four": 4}
d1 = d.clear()  # None
print(d)        # 空字典{}

get(key[, default])

如果键在字典中，则返回键的值，否则为返回默认值default。如果未给定默认值default，则默认为None，因此不会引发KeyError。

items()

返回字典项(key, value) 视图。

例如：

1
2
3
4
5


d = {"one": 1, "two": 2, "three": 3, "four": 4}
d1 = d.items()   # 字典项(key, value) 视图
print(type(d1))  # 打印d1的类型
print(d1)        # 打印的d1内容
print(d)

执行以上程序会输出如下结果：

1
2
3


<class 'dict_items'>
dict_items([('one', 1), ('two', 2), ('three', 3), ('four', 4)])
{'one': 1, 'two': 2, 'three': 3, 'four': 4}

keys()

返回字典键的视图。

例如：

1
2
3
4
5


d = {"one": 1, "two": 2, "three": 3, "four": 4}
d1 = d.keys()     # 字典键视图
print(type(d1))   # 打印d1的类型
print(d1)         # 打印的d1内容
print(d)

执行以上程序会输出如下结果：

1
2
3


<class 'dict_keys'>
dict_keys(['one', 'two', 'three', 'four'])
{'one': 1, 'two': 2, 'three': 3, 'four': 4}

pop(key[, default])

如果键在字典中，则将其移除并返回其值。如果键不存在，返回默认值default。如果没有给定默认值，并且字典中没有键，则会引发KeyError。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


d = {"one": 1, "two": 2, "three": 3, "four": 4}
d1 = d.pop("one")
print(d1)  #打印的d1内容
print(d)
d2 = d.pop("three",300)
print(d2)  #打印的d2内容
print(d)
d3 = d.pop("Five",500)
print(d3)  #打印的d3内容
print(d)

执行以上程序会输出如下结果：

1
2
3
4
5
6


1
{'two': 2, 'three': 3, 'four': 4}
3
{'two': 2, 'four': 4}
500
{'two': 2, 'four': 4}

以下程序会报错，引发KeyError。

1
2


d = {"one": 1, "two": 2, "three": 3, "four": 4}
d1 = d.pop("Five")  # 键"Five"不存在，并且没有给出默认值

错误信息如下。

1
2
3
4


Traceback (most recent call last):
  File "main.py", line 2, in <module>
    d1 = d.pop("Five")  
KeyError: 'Five'

popitem()

从字典中删除并返回(key, value)对元组。按后进先出LIFO顺序返回。

例如：

1
2
3
4
5
6
7
8
9


d = {}
d["one"]=1
d["two"]=2
d["three"]=3
d["four"]=4
d1 = d.popitem()
print(type(d1))  # 打印的d1类型
print(d1)        # 打印的d1内容
print(d)

执行以上程序会输出如下结果：

1
2
3


<class 'tuple'>
('four', 4)
{'one': 1, 'two': 2, 'three': 3}

(‘four’, 4)键值对是最后被添加的，按照LIFO原则，也是最先被删除的。

如果字典为空，则引发KeyError。

例如：

1
2


d = {}
d1 = d.popitem()

空字典报以下错误。

1
2
3
4


Traceback (most recent call last):
  File "main.py", line 2, in <module>
    d1 = d.popitem()
KeyError: 'popitem(): dictionary is empty'

setdefault(key[, default])

如果键在字典中，则返回其值。如果键不存在，则插入值为default的键值对，不存在default，则值为None。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


d = {"one": 1, "two": 2, "three": 3, "four": 4}
d1 = d.setdefault("one",100)   #键"one"存在，返回其值1
print(d1)  #打印的d1内容
print(d)
d2 = d.setdefault("five",5)  #键"five"不存在，且给出了值5，添加键值对five:5
print(d2)  #打印的d2内容
print(d)
d3 = d.setdefault("six")   #键"six"不存在，且没有给出值，添加键值对six:None
print(d3)  #打印的d3内容
print(d)

执行以上程序会输出如下结果：

1
2
3
4
5
6


1
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
5
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
None
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': None}

update([other])

使用key/value对更新字典，覆盖现有键。返回值为None。update()接受另一个字典对象或key/value对的iterable（长度为2的元组或其他iterable）。如果指定了关键字参数，则字典将使用这些键/值对进行更新：d.update(red=1, blue=2).

例如：

1
2
3
4
5
6
7
8
9


d = {"one": 1, "two": 2, "three": 3, "four": 4}
l = [("one",11),("two",22)]  #列表l有2个成员，每个成员都是长度为2的元组
d1 = d.update(l)
print(d1)  #打印的d1内容
print(d)
d2 = {"five": 5}
d3 = d.update(d2)
print(d3)  #打印的d3内容
print(d)

执行以上程序会输出如下结果：

1
2
3
4


None
{'one': 11, 'two': 22, 'three': 3, 'four': 4}
None
{'one': 11, 'two': 22, 'three': 3, 'four': 4, 'five': 5}

values()

返回字典值的视图。

例如：

1
2
3
4
5


d = {"one": 1, "two": 2, "three": 3, "four": 4}
d1 = d.values()  # 字典值视图
print(type(d1))  # 打印d1的类型
print(d1)        # 打印的d1内容
print(d)

执行以上程序会输出如下结果：

1
2
3


<class 'dict_values'>
dict_values([1, 2, 3, 4])
{'one': 1, 'two': 2, 'three': 3, 'four': 4}

只有当字典具有相同的（键、值）对时，字典才会比较相等。顺序比较（“<”、“<=”、“>=”、“>”）引发TypeError类型错误。词典保留插入顺序。请注意，更新密钥不会影响顺序。删除后添加的键将插入到末尾。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

set集合和字典类似，一组key的集合，但不存储value。由于key不能重复set中没有重复值。

转载请注明本网址。

Python教程017 标准数据类型字典dict

文章目录

字典dict定义

字典推导

索引操作

字典支持的方法

clear()

get(key[, default])

items()

keys()

pop(key[, default])

popitem()

setdefault(key[, default])

update([other])

values()