blocks|key|1283622|text|>>>+d+=+{'key1':+[1,+2,+3],+'key2':+[4,+5,+6],+'key3':+[7,+8,+9]}
>>>+keys+=+d.keys()
>>>+[dict(zip(keys,+vals))+for+vals+in+zip(*(d[k]+for+k+in+keys))]
[{'key3':+7,+'key2':+4,+'key1':+1},
+{'key3':+8,+'key2':+5,+'key1':+2},
+{'key3':+9,+'key2':+6,+'key1':+3}]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283623|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|740501|text|先拿钥匙。在这个阶段你可以对它们进行排序或者任何你喜欢的东西。也许您知道按什么顺序使用什么键，所以不需要检查数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|740502|keys+=+list(d.keys())|code-block|syntax|javascript|740503|定义命名元组：|740504|Record+=+collections.namedtuple('Record',+keys)|740505|并行迭代所有列表：|740506|[Record(*t)+for+t+in+zip(*(d[k]+for+k+in+keys))]|740507|或者list(map(Record,+*(d[k]+for+k+in+keys)))，如果你喜欢map。|offset|length|style|CODE|740508|注意，如果keys只是list(d.keys())，那么您可以使用d.values()代替(d[k]+for+k+in+keys)，因为即使字典中的键顺序是任意的，它也保证与值的顺序相同。因此，如果您不关心namedtuple中字段的顺序，那么它简化为：|740509|Record+=+collections.namedtuple('Record',+d.keys())
[Record(*t)+for+t+in+zip(*(d.values()))]|740510|或者list(map(Record,+*d.values()))，如果你喜欢map。|740511|entityMap^0|0|0|0|0|0|0|2|14|1C|3|0|5|4|B|E|X|A|19|K|0|0|2|U|12|3|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@$Q|19|R|1A|S|T]|$Q|1B|R|1C|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@$Q|1E|R|1F|S|T]|$Q|1G|R|1H|S|T]|$Q|1I|R|1J|S|T]|$Q|1K|R|1L|S|T]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1N|8|@$Q|1O|R|1P|S|T]|$Q|1Q|R|1R|S|T]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|11|$]]

First get the keys. You could sort them or whatever you like at this stage. Maybe you know what keys to use in what order, so you don't need to examine the data.

<pre><code>keys = list(d.keys())
</code></pre>

Define the named tuple:

<pre><code>Record = collections.namedtuple('Record', keys)
</code></pre>

Iterate all the lists in parallel:

<pre><code>[Record(*t) for t in zip(*(d[k] for k in keys))]
</code></pre>

or <code>list(map(Record, *(d[k] for k in keys)))</code> if you like <code>map</code>.

Note that if <code>keys</code> is just <code>list(d.keys())</code> then you can use <code>d.values()</code> in place of <code>(d[k] for k in keys)</code>, because even though the order of keys in the dictionary is arbitrary it's guaranteed to be the same as the order of values. So if you don't care about the order of the fields in the namedtuple then it simplifies to:

<pre><code>Record = collections.namedtuple('Record', d.keys())
[Record(*t) for t in zip(*(d.values()))]
</code></pre>

or <code>list(map(Record, *d.values()))</code> if you like <code>map</code>.

blocks|key|740531|text|根据乔杜里的回答，我开发了一个基于发电机的解决方案。这可能会有帮助，当迪克特是巨大的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|740532|def+zip_dict(d):
++++for+vals+in+zip(*(d.values())):
++++++++yield+dict(zip(d.keys(),+vals))|code-block|syntax|javascript|740533|示例用法：|740534|d+=+dict(
++++x=[1,3,5,7,9],
++++y=[2,4,6,8,10]
)

for+t+in+zip_dict(d):
++++print(t)|740535|其结果将是：|740536|{'x':+1,+'y':+2}
{'x':+3,+'y':+4}
{'x':+5,+'y':+6}
{'x':+7,+'y':+8}
{'x':+9,+'y':+10}|740537|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Based on Chaudhary's answer, I developed a generator-based solution. This might be helpful when the dict is huge.
<pre><code>def zip_dict(d):
 for vals in zip(*(d.values())):
 yield dict(zip(d.keys(), vals))
</code></pre>
Example usage:
<pre><code>d = dict(
 x=[1,3,5,7,9],
 y=[2,4,6,8,10]
)

for t in zip_dict(d):
 print(t)
</code></pre>
The result would be:
<pre><code>{'x': 1, 'y': 2}
{'x': 3, 'y': 4}
{'x': 5, 'y': 6}
{'x': 7, 'y': 8}
{'x': 9, 'y': 10}
</code></pre>

I have a dictionary of lists, and I want to merge them into a single list of namedtuples. I want the first element of all the lists in the first tuple, the second in the second and so on. 

Example:

<pre><code>{'key1': [1, 2, 3], 'key2': [4, 5, 6], 'key3': [7, 8, 9]}
</code></pre>

And I want the resulting list to be like this:

<pre><code>[('key1': 1, 'key2': 4, 'key3': 7), 
('key1': 2, 'key2': 5, 'key3': 8), 
('key1': 3, 'key2': 6, 'key3': 9)]
</code></pre>

I assume there is an elegant way of doing this?

Edit:

I have compared running times of @Steve Jessop's namedtuple answer to the dictionary version by @Ashwini Chaudhary, and the former is somewhat faster: 

<pre><code>d = {key: numpy.random.random_integers(0, 10000, 100000) 
 for key in ['key1', 'key2', 'key3']}
</code></pre>

Avg. of 100 runs:

<pre><code>namedtuple and map: 0.093583753109
namedtuple and zip: 0.119455988407
dictionary and zip: 0.159063346386
</code></pre>

'Zip' dictionary of lists in Python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个列表字典，我想将它们合并成一个名称元组列表。我想要第一个元组中所有列表的第一个元素，第二个元素在第二个元组中等等。示例：{'key1': [1, 2, 3], 'key2': [4, 5, 6], 'key3': [7, 8, 9]}我希望得到的列表是这样的：[('key1': 1, 'key2': 4, 'k...

问Python中列表的‘Zip字典
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中列表的‘Zip字典EN