Wie kann ich Permutationen einer langen Liste mit einer kürzeren Liste abgleichen (entsprechend der Länge der kürzeren Liste)? [duplicate]

Question 1

Ich habe Probleme, mich um einen Algorithmus zu kümmern, den ich zu implementieren versuche. Ich habe zwei Listen und möchte bestimmte Kombinationen aus den beiden Listen nehmen.

Hier ist ein Beispiel.

names = ['a', 'b']
numbers = [1, 2]

die Ausgabe wäre in diesem Fall:

[('a', 1), ('b', 2)]
[('b', 1), ('a', 2)]

Ich könnte mehr Namen als Nummern haben, dh len(names) >= len(numbers). Hier ist ein Beispiel mit 3 Namen und 2 Nummern:

names = ['a', 'b', 'c']
numbers = [1, 2]

Ausgang:

[('a', 1), ('b', 2)]
[('b', 1), ('a', 2)]
[('a', 1), ('c', 2)]
[('c', 1), ('a', 2)]
[('b', 1), ('c', 2)]
[('c', 1), ('b', 2)]

Question 2

Der einfachste Weg ist die Verwendung itertools.product:

a = ["foo", "melon"]
b = [True, False]
c = list(itertools.product(a, b))
>> [("foo", True), ("foo", False), ("melon", True), ("melon", False)]

Question 3

Kann einfacher sein als das einfachste oben:

>>> 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>

ohne Import

Question 4

Notiz: Diese Antwort bezieht sich auf die oben gestellte spezifische Frage. Wenn Sie von Google hier sind und nur nach einer Möglichkeit suchen, ein kartesisches Produkt in Python zu erhalten, itertools.product oder ein einfaches Listenverständnis kann das sein, wonach Sie suchen – siehe die anderen Antworten.

Vermuten len(list1) >= len(list2). Was Sie dann zu wollen scheinen, ist, alle Permutationen der Länge zu nehmen len(list2) aus list1 und sie mit Elementen aus list2 abgleichen. In Python:

import itertools
list1=['a','b','c']
list2=[1,2]

[list(zip(x,list2)) for x in itertools.permutations(list1,len(list2))]

Kehrt zurück

[[('a', 1), ('b', 2)], [('a', 1), ('c', 2)], [('b', 1), ('a', 2)], [('b', 1), ('c', 2)], [('c', 1), ('a', 2)], [('c', 1), ('b', 2)]]

Question 5

Ich habe nach einer mit sich selbst multiplizierten Liste mit nur eindeutigen Kombinationen gesucht, die als Funktion bereitgestellt wird.

import itertools
itertools.combinations(list, n_times)

Hier als Auszug aus die Python-Dokumentation auf itertools Das könnte Ihnen helfen, das zu finden, wonach Sie suchen.

Combinatoric generators:

Iterator                                 | Results
-----------------------------------------+----------------------------------------
product(p, q, ... [repeat=1])            | cartesian product, equivalent to a 
                                         |   nested for-loop
-----------------------------------------+----------------------------------------
permutations(p[, r])                     | r-length tuples, all possible 
                                         |   orderings, no repeated elements
-----------------------------------------+----------------------------------------
combinations(p, r)                       | r-length tuples, in sorted order, no 
                                         |   repeated elements
-----------------------------------------+----------------------------------------
combinations_with_replacement(p, r)      | r-length tuples, in sorted order, 
                                         | with repeated elements
-----------------------------------------+----------------------------------------
product('ABCD', repeat=2)                | AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations('ABCD', 2)                  | AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2)                  | AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2) | AA AB AC AD BB BC BD CC CD DD

Question 6

Der beste Weg, um alle Kombinationen für eine große Anzahl von Listen herauszufinden, ist:

import itertools
from pprint import pprint

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

das Ergebnis wird sein:

[('a', 'd', 'e'),
 ('a', 'd', 'f'),
 ('b', 'd', 'e'),
 ('b', 'd', 'f'),
 ('c', 'd', 'e'),
 ('c', 'd', 'f')]

Question 7

Oder die KISS-Antwort für kurze Listen:

[(i, j) for i in list1 for j in list2]

Nicht so leistungsfähig wie itertools, aber Sie verwenden Python, daher ist die Leistung bereits nicht Ihr Hauptanliegen …

Ich mag auch alle anderen Antworten!

Question 8

Vielleicht möchten Sie ein einzeiliges Listenverständnis ausprobieren:

>>> [name+number for name in 'ab' for number in '12']
['a1', 'a2', 'b1', 'b2']
>>> [name+number for name in 'abc' for number in '12']
['a1', 'a2', 'b1', 'b2', 'c1', 'c2']