¿Cómo puedo unir permutaciones de una lista larga con una lista más corta (según la longitud de la lista más corta)? [duplicate]

Question 1

Tengo problemas para entender un algoritmo que estoy tratando de implementar. Tengo dos listas y quiero tomar combinaciones particulares de las dos listas.

Aquí hay un ejemplo.

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

la salida en este caso sería:

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

Podría tener más nombres que números, es decir len(names) >= len(numbers). Aquí hay un ejemplo con 3 nombres y 2 números:

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

producción:

[('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

La forma más sencilla es usar itertools.product:

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

Question 3

Puede ser más simple que el más simple de arriba:

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

sin ninguna importación

Question 4

Nota: Esta respuesta es para la pregunta específica formulada anteriormente. Si está aquí desde Google y solo está buscando una manera de obtener un producto cartesiano en Python, itertools.product o una lista simple de comprensión puede ser lo que está buscando; vea las otras respuestas.

Suponer len(list1) >= len(list2). Entonces lo que parece querer es tomar todas las permutaciones de longitud len(list2) de list1 y combínalos con elementos de list2. En pitón:

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

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

Devoluciones

[[('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

Estaba buscando una lista multiplicada por sí misma con solo combinaciones únicas, que se proporciona como esta función.

import itertools
itertools.combinations(list, n_times)

Aquí como un extracto de los documentos de Python en itertools Eso podría ayudarte a encontrar lo que estás buscando.

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

la mejor manera de averiguar todas las combinaciones para una gran cantidad de listas es:

import itertools
from pprint import pprint

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

el resultado será:

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

Question 7

O la respuesta de KISS para listas cortas:

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

No es tan eficaz como itertools, pero está utilizando Python, por lo que el rendimiento ya no es su principal preocupación…

¡Me gustan todas las otras respuestas también!

Question 8

Es posible que desee probar una lista de comprensión de una línea:

>>> [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']

¿Ha sido útil esta solución?