Embora `np.random.permutação` da Numpy seja excelente para gerar uma * permutação aleatória *, não é a ferramenta para gerar * todas * permutações. Para gerar todas as permutações possíveis com eficiência, você deve usar a função `` itetools.permutações` na biblioteca padrão. Numpy geralmente não é necessário para esta tarefa, e `` itetools` é altamente otimizado para geração de permutação.
Aqui está um detalhamento de como usar o `` itetools.permutações` eficientemente, juntamente com o motivo pelo qual `np.random.permutação` não é adequado para gerar todas as permutações:
1. Usando `itetools.permutações` (a abordagem recomendada) `` `Python
importar itterols
def All_perMutações (input_list):
"" "
Gera todas as permutações possíveis de uma lista.
Args:
input_list:a lista para que gerar permutações.
Retornos:
Um gerador produz tuplas, onde cada tupla é uma permutação.
"" "
Retornar o itterols.permutações (input_list)
Exemplo de uso:
my_list =[1, 2, 3]
permutações =all_permutações (my_list)
Para Perm em Permutações:
Imprimir (Perm) # imprime cada permutação como uma tupla.
Saída:
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
Para converter cada permutação em uma lista, use:
my_list =[1, 2, 3]
permutações =all_permutações (my_list)
Para Perm em Permutações:
Imprimir (List (Perm)) # imprime cada permutação como uma lista
Saída:
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
Para obter todas as permutações como uma lista de listas:
my_list =[1, 2, 3]
permutações =list (all_permutações (my_list)) # converte o gerador em uma lista
list_of_lists =[List (Perm) para Perm em Permutações] # Converter Tuple para listar
print (list_of_lists)
Saída:
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
`` `
Explicação: *
`itetools.permutations (input_list)`: Este é o núcleo da solução. Ele retorna um * iterador * (especificamente, um objeto `permutações`). Um iterador é eficiente em termos de memória porque gera permutações sob demanda, uma de cada vez, em vez de criá-las de uma só vez na memória. Isso é crucial para listas mais longas, onde o número de permutações pode se tornar extremamente grande (n! Cresce muito rapidamente).
*
gerador: O uso de um gerador (o iterador) é importante para a eficiência. Se você converter o gerador em uma lista antecipada (por exemplo, `list (itertools.permutações (input_list))`), você gerará * todas as * permutações imediatamente, o que pode levar a problemas de memória para listas de entrada maiores. Processe as permutações uma a uma usando um `para` loop.
*
`tuple` saída: `itetools.permutações 'retorna cada permutação como uma' tupla '. Se você precisar da saída como uma `List`, poderá converter a tupla usando` List (Perm) `.
*
Eficiência: `itetools.permutações` é implementado em C e é altamente otimizado para esta tarefa. É a maneira mais eficiente de gerar permutações no Python.
2. Por que `np.random.permuation` é inadequado `np.random.permuation` foi projetado para gerar * permutações aleatórias *, nem todas elas. Eis por que não funcionará corretamente para o objetivo pretendido:
*
Randomismo: Ele gera uma única permutação aleatória cada vez que você chama.
*
Nenhuma garantia de todas as permutações: Para obter * All * Permutações com `np.random.permuation`, você precisaria chamá -lo repetidamente até ver todos n! possibilidades. Não há como saber quando você esgotou todas as permutações sem acompanhar as que você já viu, o que se torna extremamente complexo e ineficiente. Não há garantia de que você jamais gerará todas as permuções possíveis dessa maneira.
*
Repetição ineficiente: Você estaria gerando muitas permutações duplicadas antes (talvez nunca) vendo todas elas.
Incorreto (e ineficiente) Tente usar `np.random.permuation` (apenas fins ilustrativos - não use): `` `Python
importar numpy como np
DEF TENT_ALL_PERMUTATIONS_WITH_NUMPY (input_list):
"" "
Não use isso! É uma tentativa incorreta e ineficiente
Para gerar todas as permutações usando o np.random.permutação.
"" "
VELHO_PERMUTATIONS =Set ()
all_perms =[]
n =len (input_list)
fatorial_n =np.math.factorial (n) # Isso pode transbordar!
Enquanto Len (viu_permutações)
Perm =tupla (np.random.permutação (input_list)) # converta para tupla para o conjunto
Se não for em VELHE_PERMUTATIONS:
viu_permutations.add (Perm)
all_perms.append (List (Perm))
retornar all_perms
Não use este exemplo! É apenas para demonstrar por que está incorreto.
my_list =[1, 2, 3]
Permutações =TentM_All_Permutations_with_numpy (my_list) # potencialmente pendura ou usa memória excessiva.
Imprimir (permutações)
`` `
Problemas com a tentativa Numpy:
* problemas de memória: O conjunto `visto_permutações` aumentaria rapidamente para um tamanho enorme, potencialmente excedendo a memória disponível, especialmente para listas um pouco maiores.
* Eficiência: A condição do loop `len (vista_permutações) * Incorreção: É possível (embora estatisticamente improvável) que o loop termine prematuramente ou nunca termine devido à natureza aleatória da geração de permutação.
* conversão de tupla: A conversão de matrizes Numpy em tuplas e volta às listas é uma sobrecarga que 'ITERTOOLS' evita.
em resumo:
Para gerar todas as permutações possíveis de uma lista em Python, sempre use `itetools.permutações` . É a maneira correta, mais eficiente e pitônica de resolver esse problema. Evite usar o `np.random.permuation` para esse fim, pois foi projetado para uma tarefa diferente e levará a um código incorreto e ineficiente.
