一、字典基础
1、创建字典
一个字典通过一对大括号进行创建，键值之间使用（:）进行分隔，每一对键值之间使用（,）分隔，如果大括号中无值那么就是空字典；它是Python中唯一具有映射关系的数据类型，效率高于列表。
d = {"name":"bright",12:["jskfj",23]} #键唯一且为不可变数据类型
当然如果键值不唯一，也不会抛出异常，只不过相同的键会被覆盖掉。
d = {"name":"bright",12:["jskfj",23],"name":"gh"} #键唯一且为不可变数据类型
print(d)
#-----------------------------------------输出———————————————
{12: ['jskfj', 23], 'name': 'gh'}
2、dict函数
可以使用dict函数通过其它映射进行字典的创建
items=[('name','张三'),['iphone',1872563541]] d=dict(items) print(d) #{'name': '张三', 'iphone': 1872563541}
可以看出，为dict函数传入一个列表，而列表的元素就是一个个的列表或者元组，元素中包含两个值，第一个值表示了字典的键，第二个值表示字典的值。
另外dict也可以通过关键字传参，创建字典。
d=dict(name='张三',iphone=1872563541) print(d) #{'iphone': 1872563541, 'name': '张三'}
如果dict函数不指定任何参数，就会创建一个空字典
d=dict() print(d)#{}
二、字典的基本操作
1、len(dict)
返回字典中元素（键值对）的个数
d = {"name":"bright",12:["jskfj",23],"name":"gh"}
print(len(d))#2
2、dict[key]
#获取键对应的值 d = {"name":"bright",12:["jskfj",23],"name":"gh"} result=d["name"] print(result)#gh #对键进行赋值 d = {"name":"bright",12:["jskfj",23],"name":"gh"} d["name"]="root" print(d)#{12: ['jskfj', 23], 'name': 'root'}
3、del dict[key]
d = {"name":"bright",12:["jskfj",23],"name":"gh"}
del d["name"]
print(d)#{12: ['jskfj', 23]}
4、key in dict
判断dict中是否含有键为key的项
d = {"name":"bright",12:["jskfj",23],"name":"gh"}
print("name" in d)#True
5、字典格式化字符串
在字符串的格式化中，已经有很多方法了，这里也可以通过字典进行格式化，引进format_map()方法。
定义格式化参数字典：
data={ "name":"bright", "age":27, "hobby":"music" }
定义字符串模板：
str=""" {name} is a boy,{age} years old,liking {hobby}. """
使用format_map()方法格式化字符串：
print(str.format_map(data))#bright is a boy,27 years old,liking music.
6、序列与迭代
（1）获取字典中的key
d = {"name":"bright",12:["jskfj",23],"name":"gh"}
for key in d:
print(key)
######输出######
12
name
（2）获取字典中的key和value
d = {"name":"bright",12:["jskfj",23],"name":"gh"}
for key,val in d.items():
print(key,val)
#########输出######
12 ['jskfj', 23]
name gh
（3）并行迭代
同时迭代多个序列，可以使用range函数获取索引的范围，然后使用for循环进行迭代，注意多个序列一般元素个数相同。
schools=['beida','fudan','shifan'] citys=['北京','上海','天津'] for i in range(len(schools)): print(schools[i],citys[i]) ##########输出######## beida 北京 fudan 上海 shifan 天津
（4）压缩序列
使用zip函数将两个或多个序列的对应元素做为一个元组放到一起，如果压缩的两个或多个序列元素个数不相等，以元素个数最少的为准。
schools=['beida','fudan','shifan'] citys=['北京','上海','天津'] print(zip(schools,citys)) print(type(zip(schools,citys))) for i in zip(schools,citys): print(i) ############输出########### <zip object at 0x0000000005220D08> <class 'zip'> ('beida', '北京') ('fudan', '上海') ('shifan', '天津')
（5）反转序列迭代
通过reversed函数对一个序列进行反转
citys=['北京','上海','天津'] result=reversed(citys) print(result) for i in result: print(i) ###########输出########## <list_reverseiterator object at 0x00000000054657B8> 天津 上海 北京
7、其它
- 键类型
字典的键可以是任意不可变类型，例如，元组、字符串等，而列表的key也就是index必须是整数类型。
- 自动添加
字典可以通过dict[key]=value进行添加新元素，而列表必须通过append()或insert()方法进行添加新元素。
- key in dict
字典中查找的仅仅是字典的key，而列表中查找的是value，而非index.
三、字典方法
class dict(object): """ dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) """ def clear(self): # real signature unknown; restored from __doc__ """ D.clear() -> None. Remove all items from D. """ pass def copy(self): # real signature unknown; restored from __doc__ """ D.copy() -> a shallow copy of D """ pass @staticmethod # known case def fromkeys(*args, **kwargs): # real signature unknown """ Returns a new dict with keys from iterable and values equal to value. """ pass def get(self, k, d=None): # real signature unknown; restored from __doc__ """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ pass def items(self): # real signature unknown; restored from __doc__ """ D.items() -> a set-like object providing a view on D's items """ pass def keys(self): # real signature unknown; restored from __doc__ """ D.keys() -> a set-like object providing a view on D's keys """ pass def pop(self, k, d=None): # real signature unknown; restored from __doc__ """ D.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised """ pass def popitem(self): # real signature unknown; restored from __doc__ """ D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty. """ pass def setdefault(self, k, d=None): # real signature unknown; restored from __doc__ """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ pass def update(self, E=None, **F): # known special case of dict.update """ D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k] """ pass def values(self): # real signature unknown; restored from __doc__ """ D.values() -> an object providing a view on D's values """ pass def __contains__(self, *args, **kwargs): # real signature unknown """ True if D has a key k, else False. """ pass def __delitem__(self, *args, **kwargs): # real signature unknown """ Delete self[key]. """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __getitem__(self, y): # real signature unknown; restored from __doc__ """ x.__getitem__(y) <==> x[y] """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ """ dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) # (copied from class doc) """ pass def __iter__(self, *args, **kwargs): # real signature unknown """ Implement iter(self). """ pass def __len__(self, *args, **kwargs): # real signature unknown """ Return len(self). """ pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self<value. """ pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __ne__(self, *args, **kwargs): # real signature unknown """ Return self!=value. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setitem__(self, *args, **kwargs): # real signature unknown """ Set self[key] to value. """ pass def __sizeof__(self): # real signature unknown; restored from __doc__ """ D.__sizeof__() -> size of D in memory, in bytes """ pass __hash__ = None
1、clear()
清空字典中的所有元素
d = {"name":"bright",12:["jskfj",23],"name":"gh"}
d.clear()
print(d)#{}
2、copy()与deepcopy()
copy()方法复制的字典只是浅复制，复制的是第一层的字典数据。也就是说修改原字典还是新字典，对应的元素都会改变。
d = {"name":"bright",12:["jskfj",23]}
d1=d.copy()
print(d1)
print(d)
############输出###########################
{12: ['jskfj', 23], 'name': 'bright'}
{12: ['jskfj', 23], 'name': 'bright'}
修改原字典中的值：
d = {"name":"bright",12:["jskfj",23]}
d1=d.copy()
d["name"]="alb"
print(d1)
print(d)
#################输出################
{12: ['jskfj', 23], 'name': 'bright'}
{12: ['jskfj', 23], 'name': 'alb'}
修改copy后新字典中的值：
d = {"name":"bright",12:["jskfj",23]}
d1=d.copy()
d1["name"]="sjp"
print(d1)
print(d)
###############输出###################
{12: ['jskfj', 23], 'name': 'sjp'}
{12: ['jskfj', 23], 'name': 'bright'}
修改第二层数据：
d = {"name":"bright",12:["jskfj",23]}
d1=d.copy()
d[12][0]=56
print(d)
print(d1)
################输出###############
{12: [56, 23], 'name': 'bright'}
{12: [56, 23], 'name': 'bright'}
从上面可以看到修改第二层数据，无论是修改新字典还是原字典，另外一个字典的值都会改变，如果想改变这种情况，就需要进行深拷贝。
from copy import deepcopy d = {"name":"bright",12:["jskfj",23]} d1=deepcopy(d) d[12][0]=78 print(d) print(d1) ###################输出################## {12: [78, 23], 'name': 'bright'} {12: ['jskfj', 23], 'name': 'bright'}
3、fromkeys()
用于根据key建立新的字典，该方法的返回值就是新的字典。在新的字典中所有的key都有相同的默认值None，不过可以根据fromkeys方法的第二个参数进行指定默认值。
#在新字典上调用fromkeys创建新的字典，通过列表指定key dic={}.fromkeys(['name','age','hobby']) print(dic) #'hobby': None, 'age': None, 'name': None}
#通过元组指定key
dic={}.fromkeys(('name','age','hobby'))
print(dic) #'hobby': None, 'age': None, 'name': None}
通过fromkeys的第二个参数指定默认值
dic={}.fromkeys(('name','age','hobby'),'bx')
print(dic) #{'hobby': 'bx', 'age': 'bx', 'name': 'bx'}
4、get()
获取对应key的value，使用dict[key]可以获取值，但是一旦key不存在就会抛出异常，get()方法就不会抛出异常，如果key不存在，会返回None值。当然也可以通过get的第二个参数指定传入的默认值。
d = {"name":"bright",12:["jskfj",23]}
print(d.get("name"))#bright
print(d.get("age"))#None
5、items()与keys()
在字典的基本操作中已经说明了这两种方法，items方法用于获取字典的key-value，返回值是一个可迭代的dict_items类型；keys方法用于返回字典中所有的key，是dict_keys类型，也是可迭代的。
d = {"name":"bright",12:["jskfj",23]}
result1=d.items()
result2=d.keys()
print(type(result1))
for key,val in result1:
print(key,val)
print(type(d.keys()))
for key in result2:
print(key)
#########输出############
<class 'dict_items'>
12 ['jskfj', 23]
name bright
<class 'dict_keys'>
12
name
6、pop()和popitem()
pop方法和popitem方法用于弹出字典中的元素，pop方法用于获取指定的key的值，并从字典中弹出这个key-value，popitem方法用于返回最后一个key-value，并且弹出这对key-value。
#pop方法
dict={'name':'xiaoli','depart':'xiaoshou','age':27} print(dict.pop('name'))#xiaoli print(dict)#{'age': 27, 'depart': 'xiaoshou'} #popitem方法 dict={'name':'xiaoli','depart':'xiaoshou','age':27} print(dict.popitem())#('age', 27) print(dict)#{'name': 'xiaoli', 'depart': 'xiaoshou'}
7、setdefault()
setdefault方法用于设置key的默认值，该方法接收两个参数，第一个表示key，第二个表示默认值，如果key在字典中不存在，那么就会向字典中添加key，并用第二个参数作为值（参数未指定就为None），如果字典中已经存在key，setdefault不会修改key原来的值，而且该方法会返回原来的值。
dict={} dict.setdefault("name","menb") dict.setdefault("name","niko") dict.setdefault("age") print(dict) ##############输出######## {'age': None, 'name': 'menb'}
其实这个方法与dict[key]=value差不多，但是这个方法可以添加元素，但是不能修改元素，因为已经存在的key，它只会返回不会修改，而dict[key]=value既可以添加又可以修改。
8、update()
update方法用于一个字典中的元素更新另外一个字典。该方法接收一个参数，该参数表示用作更新数据的字典的数据源。列如：
d1.update(d2)
将d2中的元素更新到d1中，如果d2中的key-value对在d1中不存在，就会在d1中新添加key-value对，如果d2中的key在d1中已经存在，那么就会把d2中的key的value更新给d1中key的value。
d1={"name":"bright","age":27,"hobby":"music"}
d2={"name":"sansha","city":"陕西"}
d1.update(d2)
print(d1)#{'city': '陕西', 'hobby': 'music', 'age': 27, 'name': 'sansha'}
该方法试讲两个列表进行合并，当然还有其它方法，使用dict(dict1,**dict2)：
>>> dict1 = {'name':'bright','age':28}
>>> dict2 = {'identified':'worker'}
>>> dict(dict1,**dict2)
{'age': 28, 'name': 'bright', 'identified': 'worker'}
9、values()
获取字典中的值，返回的是dict_values类型，是可迭代的。它与keys方法返回的有一点不一样就是，它返回的值得列表可以有重复的，而keys()方法返回的都是唯一值的列表。
dict={"name":"bright","age":27,"hobby":"music"}
result=dict.values()
print(type(result))
for val in result:
print(val)
##########输出###########
<class 'dict_values'>
music
27
bright
四、总结
对字典操作最多的无非就是增、删、查、改这些基本操作，现在就对这些基本操作总结一下。
d = {"name":"bright",12:["jskfj",23]}
# #查
print(d["name"])
print(d.get("name",None)) #推荐
##增加
# d["age"] = "123"
# d.default("age","123")
print(d)
#修改
# d["name"] = "zhangfei"
#删除
# ret = d.pop(12)
# del d[12]
# print(ret)
##更新
d1 = {"name":"alia",12:["jskfj",23]}
d2 = {"name":"megon",12:["jskfj",23],"age":32}
d2.update(d)
print(d2)