py 字典添加多个value_Python序列--字典（dict）

字典

字典是另一种可变序列，且可存储任意类型对象。

不过与列表不同，字典是无序的可序列表，保存的内容是以'键-值对'的形式存放的。

把它想象成新华字典，新华字典的音节表相当与键(key)，而对应的汉字，相当于值(value)。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中

语法格式：

d = {'key1' : 'value1', 'key2' : 'value2',...,'keyn'：'valuen', }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

字典的主要特征：

1.通过键而不是索引来读取。

字典有时也被称为关联数组或者散列表(hash)。它是通过键将一系列的值联系在一起，通过建来获取指定项，但是不能通过索引来获取。

2.字典是任意对象的无序集合。

字典是无序的，各项是从左向右随机排序，即保存在字典的项都没有特定的排序，

3.字典是可变的，并且可以任意嵌套。

字典可以在原处增长或者缩短(无需生成一个副本)并且支持任意深度的嵌套(即它的值可以是列表或者其他字典)

4.字典的键必须唯一

不允许同一个键出现两次，如果出现两次，则最后一个值被记住。

字典的键必须不可变

字典的键是不可变的，所以可以使用数字，字符串或者元组，但是不能使用列表。

同列表和元组一样，也可以创建空字典。

语法格式：

dictionary = {} 或者 dictionary = dict()

还可以通过已有的数据快速创建字典。

.用过映射函数创建字典

语法格式： dictionary = dict(zip(list1,list2))

# dictionary : 表示字典名称。

# zip()函数： 用于将多个列表或者元组对应位置的元素组合为元组，并返回包含这些内容的zip对象。

如果想获取元组，可以将zip对象使用tuple()函数转换为元组。

如果想获取列表，可以使用list()函数将其转换为列表。

# list1: 一个列表，用于指定要生成的字典的键。

# list2: 一个列表，用于指定要生成的字典的值。

(如果list1和list2的长度不同，则与最短的列表长度相同)

例：

name = ['绮梦','冷伊一','香凝','黛兰'] # 作为键的列表

sign = ['水瓶座','射手座','双鱼座','双子座'] # 作为值的列表

dictionary = dict(zip(name,sign)) # 转换为字典

print(dictionary) # 输出转换后字典

输出：

