dict 和 set 的15个使用例子

from heapq import nlargest
from collections import defaultdict,ChainMap
#update 实际使⽤字典时，需要批量插⼊键值对到已有字典中，使⽤ update ⽅法实现批量插⼊.
a = {'a':1,'b':2}
a.update({'b':4,'c':5,'e':9}) # 方法1
a.update([('b',4),('c',5),('e',9)]) # 方法2
a.update([('b',4),('c',5),('e',9)],fi1=10) # 方法3
print(f'更新后的值是：{a}')

# setdefault 如果仅当字典中不存在某个键值对时，才插⼊到字典中；如果存在，不必插⼊（也就不会修改键值对）
b = {'a':1,'b':2}
bs = b.setdefault('c',3)
print(f'添加的值：{bs}')
print(f'C不存在，所以会添加进去：{b}')

bsa = b.setdefault('c',53)
print(f'添加的值：{bsa}')
print(f'C已经存在，所以不会添加进去：{b}')

# 字典并集
def f(d:dict)->dict:
    return {**d}
cb = f({'a':1,'b':2})
print(f'字典取并集后：{cb}')

def merge(d1,d2):
    return {**d1,**d2}

cd = merge({'a':1,'v':32,'t':43},{'y':43})
print(f'字典取并集后：{cd}')

# 字典差,去交集
def difference(d1,d2):
    return dict([(k,v) for k,v in d1.items() if k not in d2])
da = difference({'a':1,'b':2,'c':3},{'b':2})
print(f'字典差的结果：{da}') # 字典差的结果：{'a': 1, 'c': 3}

# 按键进行排序
def sort_by_key(d):
    return sorted(d.items(),key=lambda x: x[0])   # sorted 函数返回列表，元素为 tuple
ea = sort_by_key({'a':3,'b':1,'c':2,'h':6,'d':12})
print(f'按键进行排序：{ea}') # 按键进行排序：[('a', 3), ('b', 1), ('c', 2), ('d', 12), ('h', 6)]


# 按值排序 与按照键排序原理相同，按照值排序时，key 函数定义为按值（x[1]）⽐较
# d.items() 返回元素为 (key, value) 的可迭代类型（Iterable），key函数的参数 x 便是元素 (key, value)，所以 xN1O 取到字典的值
def sort_by_value(d):
    return sorted(d.items(),key=lambda x: x[1])
fa = sort_by_value({'a':3,'b':1,'c':2,'h':6,'d':12})
print(f'按值进行排序：{fa}') # 按值进行排序：[('b', 1), ('c', 2), ('a', 3), ('h', 6), ('d', 12)]

# 最大键 过 keys 拿到所有键，获取最⼤键，返回 (最⼤键,值) 的元组
def max_key(f):
    if len(f) ==0:
        return []
    max_key = max(f.keys())
    return (max_key,f[max_key])
ja = max_key({'a':3,'b':1,'axks':2,'h':6,'shmaur':12})
print(f'最大键筛选：{ja}') # 最大键筛选：('shmaur', 12)

# 最大字典值，有可能会有多对
def max_keys(d):
    if len(d) ==0:
        return []
    max_val = max(d.values())
    return [(key,max_val) for key in d if d[key]==max_val]

ka = max_keys({'a':3,'b':1,'axks':2,'h':6,'shmaur':12})
print(f'最大值筛选：{ka}') # 最大值筛选：[('shmaur', 12)]

# 集合最值 找出最大、最小值，并装到元组中返回
def max_min(ms):
    return (max(ms),min(ms))
la = max_min({1,2,3,5,6,9,1,50})
print(f'最大值与最小值：{la}') 

# 单字符串  若组成字符串的所有字符仅出现⼀次，则被称为单字符串。
def single(str):
    return len(set(str)) == len(str)
qa = single('love_shmaur')
print(f' 是否是单字符串：{qa}')
qb = single('shmaur')
print(f' 是否是单字符串：{qb}')
qc = single('love shmaur you _ me')
print(f' 是否是单字符串：{qc}')
qd = single('love_python')
print(f' 是否是单字符串：{qd}')

# 更长集合 key 函数定义为按照元素⻓度⽐较⼤⼩，找到更⻓的集合
def longer(s1,s2):
    return max(s1,s2,key=lambda x: len(x))
wa = longer({1,3,5,7},{1,5,7})
print(f' 最长的集合：{wa}')

# 重复最多 在两个列表中，找出重叠次数最多的元素。默认只返回⼀个
# 解决思路：
# 求两个列表的交集
# 遍历交集列表中的每⼀个元素， min(元素在列表 1 次数, 元素在列表 2 次数) ，就是此元素的重叠次数
# 求出最⼤的重叠次数

def max_overlap(lst1,lst2):
    overlap = set(lst1).intersection(lst2)
    ox = [(x,min(lst1.count(x),lst2.count(x))) for x in overlap]
    return max(ox,key=lambda x: x[1])

ra = max_overlap([1,2,2,2,3,3],[2,2,3,2,2,3])
print(f' 交集中的列表数组中出现次数最多的对象：{ra}')

# topn键
# 找出字典前N个最大值对应的键
# 导⼊ Python 内置模块 heapq 中的 nlargest 函数，获取字典中的前n 个最⼤值。
# key 函数定义按值⽐较⼤⼩
def topn_dict(d,nb):
    return nlargest(nb,d,key=lambda x: d[x])
ta = topn_dict({'a': 10, 'b': 8, 'c': 9,'d': 10,'t':15}, 3)
print(f' 输出前三的字典中最大的键：{ta}')

# 一键对多值字典 ⼀键对多个值的实现⽅法 1，按照常规思路，循序渐进：
# 两种方法
ya = {}
yalst = [(1,'apple'),(2,'orange'),(1,'compute')]
for k,v in yalst:
    if k not in ya:
        ya[k]=[]
    ya[k].append(v)
print(ya)
# 使用collections 模块中的defaultdict，它能创建属于某个类型的自带初始值的字典。使用起来更方便
ya2 = defaultdict(list)
for k,v in yalst:
    ya2[k].append(v)
print(ya2)

# 逻辑上合并字典
dic1 = {'x': 1, 'y': 2 }
dic2 = {'y': 3, 'z': 4 }
mergedL = {**dic1, **dic2}  # 修改 merged['x']=10 ，dic1 中的 x 值不变，merged 是重新⽣成的⼀个新字典。
print(mergedL)
mergedL['x'] = 20
print(mergedL)
print(dic1)

# 但是，collections 模块中的 ChainMap 函数却不同，它在内部创建了⼀个容纳这些字典的列表。使⽤ ChainMap 合并字典，修改merged['x']=10 后，dic1 中的 x 值改变
chain = ChainMap(dic1,dic2)
print(chain)
chain['x'] = 80
print(chain)
print(dic1)