Python3之字典

1、字典定义

字典是一种可变容器模型(支持增删改查操作)，可存储任意类型对象

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

dict = {key1:value1

           key2:value2

          }

注意：

a、字典中的键不可变，但值(value)可以取任意类型的数据，因此键一般使用数字、字符串或元组，键使用列表时报错 

dict = {
        ['Name']: 'Runoob', 
        'Age': 7
       }
 
print ("dict['Name']: ", dict['Name'])

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

b、 字典的键(key)必须是唯一的，创建字典时如果相同的键被赋值两次，后面的值会覆盖前面的值，相当于修改字典中某个键的值

2、访问字典中的值

使用dict[key]可以访问字典中的值，即：字典名[键名]

dictA = {
         'name':'Kobe',
         'age':'41'
        }
print('字典dictA中name的值为：', dictA['name'])
print('字典dictA中name的值为：%s' %  dictA['name'])

字典dictA中name的值为： Kobe
字典dictA中name的值为：Kobe

3、修改字典中的值

字典添加新元素的方法是增加新的键/值对，即直接对字典名[键名]赋值。如果对已有的键值对赋值，相当于修改该键值对，如：

dictA = {
         'name':'Kobe',
         'age':'41'
        }
print('原字典dictA为：',dictA)
dictA['number'] = 24
dictA['age'] = 18
print('新字典dictA为：',dictA)

原字典dictA为： {'name': 'Kobe', 'age': '41'}
新字典dictA为： {'name': 'Kobe', 'age': 18, 'number': 24}

4、 删除字典的值

a、删除单一数据

使用del 字典名[键名]即可删除单一字典数据

b、清空整个字典中的值(保留字典)

使用字典名.clear()即可清空整个字典中的值

c、删除整个字典

使用del 字典名即可删除整个字典，删除字典后再打印字典时报错

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

# a、删除单一字典值
del dictA['age']
print('删除age后的字典dictA为：',dictA)

# b、清空字典中的所有元素
dictA.clear()
print('清空字典中的所有元素后为：',dictA)

# c、删除整个字典
del dictA
print('删除整个字典后为：',dictA)

删除age后的字典dictA为： {'name': 'Kobe', 'number': 24}
清空字典中的所有元素后为： {}

5、 字典的内置函数和方法

定义：
dictA = {
         'name':'Kobe',
         'age':'41'
        }

