标签: dictionary-comprehension

我的目标是使用agg函数聚合 pandas DataFrameGroupBy 对象。

为了做到这一点，我正在生成一个字典，我将使用 dict unpacking through 将其解压为 kwargs **dict。该字典需要包含新列名作为键和元组作为值。元组的第一个值是列名称，该列名称被压缩为一个系列，并作为 的输入提供给第二个值lambda series: ...。

agg_dict = {
   f"{cat_name}_count": ('movement_state', lambda series: series.value_counts()[cat_name]) 
   for cat_name in ml_data['category_column'].cat.categories
}

# Aggregating
agg_ml_data = ml_data.groupby(['col1', 'col2']).agg(**agg_dict)

现在实际发生的事情对我来说有点奇怪。

假设：

ml_data['category_column'].cat.categories

Index(['cat1', 'cat2', 'cat3'], dtype='object')

一组的正确值计数是

one_group['category_column'].value_counts()

     | category_column
cat1 | 2
cat2 | 9
cat3 | 6

一组的预期输出：

一组的实际输出

不知何故，python 对 lambda 函数执行的 dict 理解并不像预期的那样，并且cat3在索引时仅使用最后一个类别值series.value_counts()[cat_name] …

我有字典列表和整数列表

x = [
    {
        "name": "tom",
        "job": "judge"
    },
    {
        "name":"bob",
        "job": "policeman"
    }
]
y = [1000, 2200]

我想压缩它们并将y元素添加到字典中，因为"payroll": y_element 所需的输出将是：

[
    {
        "name": "tom",
        "job": "judge",
        "payroll": 1000
    },
    {
        "name":"bob",
        "job": "policeman",
        "payroll": 2200
    }
]

我实际上是通过以下方式实现的：

z = zip(x, y)
for i in z:
    i[0]["payroll"] = i[1]

z = [i[0] for i in z]

但我想知道是否可以在列表理解中的字典理解中完成。这是我到目前为止所尝试的：

z = [{k: v, "value": o} for d, o in z for k, v in d.items()]

显然这是错误的，因为输出是： …

所以我想知道是否有人可以帮我解决这个问题.

让我们假设我有一本字典:

d = {1: {2: 3}, 4: 5}

我想创建任何包含字典的字典:

wanted_result = {2: 3}

我在想的是这个:

e = {inner_key: d[key][inner_key] for key in d.keys() for inner_key in d[key].keys() if isinstance(d[key], dict)}

然而,这导致我得到一个错误,说int没有密钥,我知道,但我认为我的条件将排除我的例子中的说法4被包括在理解中.

我有2个字典,其中包含相同的键但值对不同.让dictA和dictB代表两个有问题的词典.

dictA = {'key1':'Joe', 'key2':'Bob'}
dictB = {'key1':'Smith', 'key2':'Johnson'}

目前,我正在通过嵌套的if语句创建一个基于常见键的新字典.在这样做时,共享密钥的值包含在新字典中的列表中.见下面的完成:

dictAB = {}  # Create a new dictionary

# Create a list container for dictionary values
for key in dictA.keys():
    dictAB[key] = []

# Iterate through keys in both dictionaries
# Find matching keys and append the respective values to the list container
for key, value in dictA.iteritems():
    for key2, value2 in dictB.iteritems():
        if key == key2:
            dictAB[key].append(value)
            dictAB[key].append(value2)
        else:
            pass

如何使用python字典理解将其变成更干净的结构？

当我遇到问题时,我试图缩短此问题的代码.

基本上,我正在尝试嵌套字典理解并且尝试不成功.这是我试过的.

dict2 = {key:value for key, value in line.split(":")
                   for line in ["1:One", "2:Two", "4:Four"]}
print dict2

当我运行它时,它给了我

NameError: name 'line' is not defined

而且,当我颠倒这样的for陈述时

dict2 = {key:value for line in ["1:One", "2:Two", "4:Four"]
                   for key, value in line.split(":")}
