combinaciones entre dos listas?

Ha pasado un tiempo y estoy teniendo problemas para entender un algoritmo que bash hacer. Básicamente, tengo dos listas y quiero obtener todas las combinaciones de las dos listas.

Puede que no lo esté explicando correctamente, así que aquí hay un ejemplo.

name = 'a', 'b' number = 1, 2 

La salida en este caso sería:

 1. A1 B2 2. B1 A2 

La parte difícil es que podría tener más elementos en la variable “nombre” que elementos en la variable “número” (el número siempre será igual o menor que la variable del nombre).

Estoy confundido sobre cómo hacer todas las combinaciones (¿nested para bucle?) E incluso más confundido en la lógica para cambiar los elementos en la variable de nombre en el caso de que haya más elementos en nombre de lo que están en la lista de números.

No soy el mejor progtwigdor, pero creo que puedo intentarlo si alguien puede ayudarme a aclarar la lógica / algoritmo para lograrlo. Así que acabo de estar atrapado en nesteds para bucles.

Actualizar:

Aquí está la salida con 3 variables y 2 números:

 name = 'a', 'b', 'c' number = 1, 2 

salida:

 1. A1 B2 2. B1 A2 3. A1 C2 4. C1 A2 5. B1 C2 6. C1 B2 

Supongamos que len(list1) >= len(list2) . Entonces, lo que parece querer es tomar todas las permutaciones de longitud len(list2) de la list1 y relacionarlas con los elementos de la lista2. En python:

 import itertools list1=['a','b','c'] list2=[1,2] [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)]] 

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

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

 >>> a = ["foo", "bar"] >>> b = [1, 2, 3] >>> [(x,y) for x in a for y in b] [('foo', 1), ('foo', 2), ('foo', 3), ('bar', 1), ('bar', 2), ('bar', 3)] 

sin ninguna importación

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 sobre itertools que pueden ayudarlo a encontrar lo que busca.

 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 

Es posible que desee probar una comprensión de lista 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'] 

una pequeña mejora para la respuesta de interjay, para hacer el resultado como una lista plana.

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

referencia de este enlace

Sin itertools

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

Respondiendo a la pregunta “dadas dos listas, busque todas las posibles permutaciones de pares de un elemento de cada lista” y use la funcionalidad básica de Python (es decir, sin itertools) y, por lo tanto, facilitando la replicación para otros lenguajes de progtwigción:

 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) 

Devoluciones

 [['a1', 'b2'], ['a1', 'c2'], ['a2', 'b1'], ['a2', 'c1'], ['b1', 'c2'], ['b2', 'c1']]