Python字典操作

#encoding=utf-8
#字典 dict类对象
‘‘‘
必须要会的方法：keys()、values()、items()、get(keys,d)、update(dict)方法

1、dict字典有键值对（key:value）；
        key是不重复的,key不能是列表、字典；如果key重复，在dict中只会保留一对键值对，由于字典是无序的，最终保留的键值对无先后之说
        value可以是任何值（包括列表、元组、字典各种嵌套）
2、字典是无序的，字典要查找值，必须通过key索引才能找到相应的值;由于字典是无序的，不能通过切片进行查找
3、字典的键值对的删除，通过del进行删除 dict[key]
4、支持for循环（可通过keys()、values()、items()方法获取键、值及键值对【键值对必须要用两个变量去接收】）
4、keys():表示字典的键
5、values（）：表示字典的值
6、items():表示会获取字典的键和值，在for的时候必须要有两个变量去获取键和值，否则会报错
7、clear（）：清空字典
8、copy（）：浅拷贝
9、fromkeys(iterable,values):@staticmethod 表示静态方法，可以直接写dict.fromkyes()
        功能：根据序列创建字典的键，并通过values对所有的键赋予统一的值
10、get(self,keys,d):根据keys返回value的值，和dict[key]一样。但是索引key，如果传入的key不存在，会报错
                         使用get（keys，values）不会报错，没有传入d的值，返回为None，有传入就返回d值

11、pop（self，keys,d=None）:指定键，删除字典中的相应键值对（keys）,并获取删除键的value的值，如果传入的键不存在，可以根据传入的d返回d对象
12、popitem(self):随机删除字典中的键值对，并获取删除的键值对，已元组类型存储
13、setdefault（self，keys,d=None）:通过传入的keys值，设置值，如果字典中存在，不设置值，直接获取字典的值；
                                    如果字典不存在，会在字典添加传入的keys:d值，并获取d的值
14、update(self, E=None, **F)：更新，字典中已经存在的更新，字典中不存在增加新的键值对

‘‘‘

#get（）方法和dict[key]属性的比较;key不存在用直接索引会报错，用get（）方法不会报错，返回None的值，如果有参数传入，key不存在就会返回参数的值
info = {"K1":"V1","K2":"V2","K3":"V3"}
#print(info["K4"])  #报错
‘‘‘
Traceback (most recent call last):
  File "D:/python.exec/练习/字典(dict).py", line 28, in <module>
    print(info["K4"])
KeyError: ‘K4‘
‘‘‘
print(info.get("K4"))
‘‘‘ None ‘‘‘

print(info.get("K4",1111))
‘‘‘ 1111 ‘‘‘


#dict中的value可以是任何值
info = {
    "k1":18,
    "k2":True,
    "k3":[
        11,
        22,
        {
            "kk1":"vv1",
            "kk2":"vv2",
            "kk3":(11,22)
        }
    ],
    "k4":(11,22,33,44)
}
print(info)
‘‘‘ {‘k1‘: 18, ‘k2‘: True, ‘k3‘: [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}], ‘k4‘: (11, 22, 33, 44)} ‘‘‘

#dict中的key不能是列表和字典；bool值True表示数字1，False表示数字0

info={
    1:"asdf",
    "str":21313,
    (11,22):[12,23],
    True:"123",
    False:{"kk1":"vv1"}
}
print(info)

‘‘‘ {1: ‘123‘, ‘str‘: 21313, (11, 22): [12, 23], False: {‘kk1‘: ‘vv1‘}} ‘‘‘

#由于dict是无序的，无法直接通过index进行索引值，只能通过key查找相应的值；dict是无序的，无法使用切片进行查找
info= {‘k1‘: 18, 1: True, ‘k3‘: [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}],(11,22): (11, 22, 33, 44)}
print(info["k1"])
print(info[1])
print(info[(11,22)])
print(info["k3"][2]["kk1"])
print(info["k3"][2]["kk3"][0])
‘‘‘ 18    True    (11, 22, 33, 44)     vv1  ‘‘‘

#字典的删除(del)
info= {‘k1‘: 18, 1: True, ‘k3‘: [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}],(11,22): (11, 22, 33, 44)}
del info["k1"]
print(info)
‘‘‘{1: True, ‘k3‘: [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}], (11, 22): (11, 22, 33, 44)} ‘‘‘