{'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

访问字典里的值

想将字典内容输出可以直接使用print()函数。

但是一般在使用字典时，很少直接输出内容。一般需要根据指定的键来得到对应的结果。

把相应的键放入到方括号中，如下实例:

实例

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print ("dict['Name']: ", dict['Name'])

print ("dict['Age']: ", dict['Age'])

以上实例输出结果：

dict['Name']: Runoob

dict['Age']: 7

！！！如果用字典里没有的键访问数据，会输出错误！！！

实例

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print ("dict['Alice']: ", dict['Alice'])

以上实例输出结果：

Traceback (most recent call last):

File "test.py", line 5, in

print ("dict['Alice']: ", dict['Alice'])KeyError: 'Alice'

实例：

name = ['绮梦','冷伊一','香凝','黛兰']

sign=['水瓶座','射手座','双鱼座','双子座']

dictionary = dict(zip(name,sign))

print(dictionary)

print(dictionary['黛兰'])

输出：

{'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

双子座

在实际开发中或许会遇到查询的键不存在，可以使用if语句对不存在的情况进行处理，即设置一个默认值。

实例：

dictionary = {'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

print("梦的星座是：",dictionary['梦'] if '梦' in dictionary else '查无此人')

输出：

梦的星座是： 查无此人

使用字典对象的get()方法来获取指定键的值：

语法格式：dictionary.get([,default])

# dictionary ：为字典对象，既要从中获取值的字典。

# key ：为指定的键。

# default ：为可选项，用于指定当指定的'键'不存在时，返回一个默认值。如果省略则返回None。

例：

dictionary = {'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

print("绮梦的星座是：",dictionary.get('绮梦'))

输出：

绮梦的星座是： 水瓶座

也可以使用get()方法来防止在获取指定键的值时，因不存在该键而出现的异常，可以为get()方法设置默认值，这样当指定的键不存在时，得到的结果是指定的默认值。

例：

dictionary = {'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

a = input('查询：')

print(a,"的星座是：",dictionary.get(a,'查无此人'))

输出：

查询：绮梦

绮梦 的星座是： 水瓶座

当查询的键不存在时：

dictionary = {'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

a = input('查询：')

print(a,"的星座是：",dictionary.get(a,'查无此人'))

输出：

查询：梦

梦 的星座是： 查无此人

修改字典

1.添加新内容的方法是增加新的键/值对修改已有键/值对

语法格式：dictionary[key] = value

# dictionary：字典名称

# key：表示要添加的元素的键，必须是唯一，并且不可变的。

# value：表示元素的值，可以是任何数据类型，不是必须唯一。

例：

dictionary = {'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

dictionary['君'] = '天蝎'

print(dictionary)

输出：

{'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座', '君': '

天蝎'}

修改已有键/值对

由于键是唯一的，不可改动，所以只能改变对值。

例：

dictionary = {'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

dictionary['绮梦'] = '天蝎'

print(dictionary)

输出：

{'绮梦': '天蝎', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令

实例：

dictionary = {

'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'

}

del dictionary['绮梦']

print(dictionary)

输出：

{'冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

当删除一个不存在的键是，会引发一个异常

遍历字典

字典以"键-值对"的形式储存数据，所以需要通过这些"键-值对"进行获取。

使用字典对象的items()方法可以获取字典的"键-值对"列表。

语法格式： dictionary.items()

例：

dictionary = {

'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'

}

for item in dictionary.items():

print(item)

输出：

('绮梦', '水瓶座')

('冷伊一', '射手座')

('香凝', '双鱼座')

('黛兰', '双子座')

也可以获取具体的每个键，每个对值。

例：

dictionary = {

'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'

}

for key,value in dictionary.items():

print(key,'的星座是',value)

输出：

绮梦 的星座是 水瓶座

冷伊一 的星座是 射手座

香凝 的星座是 双鱼座

黛兰 的星座是 双子座

说明：字典对象也可以使用key()方法和value()方法，用于返回字典中的键与值列表，他们的使用方法与items()方法类似，也需要使用for循环遍历该字典列表，获取对应的键与值。

字典推导法

使用字典推导法也可以快速生成字典，它的表现形式与列表推导法类似。

例：

import random

randomdict = {i:random.randint(10,10) for i in range (1,5)}

print('生成的字典为：',randomdict)

输出：

生成的字典为： {1: 10, 2: 10, 3: 10, 4: 10}

示例：

name = ['绮梦','冷伊一','香凝','黛兰'] # 作为键的列表

sign = ['水瓶','射手','双鱼','双子'] # 作为值的列表

dictionary = {i:j+'座' for i,j in zip(name,sign)} # 使用列表推导式生成字典

print(dictionary) # 输出转换后字典

输出：

{'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座'}

字典内置函数&方法

Python字典包含了以下内置函数：

序号

函数及描述

1

radiansdict.clear()删除字典内所有元素

2

radiansdict.copy()返回一个字典的浅复制

3

radiansdict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

4

radiansdict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值

5

key in dict如果键在字典dict里返回true，否则返回false

6

radiansdict.items()以列表返回可遍历的(键, 值) 元组数组

7

radiansdict.keys()返回一个迭代器，可以使用 list() 来转换为列表

8

radiansdict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

9

radiansdict.update(dict2)把字典dict2的键/值对更新到dict里

10

radiansdict.values()返回一个迭代器，可以使用 list() 来转换为列表

11

pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

12

popitem()随机返回并删除字典中的最后一对键和值。

1.len(dict)

计算字典元素个数，即键的总数。

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> len(dict)3

2.str(dict)

输出字典，以可打印的字符串表示。

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> str(dict)"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

3。type(variable)

返回输入的变量类型，如果变量是字典就返回字典类型。

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> type(dict)

Python字典包含了以下内置方法：

字典 clear()方法

描述

Python 字典 clear() 函数用于删除字典内所有元素。

语法

clear()方法语法：

dict.clear()

返回值

该函数没有任何返回值。

实例

clear()函数的使用方法：

dict = {'Name': 'Zara', 'Age': 7}

print ("字典长度 : %d" % len(dict))

dict.clear()print ("字典删除后长度 : %d" % len(dict))

以上实例输出结果为：

字典长度 : 2

字典删除后长度 : 0

字典 copy()方法

Python 字典 copy() 函数返回一个字典的浅复制。

语法

copy()方法语法：

dict.copy()

返回值

返回一个字典的浅复制。

实例

copy()函数的使用方法：

实例

dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

dict2 = dict1.copy()

print ("新复制的字典为 : ",dict2)

以上实例输出结果为：

新复制的字典为 : {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}

直接赋值和 copy 的区别

可以通过以下实例说明：

实例

dict1 = {'user':'runoob','num':[1,2,3]}

dict2 = dict1 # 浅拷贝: 引用对象

dict3 = dict1.copy() # 浅拷贝：深拷贝父对象(一级目录)，子对象(二级目录)不拷贝，还是引用 # 修改 data 数据 dict1['user']='root'

dict1['num'].remove(1) # 输出结果

print(dict1)

print(dict2)

print(dict3)

实例中 dict2 其实是 dict1 的引用(别名)，所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。

{'user': 'root', 'num': [2, 3]}{'user': 'root', 'num': [2, 3]}{'user': 'runoob', 'num': [2, 3]}

知识扩展:

Python 直接赋值、浅拷贝和深度拷贝解析

直接赋值：其实就是对象的引用(别名)。

浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

字典浅拷贝实例

实例

>>>a = {1: [1,2,3]}

>>> b = a.copy()

>>> a, b ({1: [1, 2, 3]}, {1: [1, 2, 3]})

>>> a[1].append(4)

>>> a, b ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})

深度拷贝需要引入 copy 模块：

实例

>>>import copy

>>> c = copy.deepcopy(a)

>>> a, c ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})

>>> a[1].append(5)

>>> a, c ({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})

解析

1、b = a: 赋值引用，a 和 b 都指向同一个对象。

2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象(是引用)。

b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

更多实例

以下实例是使用 copy 模块的 copy.copy( 浅拷贝 )和(copy.deepcopy ):

实例

import copy a = [1, 2, 3, 4, ['a', 'b']] #原始对象

b = a #赋值，传对象的引用

c = copy.copy(a) #对象拷贝，浅拷贝

d = copy.deepcopy(a) #对象拷贝，深拷贝

append(5) #修改对象a

a[4].append('c') #修改对象a中的['a', 'b']数组对象

print( 'a = ', a )

print( 'b = ', b )

print( 'c = ', c )

print( 'd = ', d )

以上实例执行输出结果为：

('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])

('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])

('c = ', [1, 2, 3, 4, ['a', 'b', 'c']])

('d = ', [1, 2, 3, 4, ['a', 'b']])

字典 fromkeys() 方法

Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

语法

fromkeys() 方法语法：

dict.fromkeys(seq[, value])

参数

seq -- 字典键值列表。

value -- 可选参数, 设置键序列(seq)对应的值，默认为 None。

返回值

该方法返回一个新字典。

实例

fromkeys()函数的使用方法：

实例

seq = ('name', 'age', 'sex')

dict = dict.fromkeys(seq)

print ("新的字典为 : %s" % str(dict))

dict = dict.fromkeys(seq, 10)

print ("新的字典为 : %s" % str(dict))

以上实例输出结果为：

新的字典为 : {'age': None, 'name': None, 'sex': None}

新的字典为 : {'age': 10, 'name': 10, 'sex': 10}

不指定值：

实例

#!/usr/bin/python3

x = ('key1', 'key2', 'key3')

thisdict = dict.fromkeys(x)

print(thisdict)

以上实例输出结果为：

{'key1': None, 'key2': None, 'key3': None}

字典 get() 方法

描述

Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值。

语法

get()方法语法：

dict.get(key, default=None)

参数

key -- 字典中要查找的键。

default -- 如果指定键的值不存在时，返回该默认值值。

返回值

返回指定键的值，如果值不在字典中返回默认值 None。

实例

get()函数的使用方法：

dict = {'Name': 'Runoob', 'Age': 27}

print ("Age 值为 : %s" % dict.get('Age'))

print ("Sex 值为 : %s" % dict.get('Sex', "NA"))

以上实例输出结果为：

Age 值为 : 27Sex 值为 : NA

字典 in 操作符

描述:字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。

而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。

语法

in 操作符语法：

key in dict

参数

key -- 要在字典中查找的键。

返回值

如果键在字典里返回true，否则返回false。

实例

n 操作符在字典中的使用方法：

dict = {'Name': 'Runoob', 'Age': 7}

# 检测键 Age 是否存在

if 'Age' in dict: print("键 Age 存在")

else : print("键 Age 不存在")

# 检测键 Sex 是否存在

if 'Sex' in dict:

print("键 Sex 存在")

else : print("键 Sex 不存在")

# not in

# 检测键 Age 是否存在

if 'Age' not in dict:

print("键 Age 不存在")

else : print("键 Age 存在")

以上实例输出结果为：

键 Age 存在

键 Sex 不存在

键 Age 存在

items() 方法

描述:items() 方法以列表返回可遍历的(键, 值) 元组数组。

语法

items()方法语法：

dict.items()

返回值

返回可遍历的(键, 值) 元组数组。

实例:

items() 方法的使用方法：

dict = {'Name': 'Runoob', 'Age': 7}

print ("Value : %s" % dict.items())

以上实例输出结果为：

Value : dict_items([('Age', 7), ('Name', 'Runoob')])

字典 keys() 方法

描述: 字典 keys() 方法返回一个可迭代对象，可以使用 list() 来转换为列表。

语法

keys()方法语法：

dict.keys()

返回值

返回一个迭代器。

实例

keys() 方法的使用方法：

>>> dict = {'Name': 'Runoob', 'Age': 7}

>>> dict.keys()

dict_keys(['Name', 'Age'])

>>> list(dict.keys()) # 转换为列表

['Name', 'Age']

>>>

以上实例输出结果为：

字典所有的键为 : dict_keys(['Age', 'Name'])

字典 setdefault() 方法

描述

字典 setdefault() 方法和 类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。

语法

setdefault()方法语法：

dict.setdefault(key, default=None)

参数

key -- 查找的键值。

default -- 键不存在时，设置的默认键值。

返回值

如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。

实例

setdefault() 方法的使用方法：

实例

dict = {'Name': 'Runoob', 'Age': 7}

print ("Age 键的值为 : %s" % dict.setdefault('Age', None))

print ("Sex 键的值为 : %s" % dict.setdefault('Sex', None))

print ("新字典为：", dict)

以上实例输出结果为：

Age 键的值为 : 7

Sex 键的值为 : None

新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}

字典 update() 方法

描述

update() 方法用于更新字典中的键/值对，可以修改存在的键对应的值，也可以添加新的键/值对到字典中。

用法与 Python 函数相似。

语法:update()

方法语法：

dict.update(dict2)

参数

dict2 -- 添加到指定字典dict里的字典。

返回值

该方法没有任何返回值。

实例

以下实例展示了 update()函数的使用方法：

实例(Python 2.0+)

dict = {'Name': 'Runoob', 'Age': 7}

dict2 = {'Sex': 'female' }

dict.update(dict2)

print ("更新字典 dict : ", dict)

以上实例输出结果为：

更新字典 dict : {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}

字典 values() 方法

描述

字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。

语法

values()方法语法：

dict.values()

参数

NA。

返回值

返回迭代器。

实例

values() 方法的使用方法：

dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}

print ("字典所有值为 : ", list(dict.values()))

以上实例输出结果为：

字典所有值为 : ['female', 7, 'Zara']

字典 pop() 方法

描述

字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

语法

pop()方法语法：

pop(key[,default])

参数

key: 要删除的键值

default: 如果没有 key，返回 default 值

返回值

返回被删除的值。

实例

以下实例展示了 pop() 方法的使用方法：

>>> site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}

>>> pop_obj=site.pop('name')

>>> print(pop_obj)

菜鸟教程

字典 popitem() 方法

描述

Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。

如果字典已经为空，却调用了此方法，就报出KeyError异常。

语法

popitem()方法语法：

popitem()

参数

无

返回值

返回一个键值对(key,value)形式，按照 LIFO(Last In First Out 后进先出法) 顺序规则，即最末尾的键值对。

实例

以下实例展示了 popitem() 方法的使用方法：

实例

site= {'name': '菜鸟', 'alexa': 10000, 'url': 'www.runoob.com'}

pop_obj=site.popitem()

print(pop_obj)

print(site)

输出结果为：

('url', 'www.runoob.com'){'name': '菜鸟', 'alexa': 10000}