todas - permutar una lista python

Generando todas las combinaciones de una lista en python

Question

Aquí está la pregunta:

Dada una lista de elementos en Python, ¿cómo iría para obtener todas las combinaciones posibles de los elementos?

Hay varias preguntas similares en este sitio, que sugieren el uso de itertools.combine, pero que solo devuelve un subconjunto de lo que necesito:

stuff = [1, 2, 3]
for L in range(0, len(stuff)+1):
    for subset in itertools.combinations(stuff, L):
        print(subset)

()
(1,)
(2,)
(3,)
(1, 2)
(1, 3)
(2, 3)
(1, 2, 3)

Como puede ver, devuelve solo los elementos en un orden estricto, no regresa (2, 1), (3, 2), (3, 1), (2, 1, 3), (3, 1, 2), ( 2, 3, 1) y (3, 2, 1). ¿Hay alguna solución que? No puedo pensar en nada.

Answer 1

Aquí hay una solución sin itertools

Primero definamos una traducción entre un vector indicador de 0 y 1 sy una sublista ( 1 si el elemento está en la sublista)

def indicators2sublist(indicators,arr):
   return [item for item,indicator in zip(arr,indicators) if int(indicator)==1]

A continuación, defina una asignación de un número entre 0 y 2^n-1 a su representación de vector binario (utilizando la función de format de cadena):

def bin(n,sz):
   return (''{d:0''+str(sz)+''b}'').format(d=n)

Todo lo que tenemos que hacer es iterar todos los números posibles y llamar a los indicators2sublist

def all_sublists(arr):
  sz=len(arr)
  for n in xrange(0,2**sz):
     b=bin(n,sz)
     yield indicators2sublist(b,arr)

Answer 2

¿Estás buscando itertools.permutations: en itertools.permutations: lugar?

De la help(itertools.permutations) ,

Help on class permutations in module itertools:

class permutations(__builtin__.object)
 |  permutations(iterable[, r]) --> permutations object
 |  
 |  Return successive r-length permutations of elements in the iterable.
 |  
 |  permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)

Código de muestra :

>>> from itertools import permutations
>>> stuff = [1, 2, 3]
>>> for i in range(0, len(stuff)+1):
        for subset in permutations(stuff, i):
               print(subset)


()
(1,)
(2,)
(3,)
(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)

De Wikipedia, la diferencia entre permutaciones y combinaciones:

Permutación:

Informalmente, una permutación de un conjunto de objetos es una disposición de esos objetos en un orden particular. Por ejemplo, hay seis permutaciones del conjunto {1,2,3}, a saber (1,2,3), (1,3,2), (2,1,3), (2,3,1) , (3,1,2) y (3,2,1).

Combinación:

En matemáticas, una combinación es una forma de seleccionar varias cosas de un grupo más grande, donde (a diferencia de las permutaciones) el orden no importa.

Answer 3

Solo pensé en poner esto en el tapete ya que no podía corregir TODOS los posibles resultados y teniendo en cuenta que solo tengo el conocimiento más básico sobre Pitón y probablemente hay una solución mucho más elegante ... (también disculpa) los nombres de las pobres variables

prueba = [1, 2, 3]

testing2 = [0]

n = -1

def testingSomethingElse (número):

try:

    testing2[0:len(testing2)] == testing[0]

    n = -1

    testing2[number] += 1

except IndexError:

    testing2.append(testing[0])

mientras que es cierto:

n += 1

testing2[0] = testing[n]

print(testing2)

if testing2[0] == testing[-1]:

    try:

        n = -1

        testing2[1] += 1

    except IndexError:

        testing2.append(testing[0])

    for i in range(len(testing2)):

        if testing2[i] == 4:

            testingSomethingElse(i+1)

            testing2[i] = testing[0]

Me salí con == 4 porque estoy trabajando con enteros, pero puede que tengas que modificar eso en consecuencia ...

Answer 4

Supongo que quieres todas las combinaciones posibles como ''conjuntos'' de valores. Aquí hay un fragmento de código que escribí que podría ayudarlo a tener una idea:

def getAllCombinations(object_list):
    uniq_objs = set(object_list)
    combinations = []
    for obj in uniq_objs:
        for i in range(0,len(combinations)):
            combinations.append(combinations[i].union([obj]))
        combinations.append(set([obj]))
return combinations

Aquí hay una muestra:

combinations = getAllCombinations([20,10,30])
combinations.sort(key = lambda s: len(s))
print combinations
... [set([10]), set([20]), set([30]), set([10, 20]), set([10, 30]), set([20, 30]), set([10, 20, 30])]

¡Creo que esto tiene n! complejidad del tiempo, así que ten cuidado Esto funciona, pero puede que no sea lo más eficiente

Answer 5

Use itertools.permutations:

>>> import itertools
>>> stuff = [1, 2, 3]
>>> for L in range(0, len(stuff)+1):
        for subset in itertools.permutations(stuff, L):
                print(subset)
...         
()
(1,)
(2,)
(3,)
(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
....

ayuda en itertools.permutations :

permutations(iterable[, r]) --> permutations object

Return successive r-length permutations of elements in the iterable.

permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)
>>> 

Answer 6

itertools.permutations va a ser lo que quieras. Por definición matemática, el orden no tiene importancia para las combinations , lo que significa que (1,2) se considera idéntico a (2,1) . Mientras que con las permutations , cada orden distinto cuenta como una permutación única, entonces (1,2) y (2,1) son completamente diferentes.

Answer 7

Puede generar todas las combinaciones de una lista en python usando este código simple

import itertools

a = [1,2,3,4]
for i in xrange(1,len(a)+1):
   print list(itertools.combinations(a,i))

Resultado:

[(1,), (2,), (3,), (4,)]
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
[(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
[(1, 2, 3, 4)]