I Python har blanding af en talsekvens altid været et nyttigt værktøj, og det spørgsmål, der også er dukket op i mange virksomhedsinterviews. At kende mere end én metode til at opnå dette kan altid være et plus. Lad os diskutere visse måder, hvorpå dette kan opnås.
Python Tilfældig bland en liste
I Python, der er flere måder at blande en liste på. Her er forskellige Python-måder til at blande lister.
- Brug sorteret()
- Brug af random.shuffle()
- Brug af random.sample()
- Brug af tilfældig udvælgelsesmetode
- Brug af Fisher-Yates shuffle-algoritme
- Bruger itertools.permutations() funktion
- Bruger NumPy
Bland en liste tilfældigt ved hjælp af sorted()
En sorteret version af listen kan fremstilles ved hjælp af sorteret() fungere. Vi blander effektivt elementerne tilfældigt ved at bruge dem på en kopi af listen, der er blevet blandet.
Python3
import> random> my_list>=> [>1>,>2>,>3>,>4>,>5>]> shuffled_list>=> sorted>(my_list, key>=>lambda> x: random.random())> print>(>'Original list:'>, my_list)> print>(>'Shuffled list:'>, shuffled_list)> |
>
>
Produktion
Original list: [1, 2, 3, 4, 5] Shuffled list: [2, 3, 4, 5, 1]>
Tidskompleksitet: O(nlogn), hvor n er længden af listen
Rumkompleksitet: O(n), hvor n er længden af listen
Randomiser en liste ved hjælp af Random.Shuffle()
Random.Shuffle() er den mest anbefalede metode til at blande en liste. Python i sit tilfældige bibliotek giver denne indbyggede funktion, som på stedet blander listen. Ulempen ved dette er, at listerækkefølgen går tabt i denne proces. Nyttigt for udviklere, der vælger at spare tid og travlhed.
Python3
import> random> test_list>=> [>1>,>4>,>5>,>6>,>3>]> print>(>'The original list is : '> +> str>(test_list))> # using random.shuffle() to shuffle a list> random.shuffle(test_list)> print>(>'The shuffled list is : '> +> str>(test_list))> |
>
>
Produktion
binær søgealgoritme
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [5, 1, 3, 4, 6]>
Tidskompleksitet: O(n), hvor n er længden af listen
Rumkompleksitet: O(n), hvor n er længden af listen
Randomiser en liste u syng Random.Sample()
Random.Sample(), Dette er en ganske nyttig funktion, bedre end blandingsmetoden, der blev brugt ovenfor, fordi den opretter en ny blandet liste og returnerer den i stedet for at forstyrre rækkefølgen af den oprindelige liste. Dette er nyttigt i tilfælde, hvor vi har brug for at beholde den originale liste.
Python3
fuld hugorm
import> random> test_list>=> [>1>,>4>,>5>,>6>,>3>]> print>(>'The original list is : '> +> str>(test_list))> # using random.sample()to shuffle a list> res>=> random.sample(test_list,>len>(test_list))> print>(>'The shuffled list is : '> +> str>(res))> |
>
>
Produktion
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [4, 3, 1, 6, 5]>
Tidskompleksitet: O(n), hvor n er længden af listen
Rumkompleksitet: O(n), hvor n er længden af listen
Randomiser en liste ved hjælp af tilfældig udvælgelsesmetode
I denne metode vil vi randomisere en liste ved hjælp af tilfældig udvælgelsesmetode . Vi vælger et indeks tilfældigt og tilføjer det element i det indeks til listen.
Python3
import> random> arr>=> [>1>,>2>,>3>,>4>,>5>,>6>]> print>(>'Original List: '>, arr)> n>=> len>(arr)> for> i>in> range>(n):> >j>=> random.randint(>0>, n>->1>)> >element>=> arr.pop(j)> >arr.append(element)> > print>(>'Shuffled List: '>, arr)> |
>
>
Produktion
Original List: [1, 2, 3, 4, 5, 6] Shuffled List: [1, 5, 2, 6, 3, 4]>
Tidskompleksitet: O(n) hvor n er længden af listen
Rumkompleksitet: O(1)
Bland en liste tilfældigt ved hjælp af Fisher-Yates Shuffle Algorithm
Dette er en af de berømte algoritmer Fisher-Yates Shuffle-algoritme , hovedsageligt brugt til at blande en række tal i Python. Denne algoritme tager bare den højere indeksværdi og bytter den med den aktuelle værdi, denne proces gentages i en løkke indtil slutningen af listen.
Python3
import> random> test_list>=> [>1>,>4>,>5>,>6>,>3>]> print>(>'The original list is : '> +> str>(test_list))> # using Fisher–Yates shuffle Algorithm to shuffle a list> for> i>in> range>(>len>(test_list)>->1>,>0>,>->1>):> ># Pick a random index from 0 to i> >j>=> random.randint(>0>, i>+> 1>)> ># Swap arr[i] with the element at random index> >test_list[i], test_list[j]>=> test_list[j], test_list[i]> print>(>'The shuffled list is : '> +> str>(test_list))> |
>
>
Produktion
matrix i c-sprog
The original list is : [1, 4, 5, 6, 3]The shuffled list is : [3, 4, 5, 6, 1]>
Tidskompleksitet: O(n), hvor n er længden af listen
Rumkompleksitet: O(n), hvor n er længden af listen
Randomiser en liste ved hjælp af Itertools.Permutations()-funktionen
Denne metode genererer alle mulige permutationer af den originale liste ved hjælp af itertools.permutations() funktion, og vælg derefter en tilfældig.
Python3
import> random> import> itertools> lst>=> [>1>,>4>,>5>,>6>,>3>]> permutations>=> list>(itertools.permutations(lst))> shuffled_lst>=> random.choice(permutations)> print>(>'Shuffled list:'>, shuffled_lst)> |
>
>
Produktion
Shuffled list: (6, 5, 4, 1, 3)>
Tidskompleksitet: O(n!) hvor n er længden af listen, på grund af genereringen af alle mulige permutationer.
Rumkompleksitet: O(n!), da alle mulige permutationer genereres og gemmes i en liste.
Randomiser en liste ved hjælp af Numpy
Vi bruger NumPy() for at blande elementerne på listen. For at randomisere en liste ved hjælp af numpy, skal vi konvertere liste til NumPy-array og derefter anvende reduceringsfunktionen, og den returnerer den blandede liste og udskriver den blandede liste.
Python3
import> numpy as np> from> functools>import> reduce> test_list>=> [>1>,>4>,>5>,>6>,>3>]> # Printing original list> print>(>'The original list is : '> +> str>(test_list))> # using reduce() and numpy to shuffle a list> res>=> reduce>(>lambda> acc, _: np.random.permutation(acc),> >range>(>len>(test_list)), np.array(test_list))> print>(>'The shuffled list is : '> +> str>(res.tolist()))> |
>
>
Produktion
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [3, 6, 1, 5, 4]>
Tidskompleksitet: Tidskompleksiteten af reduce()-funktionen afhænger af antallet af iterationer, som er lig med længden af listen. Tidskompleksiteten af np.random.permutation() er O(n), hvor n er længden af input-arrayet. Derfor er tidskompleksiteten af denne kode O(n^2).
Rumkompleksitet: Pladskompleksiteten af denne kode afhænger af listens størrelse. Listen er gemt i hukommelsen sammen med et par ekstra variabler, der bruges af reduce()-funktionen. Derfor er rumkompleksiteten O(n).