print dict2

它导致了

ValueError: need more than 1 value to unpack

我需要关于dictionary(或list)理解的嵌套结构的帮助.一个例子可以帮助很多.

试图想出一个单行程来实现以下(总结一个键的所有值):

>>> data = [('a',1),('b',3),('a',4),('c',9),('b',1),('d',3)]
>>> res = {}
>>> for tup in data:
...     res[tup[0]] = res.setdefault(tup[0],0) + tup[1]
... 
>>> res
{'a': 5, 'c': 9, 'b': 4, 'd': 3}

单行版本,不使用任何导入,如itertools,集合等.

 { tup[0] : SELF_REFERENCE.setdefault(tup[0],0) + tup[1]  for tup in data }

在Python中是否可以使用对当前正在理解的对象的引用？如果没有,有没有办法在单行中实现这一点而不使用任何导入,即使用基本列表/字典理解和内置函数.

我最近开始学习python，所以我确定很多我不知道的事情可能很容易解决。但是，通过搜索许多问题，我找不到这个问题的答案。

是否可以在字典理解语句中迭代变量？

在寻找答案时，我发现了这一点：

{ _key : _value(_key) for _key in _container }

我现在知道，维奇是一种在理解内循环的方法，但是对于我来说，这需要我能够迭代'_container'中每个'_key'的值。

一个非常基本的例子：

alphabet = 'abcdefghijklmnopqrstuvwxyz'

x = 1

alpha_numbers = {char : x for char in alphabet}

我希望对于“字母”容器中的每个“字符”，“ x”为“ x + = 1”。但是，在字典理解中，我尝试进行迭代的每种方式都会返回“无效语法”错误。

那么，有可能做到吗？还是有更好的方法来做到这一点？

提前致谢。

我想知道是否有更Pythonic的方法可以执行以下操作，也许使用字典理解：

A = some list
D = {}
for i,v in enumerate(A):
    if v in D:
        D[v].append(i)
    else:
        D[v] = [i]

我有一串字母作为输入.
输入:

my_str = 'soumendra_in_stackoverflow'

我想要输出如下.所有元音都应与字典中的相应计数一起打印.
需要输出:

{'a': 2, 'e': 2, 'i': 1, 'o': 3, 'u': 1}

为此我写了以下程序:

ans_dict = {}
for letter in my_str:
    if letter in ['a', 'e', 'i', 'o', 'u']:
        ans_dict[letter] = ans_dict.get(letter, 0) + 1
print(ans_dict)

有用.但是,如何在一行中编写相同的逻辑(可能使用字典理解)而不使用collections.Counter？
我试过这个,但它失败了.

{x: + 1 for x in a if x in ['a', 'e', 'i', 'o', 'u'] }

我在Python3.x中有以下字典列表:

list_of_dictionaries = [{0:3523, 1:3524, 2:3540, 4:3541, 5:3542}, 
                        {0:7245, 1:7246, 2:7247, 3:7248, 5:7249, 6:7250},
                        {1:20898, 2:20899, 3:20900, 4:20901, 5:20902}]

在这种情况下,它是一个包含三个词典的单个列表.

我想有效地将​​它合并到一个单词字典中,列表作为值; 这是正确的答案:

correct = {0:[3523, 7245], 1:[3524, 7246, 20898], 2:[3540, 7247, 20899], 
               3:[7248, 20900], 4:[3541, 20901], 5:[3542, 7249, 20902], 6:[7250]}

我的第一个想法是这样的列表理解:

dict(pair for dictionary in list_of_dictionaries for pair in dictionary.items())

但这是错误的,因为它不包括值列表:

{0: 7245, 1: 20898, 2: 20899, 4: 20901, 5: 20902, 3: 20900, 6: 7250}

我也担心如何有效地创建价值表.它也可能无法扩展到大型列表/大型词典.

我怎么能做到这一点？