info= {‘k1‘: 18, 1: True, ‘k3‘: [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}],(11,22): (11, 22, 33, 44)}
del info["k3"][2]["kk1"]
print(info)
‘‘‘{‘k1‘: 18, 1: True, ‘k3‘: [11, 22, {‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}], (11, 22): (11, 22, 33, 44)}‘‘‘

#看是否是可迭代对象,字典没有传入方法时，默认输出的是key值
info= {‘k1‘: 18, 1: True, ‘k3‘: [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}],(11,22): (11, 22, 33, 44)}
#遍历字典，输出所有的键
for keys in info.keys():   #for keys in info：效果一致（默认就是键）
    print(keys)
‘‘‘k1    1     k3     (11, 22)‘‘‘
#遍历字典，输出所有的值
for values in info.values():
    print(values)
‘‘‘18   True    [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}]    (11, 22, 33, 44) ‘‘‘

#输出所有的键值对，使用items（）方法时必须要用两个变量去获取
for dict1 in info.keys():
    print(dict1,info[dict1])

for keys,values in info.items():
    print(keys,values)
‘‘‘
k1 18
1 True
k3 [11, 22, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}]
(11, 22) (11, 22, 33, 44)
‘‘‘

#fromkeys(iterable,values)静态方法：通过序列创建字典的键，比对所有的键赋值统一的值values
dic1 = dict.fromkeys("123","123")
print(dic1)
‘‘‘{‘1‘: ‘123‘, ‘2‘: ‘123‘, ‘3‘: ‘123‘}‘‘‘
dic1 = dict.fromkeys([1,2,3],[4,5,6])
print(dic1)
‘‘‘{1: [4, 5, 6], 2: [4, 5, 6], 3: [4, 5, 6]}‘‘‘
dic1 = dict.fromkeys((1,2,3),(4,5,6))
print(dic1)
‘‘‘{1: (4, 5, 6), 2: (4, 5, 6), 3: (4, 5, 6)}‘‘‘

#pop(keys,d)方法，通过传入的key删除字典中对应的键值对,返回values值，如果字典中补充该键，返回传入参数的d对象
info = {"K1":"V1","K2":"V2","K3":"V3"}
v = info.pop("K1")
print(info,v)
‘‘‘ {‘K2‘: ‘V2‘, ‘K3‘: ‘V3‘} V1 ‘‘‘
v = info.pop("K4",1111)
print(info,v)
‘‘‘ {‘K2‘: ‘V2‘, ‘K3‘: ‘V3‘} 1111 ‘‘‘

#popitem(self):随机删除字典的键值对，返回删除的键值对并以元组类型存储
info = {"K1":"V1","K2":"V2","K3":"V3"}
v = info.popitem()
print(info,v)
‘‘‘ {‘K1‘: ‘V1‘, ‘K2‘: ‘V2‘} (‘K3‘, ‘V3‘) ‘‘‘
v1,v2 = info.popitem()
print(info,v1,v2)
‘‘‘ {‘K1‘: ‘V1‘} K2 V2 ‘‘‘

#setdefault(keys,d)通过keys设置值，字典存在，不修改字典的键值对，获取字典的值；如果字典不存在，在字典中添加键值对，获取d的值
info = {"K1":"V1","K2":"V2","K3":"V3"}
v = info.setdefault("K1",123)          #在字典中存在，故返回字典K1对应值为V1
print(info,v)
‘‘‘ {‘K1‘: ‘V1‘, ‘K2‘: ‘V2‘, ‘K3‘: ‘V3‘} V1 ‘‘‘
v = info.setdefault("123",123)       #不存在，会往字典增加键值对，返回123的值
print(info,v)
‘‘‘ {‘K1‘: ‘V1‘, ‘K2‘: ‘V2‘, ‘K3‘: ‘V3‘, ‘123‘: 123} 123 ‘‘‘

#update（self，dict）更新字典，传入的新字典中，在老字典中存在，更新，不存在增加
info = {"K1":"V1","K2":"V2","K3":"V3"}
info.update({"K1":123,"K4":456})
print(info)
‘‘‘ {‘K1‘: 123, ‘K2‘: ‘V2‘, ‘K3‘: ‘V3‘, ‘K4‘: 456} ‘‘‘
#另外一种写法
info = {"K1":"V1","K2":"V2","K3":"V3"}
info.update(K1=123,K4=456)
print(info)
‘‘‘ {‘K1‘: 123, ‘K2‘: ‘V2‘, ‘K3‘: ‘V3‘, ‘K4‘: 456} ‘‘‘