函数/方法	说明	举例
len(dictA )	计算字典元素的个数，即字典中key的个数	len(dictA)方法2
str(dictA )	以可打印的字符串形式输出字典	str(dictA)输出：{'name': 'Kobe', 'age': '41'}
type(variable)	返回变量variable的类型	type(dictA['name'])返回：<class 'str'>
radiansdict.clear()	clear() 函数用于删除字典内所有元素 语法： dict.clear()	print("删除字典内所有元素前，字典中元素数量：%d" % len(dictA)) dictA.clear() print("删除字典内所有元素后，字典中元素数量：%d" % len(dictA)) 删除字典内所有元素前，字典中元素数量：2 删除字典内所有元素后，字典中元素数量：0
radiansdict.copy()	copy() 函数返回一个字典的浅复制 语法： dict.copy() 返回值： 返回一个字典的浅复制	dictB = dictA.copy() print('新字典dictB为：',dictB) print('新字典dictB为：',str(dictB)) 新字典dictB为： {'name': 'Kobe', 'age': '41'} 新字典dictB为： {'name': 'Kobe', 'age': '41'}
radiansdict.fromkeys()	dictA.fromkeys()函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值 语法： dict.fromkeys(seq[, value]) 参数： seq -- 字典键值列表 value -- 可选参数, 设置键序列（seq）对应的值，默认为 None 返回： 该方法返回一个新字典	seq1 = ('name' , 'number' , 'age') dictC = dict.fromkeys(seq1) dictC = dict.fromkeys(seq1 , 10) print('新字典dictC为：',str(dictC)) 新字典dictC为： {'name': 10, 'number': 10, 'age': 10}
radiansdict.get(key, default=None)	get() 函数返回指定键的值，如果value值不在字典中返回默认值 语法： dict.get(key, default=None) 参数： key -- 字典中要查找的键 default -- 如果指定键的值不存在时，返回该默认值值 返回值： 返回指定键的值，如果值不在字典中返回默认值 None(如果查询的key不在字典中，则返回的value为none)	dictA = { 'name':'Kobe', 'age':'41' } print("dictA字典中name的值为：" , dictA.get('name')) print("dictA字典中name的值为：" , dictA['name']) print("dictA字典中number的值为：" , dictA.get('number')) dictA字典中name的值为： Kobe dictA字典中name的值为： Kobe dictA字典中name的值为： None
radiansdict.setdefault(key, default=None)	setdefault() 方法和 get()方法 类似，如果键key不存在于字典中，将会添加键并将值设为默认值 语法： dict.setdefault(key, default=None) 参数： key -- 查找的键值 default -- 键不存在时，设置的默认键值 返回： 如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None	dictA = { 'name':'Kobe', 'age':'41' } print("dictA中name的值为：%s" % dictA.setdefault('name' , 'KD')) # name已有value值Kobe，因此即使新设置值KD，也不会更新value的值 print("dictA中team的值为：%s" % dictA.setdefault('team',None)) print("新的dictA为：" , dictA) dictA中name的值为：Kobe dictA中team的值为：None 新的dictA为： {'name': 'Kobe', 'age': '41', 'team': None}
key in dict	字典 in 操作符用于判断键是否存在于字典中，如果键在字典，返回 true，否则返回 false； not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true	print("name in dictA中：" , ('name' in dictA)) print("number in dictA中：" , ('number' not in dictA)) name in dictA中： True number in dictA中： True
radiansdict.items()	items() 方法以列表的形式返回可遍历的形如(键, 值) 的元组数组 语法： dict.items() 返回值： 返回可遍历的(键, 值) 元组数组	dictA = { 'name':'Kobe', 'age':'41' } tuple_A = dictA.items() print((tuple_A)) dict_items([('name', 'Kobe'), ('age', '41')]) 将字典的 key 和 value 组成一个新的列表： dictA = { 'name':'Kobe', 'age':'41' } listA = [] for i , j in dictA.items(): listA.append(i) listA.append(j) print('listA为：' , listA)   listA为： ['name', 'Kobe', 'age', '41']
radiansdict.keys()	keys() 方法将字典中key作为一个可迭代对象返回，可以使用 list() 来转换为列表 语法： dict.keys() 返回值： 字典中key作为一个可迭代对象返回，可以使用 list() 来转换为列表	dictA = { 'name':'Kobe', 'age':'41' } print('dictA.keys()为：' , dictA.keys()) print('list(dictA.keys())为：',list(dictA.keys())) dictA.keys()为： dict_keys(['name', 'age']) list(dictA.keys())为： ['name', 'age']
radiansdict.values()	keys() 方法将字典中values作为一个可迭代对象返回，可以使用 list() 来转换为列表 语法： dict.values() 字典中values作为一个可迭代对象返回，可以使用 list() 来转换为列表	dictA = { 'name':'Kobe', 'age':'41' } print('dictA.values()为：' , dictA.values()) print('list(dictA.values())为：',list(dictA.values())) dictA.values()为： dict_values(['Kobe', '41']) list(dictA.values())为： ['Kobe', '41']
radiansdict.update(dict2)	update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里 语法： dict.update(dict2) 参数： dict2 -- 添加到指定字典dict里的字典 返回值： 该方法没有任何返回值 注：如果dict2中键值key与dict1中key有重复，则 dict2 中的value内容更新替换到 dict1 中	dictA = { 'name':'Kobe', 'age':41 } dictB = { 'Team':'Lakers', 'number':24 , 'age':14 , } print("dictB 的 key/value(键/值) 对更新到字典 dictA 里后，dictA为：" , dictA.update(dictB)) # dictA.update(dictB)返回结果为None dictA.update(dictB) print("dictB 的 key/value(键/值) 对更新到字典 dictA 里后，dictA为：" , dictA) dictB 的 key/value(键/值) 对更新到字典 dictA 里后，dictA为： None dictB 的 key/value(键/值) 对更新到字典 dictA 里后，dictA为： {'name': 'Kobe', 'age': 14, 'Team': 'Lakers', 'number': 24}
pop(key[,default])	pop() 方法删除字典给定键 key 所对应的值value，返回被删除的值value；key值必须给出， 否则，返回default值 语法： pop(key[,default]) 参数： key: 要删除的键值 default: 如果没有 key，返回 default 值 返回值： 返回被删除的值	dictA = { 'name':'Kobe', 'age':41 } print('删除dictA中age的值为：' , dictA.pop('age')) # 如果要删除的 key 不存在，则需要添加默认值，否则会报错 print('删除dictA中不存在的number的值为：' , dictA.pop('number' , 24)) # 设置默认值，必须添加，否则报错 删除dictA中age的值为： 41 删除dictA中不存在的number的值为： 24
popitem()	popitem() 方法随机返回并删除字典中的最后一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常 语法： popitem() 返回： 返回一个键值对(key,value)形式，按照 LIFO（Last In First Out 后进先出） 顺序规则，即最末尾的键值对最先被删除	dictC = { 'name': 'Kobe', 'age': 14, 'Team': 'Lakers', 'number': 24 } print("被popitem() 方法删除的键值对为：" , dictC.popitem()) print("被popitem() 方法删除后的字典dictC为：" , dictC) 被popitem() 方法删除的键值对为： ('number', 24) 被popitem() 方法删除后的字典dictC为： {'name': 'Kobe', 'age': 14, 'Team': 'Lakers'}