Python defaultdict-添加另一个键？

我可能没有在这里使用正确的词，但基本上我想在提供的第一个键旁边添加另一个键

这就是我目前拥有的：

def transform_result(self, data):
    type_map = defaultdict(list)
    for entry in data:
        type_map[entry['type']].append({
            'id': entry['id'],
            'tag': entry['tag'],
        })
    ret = []
    for key, value, in type_map.items():
        ret.append({
            'type': key,
            'tags': value,
        })
    return ret

输入：

[
    OrderedDict([
        ('id', 1),
        ('type', 'Color'),
        ('writable', True),
        ('tag', 'Blue')
    ]),
    OrderedDict([
        ('id', 2),
        ('type', 'Color'),
        ('writable', True),
        ('tag', 'Red')
    ]),
    OrderedDict([
        ('id', 3),
        ('type', 'Color'),
        ('writable', True),
        ('tag', 'Green')
    ]),
    OrderedDict([
        ('id', 4),
        ('type', 'Shape'),
        ('writable', False),
        ('tag', 'Square')
    ]),
    OrderedDict([
        ('id', 5),
        ('type', 'Shape'),
        ('writable', False),
        ('tag', 'Circle')
    ])
]

期望输出：

[
    {
        'type': 'Color',
        'writable': True,
        'tags': [
            {
                'tag': 'Blue',
                'id': 1
            },
            {
                'tag': 'Red',
                'id': 2
            },
            {
                'tag': 'Green',
                'id': 3
            }
        ]
    },
    {
        'type': 'Shape',
        'writable': False,
        'tags': [
            {
                'tag': 'Square',
                'id': 4
            },
            {
                'tag': 'Circle',
                'id': 5
            },

        ]
    },
]

如何做到这一点

---

编辑：我明白了，对不起，我完全躲开了。以下是我的黑客解决方案：

def transform_result(self, data):
    type_map = defaultdict(list)
    for entry in data:
        type_map[entry['type'], entry['many']].append({
            'id': entry['id'],
            'tag': entry['tag'],
        })
    ret = []
    for key, value, in type_map.items():
        ret.append({
            'type': key[0],
            'many': key[1],
            'tags': value
        })
    return ret

---

基本上，让我困惑的是如何在第一个循环完成后访问

many

。我的解决方案是快速将

类型

和

多个

放在一个小列表中，然后使用

[0]

和

[1]

访问它们，这样做很有效

这里有一个建议，注意这个解决方案是n*lg（n），你可以用n来解决这个问题，但是如果你没有非常大的数据集，那就没关系了。用它作为灵感；）

从集合导入订单数据
从itertools导入groupby
从运算符导入itemgetter
从pprint导入pprint
foo=[
有序的([
（'id'，1），
（‘类型’、‘颜色’），
（“可写”，正确），
（“标签”，“蓝色”）
]),
...
...
...
有序的([
（'id'，5），
（‘类型’、‘形状’），
（“可写”，假），
（“标记”、“圆圈”）
])
]
def转换_结果（数据）：
key\u func=itemgetter（'type'）
对于g，groupby中的项目（已排序（foo，key=key\u func，key=key\u func）：
项={'type'：g，'tags'：[]}
对于项目中的i：
项目['writable']=i['writable']
项['tags'].append（{'tag'：i['tag']，'id'：i['id']}）
收益项目
pprint（列表（转换结果（foo）））

输出

[{'tags': [{'id': 1, 'tag': 'Blue'},
           {'id': 2, 'tag': 'Red'},
           {'id': 3, 'tag': 'Green'}],
  'type': 'Color',
  'writeable': True},
 {'tags': [{'id': 4, 'tag': 'Square'}, {'id': 5, 'tag': 'Circle'}],
  'type': 'Shape',
  'writeable': False}]

---

这里有一个建议，注意这个解决方案是n*lg（n），你可以用n来解决这个问题，但是如果你没有非常大的数据集，那就没关系了。用它作为灵感；）

