字典的相关知识

#按照字符串每个数字的和进行排序：
#s="11 22 33 44 394 55" 得到“11 22 33 44 55 394”

s="11 22 33 44 394 55"
def sum_(num):
    r=0
    for n in num:
        r += int(n)
    return (r)
print(" ".join(sorted(s.split(),key=sum_)))
 

#L中分别按照学生姓名和学生成绩排序
L=[('Bob',75),('Adam',92),('Bart',66),('Lisa',88)]
print(sorted(L,key=lambda x:x[0]))
print(sorted(L,key=lambda x:x[1]))

#统计一个字符串中的每个单词出现的次数
s="i am a boy a good boy a bad boy"

item_count={}
s_list=s.split()
for word in s_list:
    item_count[word]=s_list.count(word)
print(item_count)

#第二种方法
s="i am a boy a good boy a bad boy"
item_count={}
s_list=s.split()
for word in s_list:
    if word not in item_count:
        item_count[word]=1
    else:
        item_count[word]+=1
print(item_count)
 

#生成["z1","y2","x3","w4","v5"]
#大写A-Z 65-90 a-z 97-122 数字48-57
res=[]
for i in range(1,6):
    item=chr(122-i+1)+str(i)
    res.append(item)
print(res)
 

print([chr(123-i)+str(i)for i in range(1,6)])

字典的两个特性：key是唯一的 不可重复的；key必须为不可变元素

不可变元素：数字 字符串 集合

可变元素：字典 列表 集合set{} 改变值的同时，id不变

{} key value键值对

可通过赋值的方式来添加key和value

>>> d['a']=97

>>> d

{'a': 97}

删除 del d["a"]

d.pop(key)--删除某个键值对 并返回它的value

 d.popitem() 删除并返回某一个键值对

d.clear() 清空元素 id(d)存在

del d 删除

修改：d['c']=100 直接赋值

访问 d['a']

slice 切片

>>> d

{'b': 90, 10: 10, 10.25: 10.25, 'a,b,c': 100, 'x': [1, 2, 'X']}

>>> d["x"]

[1, 2, 'X']

>>> d["x"][0]

1

key 不能为列表

>>> d.keys()

dict_keys(['b', 10, 10.25, 'a,b,c', 'x'])

>>> d.values()

dict_values([90, 10, 10.25, 100, [1, 2, 'X']])

>>> d.items()

dict_items([('b', 90), (10, 10), (10.25, 10.25), ('a,b,c', 100), ('x', [1, 2, 'X'])])

遍历key

>>> for key in d:

...     print(key)

>>> for key in d.keys():

...     print(key)

遍历value

>>> for value in d.values():

...     print(value)

遍历键值对

>>> for key_value in d.items():

...     print(key_value)

>>> for key,value in d.items():

...     print("key:",key)

...     print("value:",value)

#练习
#把一个字典的key value互相交换
d={'a':97,'b':98,'c':100}
res={}
for key,value in d.items():
    if not isinstance(value,(list,dict,set)):
        res[value]=key
print(res)
 

字典推导式：

{lst[i],lst[i+1]  for i in range(0,len(lst),2)}

下标 index

#有一个列表 把偶数下标位置元素作为key，奇数下标位置元素作为value，生成一个字典
lst=["a",97,"b",98,"c",99,(1,2,3),[1,2,3]]
dic={}
for index in range(len(lst)):
    if index%2==0:
        dic[lst[index]]=lst[index+1]#类似d['a']=97
print(dic)

字典

>>> list(zip([1,2,3],[4,5,6]))

[(1, 4), (2, 5), (3, 6)]

>>> ls=list(zip([1,2,3],[4,5,6]))

>>> ls

[(1, 4), (2, 5), (3, 6)]

dict items 互反

>>> l=sorted(d.items(),key=lambda x:x[0])

>>> l

[('a', 97), ('b', 98), ('c', 99), ('d', 100), ('z', 122)]

>>> dict(l)

{'a': 97, 'b': 98, 'c': 99, 'd': 100, 'z': 122}

通过列表排序 再转换为字典 

>>> d.get('a')

97

字典不可以+操作

eval()函数 字符串转换成字典

exec()函数

>>> eval(str(d))

{'a': 97, 'b': 98, 'c': 99, 'z': 122, 'd': 100}

>>> max(d)

'z'

>>> len(d)

5

>>> list(d.keys()).count('b')

1

>>> d1

{'name': 'zhang', 'age': 18}

>>> d.update(d1)

>>> d

{'a': 97, 'b': 98, 'c': 99, 'z': 122, 'd': 100, 'name': 'zhang', 'age': 18}

同列表的extend（）

>>> d1.setdefault('bb',100)

100

>>> d1

{'name': 'zhang', 'age': 18, 'bb': 100}

d1.setdefault

如果key值存在，返回key对应的值，即使指定value参数

如果key不存在 key value作为一个键值对加入到d字典中

定义字典的方式

1.定义空字典 d={}

2.定义有元素的字典 d={"a":1,"b":2}

3.d=dict(key1=value1,key2=value2)

4.d=dict([("a",1),("b",2)])或者 dic(zip(...))

5.d=dict.fromkeys("shjadja",10)

练习：

#写一个函数实现：两个长度相同的list，一个的元素做字典的key，一个的元素作为字典的value

def gen_dic(lst1,lst2):
    dic={}
    for i in range(len(lst1)):
        dic[lst1[i]]=lst2[i]
    return dic
lst1=list("XYZ")
lst2=list("123")
print(gen_dic(lst1,lst2))

lst1=['a','b','c','d','e']
lst2=[1,2,3,4,5]
l=list(zip(lst1,lst2))
print(dict(l))

#将字符串：“k:1|k1:2|k2:3|k3:4”,处理成python字典：{'k':1,'k1':2,'k2':3,'k3':4}

res={}

s="k:1|k1:2|k2:3|k3:4"

item_list=s.split("|")
for k_v in item_list:
    k=k_v.split(":")[0]
    v=k_v.split(":")[1]
    res[k]=v
print(res)

{k_v.split(":")[0]:k_v.split(":")[1]  for k_v in s.split("|")}

#d={"Robert":80,"Smith":90,"Mei":78,"Lily":98}
#f分别按名字的所有字母的ascii值的和排序
#成绩由高到低排序

d={"Robert":80,"Smith":90,"Mei":78,"Lily":98}
print(dict(sorted(d.items(),key=lambda x:sum([ord(c) for c in x[0]]))))
#print(dict(sorted(d.items(),key=lambda x:x[1],reverse=False)))