字典操作

一、字典基础

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)