问题描述
我正在使用推导式来最小化代码。我想出了如何对列表 l 进行理解,但我似乎无法弄清楚如何对 dict d 进行理解,然后将这两个理解转换为一行 return 语句。任何帮助将不胜感激!
def f(dct:{str:[(str,int,int)]}) -> [str]:
d = dict()
for a,b in dct.items():
count = 0
for x,y,z in b:
if y <= -1:
y = y * -1
count += y
d.update({a:count})
l = list()
for a,count in sorted(d.items(),key=(lambda t:(-t[1],t[0]))):
l.append(a)
return l
解决方法
这似乎是等效的一个班轮:
def f2(dct):
return [a for (a,_) in sorted({a:sum(abs(y) for (_,y,_) in b) for (a,b) in dct.items()}.items(),key=(lambda t:(-t[1],t[0])))]
此版本保留了原始 dict
中具有相等总和的项目按名称顺序排序的属性。
除非我遗漏了一些东西,否则以下内容应该等同于您的功能:
def f(dct:{str:[(str,int,int)]}) -> [str]:
counts = {a: sum(abs(y) for (_,_) in b) for a,b in dct.items()}
return sorted(dct,key=lambda a: (-counts[a],a))
请注意,一般而言,“更少的行”不一定更好、更快或更易读。在这种情况下,我会说这两行是可以的,但是将其设为 一行,虽然可能,但并没有使它变得更好。将 dict 的名称更改为 counts
并在列表推导式中迭代原始 dict 中的值也有助于提高可读性,恕我直言。
此外,您实际上并不需要第一个 dict,因为您只需要每个计数一次(并且这些计数在 lambda
中也只计算一次)。这样,在一行中也不会太可怕。
def f(dct:{str:[(str,int)]}) -> [str]:
return sorted(dct,key=lambda a: (-sum(abs(y) for _,_ in dct[a]),a))
,
您可以将所有循环折叠成嵌套的推导式。由于 dict
从不用于键值访问,因此创建元组生成器更简单;通过直接将计数创建为负数并首先存储它,不需要 lambda
。
def f(dct: 'Dict[str,List[Tuple[str,int]]]') -> 'List[str]':
return [a for _,a in sorted(((-sum(abs(y) for _,_ in b),a) for a,b in dct.items()))]
# ^^ ^ ^ ^ invert one item directly to remove the need for a key function
# || | + instead of an entire dict[str,int],we create a lazy Generator[Tuple[int,str]]
# || + invert order since we store name last
# |+ the str in the list
# + the list we want to return
如果代码不够清晰,通常应该避免这种情况,因为它几乎不可读,至少是可理解的。
稍短的变体:
def f(dct: 'Dict[str,int]]]') -> 'List[str]':
return [*[*zip(*sorted(((-sum(abs(y[1])for y in dct[a]),a)for a in dct))),][1],]
如果任何字符串序列都没有问题:
def f(dct: 'Dict[str,int]]]') -> 'Tuple[str]':
return [*zip(*sorted(((-sum(abs(y[1])for y in dct[a]),][1]