將多個lambda運算式合并為一行

在一行中實作，使用 lambda 運算式（map/filter/reduce），獲取不同型別串列并回傳具有以下鍵的字典的函式： {'c': , 'i': , 'f': , 'o '：}

'c' 將顯示字串列 'i' 整數串列 'f' 浮點數串列 'o' 任何其他型別的串列

例如串列： myList = ['a', 2, 3, 's', 2.23]

輸出將是：{'c': ['a', 's'], 'i': [2, 3], 'f': [2.23], 'o': []}

到目前為止，我制作了一種有效的方法，但我需要以某種方式更改它的一行代碼：

def q1a(myList):
   myDict = dict.fromkeys(('c', 'i', 'f', 'o'))
   myDict['c'] = list(filter(lambda x: type(x) is str, myList))
   myDict['i'] = list(filter(lambda x: type(x) is int, myList))
   myDict['f'] = list(filter(lambda x: type(x) is float, myList))
   myDict['o'] = list(filter(lambda x: type(x) is not float and type(x) is not int and type(x) is not str, myList))
   return myDict

uj5u.com熱心網友回復：

該作業似乎要求您對此采取功能性方法并創建單個操作。

一種選擇是操作 dict 的單個 reduce。這在 python 中不像在其他語言中那樣自然，因為大多數 dict 操作回傳 None。但是，如果您嘗試，您仍然可以以一種功能性的方式做到這一點（這是一個為了可讀性的（小）改進而分解的單行代碼）：

from functools import reduce

l = ['a', 2, 3, 's', 2.23]

res = reduce(
    lambda d, t: dict(d, **{t[1]: d[t[1]]   [t[0]]}),
    map(lambda el: (el, {str: 'c', int: 'i', float: 'f'}.get(type(el), 'o')) , l),
    dict.fromkeys('cifo', [])
)

print(res)
# {'c': ['a', 's'], 'i': [2, 3], 'f': [2.23], 'o': []}

這是通過使用以下內容創建元組串列來作業的map()：

list(map(lambda el: (el, {str: 'c', int: 'i', float: 'f'}.get(type(el), 'o')) , l),)
# [('a', 'c'), (2, 'i'), (3, 'i'), ('s', 'c'), (2.23, 'f')]

然后更新使用創建的空串列初始化的reduce中的dict dict.fromkeys('cifo', [])。

uj5u.com熱心網友回復：

這繞過了一次分配一個鍵的需要：

def q1a(myList):
   return {
       'c': list(filter(lambda x: type(x) is str, myList)),
       'i': list(filter(lambda x: type(x) is int, myList)),
       'f': list(filter(lambda x: type(x) is float, myList)),
       'o': list(filter(lambda x: type(x) is not float and type(x) is not int and type(x) is not str, myList))
   }

uj5u.com熱心網友回復：

您可以使用以下丑陋的單線

out = dict(zip(['c','i','f','o'], map(list, (filter(lambda x:isinstance(x,str), lst), filter(lambda x:isinstance(x,int), lst), filter(lambda x:isinstance(x,float), lst), filter(lambda x: not isinstance(x,(str,float,int)), lst)))))

您還可以使用functools.reduce輔助函式（不完全是一個班輪，但不需要多個filters，因此可以節省時間）：

def add(d, x):
    d[x[0]].append(x[1])
    return d
from functools import reduce
out = reduce(add, 
             map(lambda x: (('c',x) if isinstance(x,str) 
                            else (('i',x) if isinstance(x,int) 
                                  else (('f',x) if isinstance(x,float) 
                                        else ('o',x)))), lst), 
             {'c':[],'i':[],'f':[],'o':[]})

輸出：

{'c': ['a', 's'], 'i': [2, 3], 'f': [2.23], 'o': []}

uj5u.com熱心網友回復：

如果我用 Python 寫這個，我的第一選擇是跳過函式式方法并使用無聊的for回圈和defaultdict。

from collections import defaultdict


def q1a(myList):
    d = defaultdict(list)
    for v in myList:
        if isinstance(v, str):
            type_code = 'c'
        elif isinstance(v, int):
            type_code = 'i'
        elif isinstnace(v, float):
            type_code = 'f'
        else:
            type_code = 'o'
        d[tc].append(v)
    return d

但是，這建議使用itertools.groupby. 大if陳述句構成了一個簡單的函式，如

def type_code(v):
    if isinstance(v, str):
        type_code = 'c'
    elif isinstance(v, int):
        type_code = 'i'
    elif isinstnace(v, float):
        type_code = 'f'
    else:
        type_code = 'o'
    return type_code

可以寫成適合在 lambda 運算式中使用的單個條件運算式：

 lambda v: ('c' if isinstance(v, str) else 
            'i' if isinstance(v, int) else
            'f' if isinstance(v, float) else
            'o')

在下文中，tc為了便于閱讀，我將縮寫上述 lambda 運算式。

使用itertools.groupby，您可以使用指定每個元素所屬的磁區的函式對（排序的）串列進行磁區。如此產生的磁區適用于字典理解。

from itertools import groupby

def q1a(myList):
    return {k: list(vs) for k, vs in groupby(sorted(myList, key=tc), tc)}

一個小故障：

>>> q1a(['a', 2, 3, 's', 2.23])
{'c': ['a', 's'], 'f': [2.23], 'i': [2, 3]}

結果不包括不是由串列中的值生成的鍵。您必須將結果與dict包含所有鍵的預初始化合并。

def q1a(myList):
    return ({'c': [], 'i': [], 'f': [], 'o': []}
            | {k: list(vs) for k, vs in groupby(sorted(myList, key=tc), tc)})

我不使用，dict.fromKeys("cifo", [])因為每個鍵默認為對同一個空串列的參考，而不是每個鍵的不同空串列。

uj5u.com熱心網友回復：

您可以使用串列推導并創建一個字典文字：

{
    'c': [e for e in myList if type(e) is str],
    'i': [e for e in myList if type(e) is int],
    'f': [e for e in myList if type(e) is float],
    'o': [e for e in myList if type(e) not in {float, int, str}]
}

uj5u.com熱心網友回復：

您可以使用雙重間接將型別轉換為字母并使用 setdefault 來更新生成的字典：

def q1a(myList):
    types  = {str:'c', int:'i', float:'f'}
    myDict = dict()
    for x in myList:
        myDict.setdefault(types.get(type(x),'o'),[]).append(x)
    return myDict

myList = ['a', 2, 3, 's', 2.23]
print(q1a(myList))
{'c': ['a', 's'], 'i': [2, 3], 'f': [2.23]}

使用 defaultdict 可以稍微簡化一下：

from collections import defaultdict

def q1a(myList):
    types  = defaultdict(lambda:'o',{str:'c', int:'i', float:'f'})
    myDict = defaultdict(list)
    for x in myList:
        myDict[types[type(x)]].append(x)
    return dict(myDict)

標籤：Python 列表 字典 筛选 拉姆达

上一篇：我如何計算這個字典串列中的重復單詞

下一篇：用零“填充”串列中缺失的位置