blocks|key|455939|text|最简单的方法是使用itertools.product|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|455940|a+=+["foo",+"melon"]
b+=+[True,+False]
c+=+list(itertools.product(a,+b))
>>+[("foo",+True),+("foo",+False),+("melon",+True),+("melon",+False)]|code-block|syntax|javascript|455941|entityMap^0|9|H|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The simplest way is to use <code>itertools.product</code>:

<pre><code>a = ["foo", "melon"]
b = [True, False]
c = list(itertools.product(a, b))
&gt;&gt; [("foo", True), ("foo", False), ("melon", True), ("melon", False)]
</code></pre>

blocks|key|455975|text|可能比上面最简单的一个更简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|455976|>>>+a+=+["foo",+"bar"]
>>>+b+=+[1,+2,+3]
>>>+[(x,y)+for+x+in+a+for+y+in+b]++#+for+a+list
[('foo',+1),+('foo',+2),+('foo',+3),+('bar',+1),+('bar',+2),+('bar',+3)]
>>>+((x,y)+for+x+in+a+for+y+in+b)++#+for+a+generator+if+you+worry+about+memory+or+time+complexity.
<generator+object+<genexpr>+at+0x1048de850>|code-block|syntax|javascript|455977|不需要任何导入|455978|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

May be simpler than the simplest one above:

<pre><code>&gt;&gt;&gt; a = ["foo", "bar"]
&gt;&gt;&gt; b = [1, 2, 3]
&gt;&gt;&gt; [(x,y) for x in a for y in b] # for a list
[('foo', 1), ('foo', 2), ('foo', 3), ('bar', 1), ('bar', 2), ('bar', 3)]
&gt;&gt;&gt; ((x,y) for x in a for y in b) # for a generator if you worry about memory or time complexity.
&lt;generator object &lt;genexpr&gt; at 0x1048de850&gt;
</code></pre>

without any import

blocks|key|456101|text|找出大量列表的所有组合的最佳方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|456102|import+itertools
from+pprint+import+pprint

inputdata+=+[
++++['a',+'b',+'c'],
++++['d'],
++++['e',+'f'],
]
result+=+list(itertools.product(*inputdata))
pprint(result)|code-block|syntax|javascript|456103|结果将是：|456104|[('a',+'d',+'e'),
+('a',+'d',+'f'),
+('b',+'d',+'e'),
+('b',+'d',+'f'),
+('c',+'d',+'e'),
+('c',+'d',+'f')]|456105|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

the best way to find out all the combinations for large number of lists is:

<pre><code>import itertools
from pprint import pprint

inputdata = [
 ['a', 'b', 'c'],
 ['d'],
 ['e', 'f'],
]
result = list(itertools.product(*inputdata))
pprint(result)
</code></pre>

the result will be:

<pre><code>[('a', 'd', 'e'),
 ('a', 'd', 'f'),
 ('b', 'd', 'e'),
 ('b', 'd', 'f'),
 ('c', 'd', 'e'),
 ('c', 'd', 'f')]
</code></pre>

blocks|key|238879|text|您可能希望尝试单行列表理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|238880|>>>+[name%2Bnumber+for+name+in+'ab'+for+number+in+'12']
['a1',+'a2',+'b1',+'b2']
>>>+[name%2Bnumber+for+name+in+'abc'+for+number+in+'12']
['a1',+'a2',+'b1',+'b2',+'c1',+'c2']|code-block|syntax|javascript|238881|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You might want to try a one line list comprehension:

<pre><code>&gt;&gt;&gt; [name+number for name in 'ab' for number in '12']
['a1', 'a2', 'b1', 'b2']
&gt;&gt;&gt; [name+number for name in 'abc' for number in '12']
['a1', 'a2', 'b1', 'b2', 'c1', 'c2']
</code></pre>

blocks|key|239016|text|或者是简短列表的KISS答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|239017|[(i,+j)+for+i+in+list1+for+j+in+list2]|code-block|syntax|javascript|239018|虽然性能不如itertools，但您使用的是python，所以性能已经不是您最关心的问题了……|239019|我也喜欢所有其他的答案！|239020|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Or the KISS answer for short lists:

<pre><code>[(i, j) for i in list1 for j in list2]
</code></pre>

Not as performant as itertools but you're using python so performance is already not your top concern...

I like all the other answers too!

blocks|key|238799|text|对interjay的答案做了一个小小的改进，使结果成为扁平化列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|238800|>>>+list3+=+[zip(x,list2)+for+x+in+itertools.permutations(list1,len(list2))]
>>>+import+itertools
>>>+chain+=+itertools.chain(*list3)
>>>+list4+=+list(chain)
[('a',+1),+('b',+2),+('a',+1),+('c',+2),+('b',+1),+('a',+2),+('b',+1),+('c',+2),+('c',+1),+('a',+2),+('c',+1),+('b',+2)]|code-block|syntax|javascript|238801|来自此link的引用|offset|length|238802|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/406121/flattening-a-shallow-list-in-python^0|0|0|3|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

a tiny improvement for the answer from interjay, to make the result as a flatten list.

<pre><code>&gt;&gt;&gt; list3 = [zip(x,list2) for x in itertools.permutations(list1,len(list2))]
&gt;&gt;&gt; import itertools
&gt;&gt;&gt; chain = itertools.chain(*list3)
&gt;&gt;&gt; list4 = list(chain)
[('a', 1), ('b', 2), ('a', 1), ('c', 2), ('b', 1), ('a', 2), ('b', 1), ('c', 2), ('c', 1), ('a', 2), ('c', 1), ('b', 2)]
</code></pre>

