Medan `np.random.permutation` från numpy är utmärkt för att generera en * slumpmässig * permutation, är det inte verktyget för att generera * alla * permutationer. För att generera alla möjliga permutationer effektivt bör du använda funktionen "Itertools.Permutations" från standardbiblioteket. Numpy behövs vanligtvis inte för den här uppgiften, och `itertools` är mycket optimerad för permutation.
Här är en uppdelning av hur man använder `itertools.Permutations 'effektivt, tillsammans med varför` np.random.Permutation' inte är lämpligt för att generera alla permutationer:
1. Använda `iterTools.PerMutations '(den rekommenderade metoden)
`` `python
Importera Itertools
def all_permutations (input_list):
"" "
Genererar alla möjliga permutationer av en lista.
Args:
input_list:listan för att generera permutationer.
Returnerar:
En generator som ger tuples, där varje tupel är en permutation.
"" "
returnera itertools.permutations (input_list)
Exempel Användning:
my_list =[1, 2, 3]
permutationer =all_permutations (my_list)
För perm i permutationer:
Print (perm) # skriver ut varje permutation som en tupel.
utgång:
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
För att konvertera varje permutation till en lista, använd:
my_list =[1, 2, 3]
permutationer =all_permutations (my_list)
För perm i permutationer:
tryck (lista (perm)) # skriver ut varje permutation som en lista
utgång:
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
för att få alla permutationer som en lista med listor:
my_list =[1, 2, 3]
permutations =lista (all_permutations (my_list)) # konvertera generatorn till en lista
list_of_lists =[List (perm) för perm i permutationer] # Konvertera tuple till lista
tryck (list_of_lists)
utgång:
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
`` `
Förklaring:
* `iterTools.PerMutations (input_list)`: Detta är kärnan i lösningen. Den returnerar en * iterator * (specifikt ett "permutations" -objekt). En iterator är minneseffektiv eftersom den genererar permutationer på begäran, en åt gången, istället för att skapa dem alla på en gång i minnet. Detta är avgörande för längre listor där antalet permutationer kan bli extremt stort (n! Växer mycket snabbt).
* Generator: Att använda en generator (iteratorn) är viktigt för effektiviteten. Om du konverterar generatorn till en lista i förväg (t.ex. "List (itertools.permutations (input_list))`) kommer du att generera * alla * permutationer omedelbart, vilket kan leda till minnesproblem för större ingångslistor. Behandla permutationerna en efter en med en "för" -slinga.
* `tupel" -utgång: `iterTools.PerMutations 'returnerar varje permutation som en" tupel ". Om du behöver utgången som en "lista" kan du konvertera tupeln med hjälp av "Perm)".
* Effektivitet: `iterTools.PerMutations 'implementeras i C och är mycket optimerad för denna uppgift. Det är det mest effektiva sättet att generera permutationer i Python.
2. Varför `np.random.permutation` är olämpligt
`np.random.permutation` är utformad för att generera * slumpmässiga * permutationer, inte alla. Här är därför det inte fungerar korrekt för det avsedda syftet:
* slumpmässighet: Det genererar en enda slumpmässig permutation varje gång du kallar det.
* Ingen garanti för alla permutationer: För att få * alla * permutationer med `np.random.permutation`, måste du upprepade gånger ringa det tills du har sett alla n! Möjligheter. Det finns inget sätt att veta när du har uttömt alla permutationer utan att hålla reda på de du redan har sett, vilket blir extremt komplicerat och ineffektivt. Det finns ingen garanti att du någonsin kommer att generera alla möjliga permutationer på detta sätt.
* ineffektiv upprepning: Du skulle generera många duplicerade permutationer innan så småningom (kanske aldrig) ser alla.
Felaktigt (och ineffektivt) försök att använda `np.random.permutation` (endast illustrativa ändamål - använd inte):
`` `python
Importera numpy som NP
def försök_all_permutations_with_numpy (input_list):
"" "
Använd inte detta! Det är ett felaktigt och ineffektivt försök
För att generera alla permutationer med np.random.permutation.
"" "
seen_permutations =set ()
all_perms =[]
n =len (input_list)
factorial_n =np.math.factorial (n) # Detta kan flyta över!
medan len (seen_permutations)
perm =tuple (np.random.permutation (input_list)) # konvertera till tuple för set
Om perm inte i Sheat_Permutations:
Sheate_Permutations.Add (Perm)
all_perms.append (lista (perm))
returnera all_perms
Använd inte det här exemplet! Det är bara för demonstration av varför det är felaktigt.
my_list =[1, 2, 3]
permutations =försök_all_permutations_with_numpy (my_list) # hänga eventuellt eller använder överdrivet minne.
tryck (permutationer)
`` `
Problem med Numpy -försöket:
* Minnesfrågor: Uppsättningen `Seene_Permutations 'skulle snabbt växa till en enorm storlek, vilket potentiellt överstiger tillgängligt minne, särskilt för något större listor.
* Effektivitet: Loop -tillståndet `len (seen_permutations)
* Felaktighet: Det är möjligt (även om det är statistiskt osannolikt) för slingan att avsluta för tidigt eller aldrig avbryta på grund av den slumpmässiga karaktären av permutation.
* tupelkonvertering: Att konvertera numpy -matriser till tuples och tillbaka till listor är en overhead som "Itertools" undviker.
Sammanfattningsvis:
För att generera alla möjliga permutationer av en lista i Python, Använd alltid `itertools.permutations` . Det är det korrekta, mest effektiva och pythoniska sättet att lösa detta problem. Undvik att använda `np.random.permutation` för detta ändamål, eftersom det är utformat för en annan uppgift och kommer att leda till felaktig och ineffektiv kod.
