Aquí hay un desglose de cómo usar `ITerTools.Permutations` de manera eficiente, junto con por qué` np.random.permutation` no es adecuado para generar todas las permutaciones:
1. Usando `itererTools.Permutations` (el enfoque recomendado)
`` `Python
Importar iTertools
Def all_permutations (input_list):
"" "
Genera todas las permutaciones posibles de una lista.
Args:
Input_list:la lista para la cual generar permutaciones.
Devoluciones:
Un generador que produce tuplas, donde cada tupla es una permutación.
"" "
return ITerTools.permutations (input_list)
Uso de ejemplo:
my_list =[1, 2, 3]
Permutaciones =all_permutations (my_list)
Para permanentes en las permutaciones:
Imprimir (Perm) # Imprime cada permutación como tupla.
Salida:
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
Para convertir cada permutación en una lista, use:
my_list =[1, 2, 3]
Permutaciones =all_permutations (my_list)
Para permanentes en las permutaciones:
Imprimir (Lista (Perm)) # Imprime cada permutación como una lista
Salida:
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
para obtener todas las permutaciones como una lista de listas:
my_list =[1, 2, 3]
permutaciones =list (all_permutations (my_list)) # convertir el generador en una lista
list_of_lists =[List (Perm) para Perm en Permutaciones] # Convertir la tupla en la lista
print (list_of_lists)
Salida:
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
`` `` ``
Explicación:
* `ITERTOOLS.PERMUTACIONES (Input_list)`: Este es el núcleo de la solución. Devuelve un * iterador * (específicamente, un objeto `permutaciones '). Un iterador es eficiente en la memoria porque genera permutaciones a pedido, una a la vez, en lugar de crearlas todas a la vez en la memoria. Esto es crucial para listas más largas donde el número de permutaciones puede volverse extremadamente grande (n!
* Generador: Usar un generador (el iterador) es importante para la eficiencia. Si convierte el generador en una lista por adelantado (por ejemplo, `List (ITerTools.Permutations (input_list))`), generará * todas las * permutaciones de inmediato, lo que puede conducir a problemas de memoria para listas de entrada más grandes. Procese las permutaciones una por una usando un `for` loop.
* `Tuple` Salida: `ITerTools.Permutations` devuelve cada permutación como una 'tupla'. Si necesita la salida como una `List ', puede convertir la tupla usando` List (Perm) `.
* Eficiencia: `ITerTools.Permutations` se implementa en C y está altamente optimizado para esta tarea. Es la forma más eficiente de generar permutaciones en Python.
2. Por qué `np.random.permutation` es inadecuado
`np.random.permutation` está diseñado para generar permutaciones * aleatorias *, no todas ellas. He aquí por qué no funcionará correctamente para el propósito previsto:
* aleatoriedad: Genera una sola permutación aleatoria cada vez que la llame.
* No hay garantía de todas las permutaciones: Para obtener * todas * permutaciones con `np.random.permutation`, necesitaría llamarlo repetidamente hasta que haya visto todo n! posibilidades. No hay forma de saber cuándo ha agotado todas las permutaciones sin realizar un seguimiento de las que ya ha visto, lo que se vuelve extremadamente complejo e ineficiente. No hay garantía de que alguna vez generará todas las permutaciones posibles de esta manera.
* repetición ineficiente: Estarías generando muchas permutaciones duplicadas antes (tal vez nunca) verlas a todos.
Incorrecto (e ineficiente) intente usar `np.random.permutation` (solo propósitos ilustrativos - no use):
`` `Python
importar numpy como np
def int_all_permutations_with_numpy (input_list):
"" "
¡No uses esto! Es un intento incorrecto e ineficiente
Para generar todas las permutaciones usando np.random.permutation.
"" "
Seen_Permutations =set ()
all_perms =[]
n =len (input_list)
Factorial_n =np.math.factorial (n) # ¡Esto podría desbordarse!
Mientras que Len (Seen_Permutations)
Si permanente no en STIVE_PERMUTACIONES:
Seen_Permutations.Add (Perm)
all_perms.append (List (Perm))
return todas_perms
my_list =[1, 2, 3]
`` `` ``
Problemas con el intento numpy:
* Problemas de memoria: El conjunto `Seen_Permutations` crecería rápidamente a un tamaño enorme, que podría exceder la memoria disponible, especialmente para listas ligeramente más grandes.
* Eficiencia: La condición de bucle `len (Seen_Permutations)
* Tuple Conversion: La conversión de matrices numpy a tuplas y de regreso a las listas es una sobrecarga que `` IterTools 'evita.
En resumen:
Para generar todas las permutaciones posibles de una lista en Python, siempre use `ITerTools.Permutations` . Es la forma correcta, más eficiente y pitónica de resolver este problema. Evite usar `np.random.permutation` para este propósito, ya que está diseñado para una tarea diferente y conducirá a un código incorrecto e ineficiente.
¡No use este ejemplo! Es solo para la demostración de por qué es incorrecto.
Permutations =intit_all_permutations_with_numpy (my_list) # potencialmente colgada o usa memoria excesiva.
imprime (permutaciones)