reference from this <a href="https://stackoverflow.com/questions/406121/flattening-a-shallow-list-in-python">link</a>

blocks|key|456285|text|更好的答案只适用于所提供的特定长度的列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|456286|这里有一个版本，适用于任何长度的输入。它还使算法在组合和排列的数学概念方面变得清晰。|456287|from+itertools+import+combinations,+permutations
list1+=+['1',+'2']
list2+=+['A',+'B',+'C']

num_elements+=+min(len(list1),+len(list2))
list1_combs+=+list(combinations(list1,+num_elements))
list2_perms+=+list(permutations(list2,+num_elements))
result+=+[
++tuple(zip(perm,+comb))
++for+comb+in+list1_combs
++for+perm+in+list2_perms
]

for+idx,+((l11,+l12),+(l21,+l22))+in+enumerate(result):
++print(f'{idx}:+{l11}{l12}+{l21}{l22}')|code-block|syntax|javascript|456288|这将输出以下内容：|456289|0:+A1+B2
1:+A1+C2
2:+B1+A2
3:+B1+C2
4:+C1+A2
5:+C1+B2|456290|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The better answers to this only work for specific lengths of lists that are provided.

Here's a version that works for any lengths of input. It also makes the algorithm clear in terms of the mathematical concepts of combination and permutation.

<pre><code>from itertools import combinations, permutations
list1 = ['1', '2']
list2 = ['A', 'B', 'C']

num_elements = min(len(list1), len(list2))
list1_combs = list(combinations(list1, num_elements))
list2_perms = list(permutations(list2, num_elements))
result = [
 tuple(zip(perm, comb))
 for comb in list1_combs
 for perm in list2_perms
]

for idx, ((l11, l12), (l21, l22)) in enumerate(result):
 print(f'{idx}: {l11}{l12} {l21}{l22}')
</code></pre>

This outputs:

<pre><code>0: A1 B2
1: A1 C2
2: B1 A2
3: B1 C2
4: C1 A2
5: C1 B2
</code></pre>

blocks|key|238935|text|回答问题“给定两个列表，从每个列表中找到一个项目对的所有可能的排列”，并使用基本的Python功能(即，没有itertools)，因此，使其易于复制到其他编程语言：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|238936|def+rec(a,+b,+ll,+size):
++++ret+=+[]
++++for+i,e+in+enumerate(a):
++++++++for+j,f+in+enumerate(b):
++++++++++++l+=+[e%2Bf]
++++++++++++new_l+=+rec(a[i%2B1:],+b[:j]%2Bb[j%2B1:],+ll,+size)
++++++++++++if+not+new_l:
++++++++++++++++ret.append(l)
++++++++++++for+k+in+new_l:
++++++++++++++++l_k+=+l+%2B+k
++++++++++++++++ret.append(l_k)
++++++++++++++++if+len(l_k)+==+size:
++++++++++++++++++++ll.append(l_k)
++++return+ret

a+=+['a','b','c']
b+=+['1','2']
ll+=+[]
rec(a,b,ll,+min(len(a),len(b)))
print(ll)|code-block|syntax|javascript|238937|返回|238938|[['a1',+'b2'],+['a1',+'c2'],+['a2',+'b1'],+['a2',+'c1'],+['b1',+'c2'],+['b2',+'c1']]|238939|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Answering the question "given two lists, find all possible permutations of pairs of one item from each list" and using basic Python functionality (i.e., without itertools) and, hence, making it easy to replicate for other programming languages:

<pre><code>def rec(a, b, ll, size):
 ret = []
 for i,e in enumerate(a):
 for j,f in enumerate(b):
 l = [e+f]
 new_l = rec(a[i+1:], b[:j]+b[j+1:], ll, size)
 if not new_l:
 ret.append(l)
 for k in new_l:
 l_k = l + k
 ret.append(l_k)
 if len(l_k) == size:
 ll.append(l_k)
 return ret

a = ['a','b','c']
b = ['1','2']
ll = []
rec(a,b,ll, min(len(a),len(b)))
print(ll)
</code></pre>

Returns

<pre><code>[['a1', 'b2'], ['a1', 'c2'], ['a2', 'b1'], ['a2', 'c1'], ['b1', 'c2'], ['b2', 'c1']]
</code></pre>

I’m having trouble wrapping my head around a algorithm I’m try to implement. I have two lists and want to take particular combinations from the two lists.
Here’s an example.
<pre><code>names = ['a', 'b']
numbers = [1, 2]
</code></pre>
the output in this case would be:
<pre><code>[('a', 1), ('b', 2)]
[('b', 1), ('a', 2)]
</code></pre>
I might have more names than numbers, i.e. <code>len(names) &gt;= len(numbers)</code>. Here's an example with 3 names and 2 numbers:
<pre><code>names = ['a', 'b', 'c']
numbers = [1, 2]
</code></pre>
output:
<pre><code>[('a', 1), ('b', 2)]
[('b', 1), ('a', 2)]
[('a', 1), ('c', 2)]
[('c', 1), ('a', 2)]
[('b', 1), ('c', 2)]
[('c', 1), ('b', 2)]
</code></pre>

Permutations between two lists of unequal length

我在试图实现一个算法时遇到了麻烦。我有两个列表，我想从这两个列表中获取特定的组合。下面是一个例子。names = ['a', 'b']numbers = [1, 2]在这种情况下，输出将是：[('a', 1), ('b', 2)][('b', 1), ('a', 2)]我的名字可能比数字多，比如len(names) >= len(numbers)。下面是一个包含3个名称和2个数字的示例：names

问两个长度不等的列表之间的排列
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问两个长度不等的列表之间的排列EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问两个长度不等的列表之间的排列
EN