从集合导入订单数据
从itertools导入groupby
从运算符导入itemgetter
从pprint导入pprint
foo=[
有序的([
（'id'，1），
（‘类型’、‘颜色’），
（“可写”，正确），
（“标签”，“蓝色”）
]),
...
...
...
有序的([
（'id'，5），
（‘类型’、‘形状’），
（“可写”，假），
（“标记”、“圆圈”）
])
]
def转换_结果（数据）：
key\u func=itemgetter（'type'）
对于g，groupby中的项目（已排序（foo，key=key\u func，key=key\u func）：
项={'type'：g，'tags'：[]}
对于项目中的i：
项目['writable']=i['writable']
项['tags'].append（{'tag'：i['tag']，'id'：i['id']}）
收益项目
pprint（列表（转换结果（foo）））

输出

[{'tags': [{'id': 1, 'tag': 'Blue'},
           {'id': 2, 'tag': 'Red'},
           {'id': 3, 'tag': 'Green'}],
  'type': 'Color',
  'writeable': True},
 {'tags': [{'id': 4, 'tag': 'Square'}, {'id': 5, 'tag': 'Circle'}],
  'type': 'Shape',
  'writeable': False}]

---

我不能说我喜欢您的数据模型，但对于给定的输入和期望的输出，您几乎拥有了它：

def transform_result(self, data):
    type_map = defaultdict(list)
    for entry in data:
        type_map[entry['type'], entry['writable']].append({
            'id': entry['id'],
            'tag': entry['tag'],
        })
    ret = []
    for (k_type, k_writable), value in type_map.items():
        ret.append({
            'type': k_type,
            'writable': k_writable,
            'tags': value,
        })
    return ret

---

我不能说我喜欢您的数据模型，但对于给定的输入和期望的输出，您几乎拥有了它：

def transform_result(self, data):
    type_map = defaultdict(list)
    for entry in data:
        type_map[entry['type'], entry['writable']].append({
            'id': entry['id'],
            'tag': entry['tag'],
        })
    ret = []
    for (k_type, k_writable), value in type_map.items():
        ret.append({
            'type': k_type,
            'writable': k_writable,
            'tags': value,
        })
    return ret

---

你能不能提供一个更清晰的目标描述而不是一个简单的描述？在输入和输出中，围绕为单个缺少的键添加值构建了一个

defaultdict

；如果您想要其他东西，您最好从

类神话（dict）

开始。不需要检查

可写

键是否存在，只需要将其附加到与键本身相同的级别。对于不匹配的

类型

和

可写

，会发生什么情况？因为在本例中，

颜色

始终是

可写的

，

形状

始终是

假的

这种情况在我使用的数据中不存在，但如果确实存在，它应该创建一个新条目。请您提供一个更清晰的目标描述，而不是一个新条目？在输入和输出中，围绕为单个缺少的键添加值构建了一个

defaultdict

；如果您想要其他东西，您最好从

类神话（dict）

开始。不需要检查

可写

键是否存在，只需要将其附加到与键本身相同的级别。对于不匹配的

类型

和

可写

，会发生什么情况？因为在这个例子中，

Color

总是

writeable

，

Shape

总是

False

，这种情况在我使用的数据中并不存在，但是如果发生了，它应该创建一个新条目。如果数据集不是很大，那么使用生成器方法似乎有点过头了，你不觉得吗？在每次迭代中，您不必更新

项['writeable']

，而可以将该赋值移到内部循环之外。如果在

屈服

之前执行此操作，您将有相同的行为，如果将其移动到内部循环之前，您将考虑第一个元素而不是最后一个元素。请注意，根据评论（原始答案中没有可用的信息），这两种行为都不是所希望的。如果数据集不是很大，那么使用生成器方法似乎有点过头了，你不觉得吗？在每次迭代中，您不必更新

项['writeable']

，而可以将该赋值移到内部循环之外。如果在

屈服

之前执行此操作，您将有相同的行为，如果将其移动到内部循环之前，您将考虑第一个元素而不是最后一个元素。请注意，根据评论（原始答案中没有可用的信息），这些行为都不是我想要的。我更喜欢你的解决方案，它似乎最符合我想要实现的目标。我不知道变量可以这样嵌套分配，非常整洁！谢谢。我更喜欢你的解决方案，它似乎最符合我想要实现的目标。我不知道变量可以这样嵌套分配，非常整洁！谢谢