In Python, mescolare una sequenza di numeri è sempre stata un'utilità utile e la domanda è apparsa anche in molte interviste di collocamento aziendale. Conoscere più di un metodo per raggiungere questo obiettivo può sempre essere un vantaggio. Discutiamo alcuni modi in cui ciò può essere raggiunto.
Python Mescola casualmente una lista
In Pitone, esistono diversi modi per mescolare un elenco. Ecco vari modi Python per mescolare le liste.
- Usando sorted()
- Utilizzando random.shuffle()
- Utilizzando random.sample()
- Utilizzando il metodo di selezione casuale
- Utilizzo dell'algoritmo di riproduzione casuale di Fisher-Yates
- Utilizzando la funzione itertools.permutations()
- Utilizzando NumPy
Mescola casualmente una lista usando sorted()
Una versione ordinata dell'elenco può essere prodotta utilizzando il file smistato() funzione. Mescoliamo effettivamente gli elementi in modo casuale utilizzandoli su una copia dell'elenco che è stato mescolato.
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)> |
>
>
esempio di elenco in Java
Produzione
Original list: [1, 2, 3, 4, 5] Shuffled list: [2, 3, 4, 5, 1]>
Complessità temporale: O(nlogn), dove n è la lunghezza dell'elenco
Complessità spaziale: O(n), dove n è la lunghezza dell'elenco
Randomizza un elenco utilizzando Random.Shuffle()
Casuale. Casuale() è il metodo più consigliato per mescolare un elenco. Python nella sua libreria casuale fornisce questa funzione incorporata che mescola l'elenco sul posto. Lo svantaggio è che in questo processo si perde l'ordine dell'elenco. Utile per gli sviluppatori che scelgono di risparmiare tempo e fatica.
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))> |
>
>
Produzione
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [5, 1, 3, 4, 6]>
Complessità temporale: O(n), dove n è la lunghezza dell'elenco
Complessità spaziale: O(n), dove n è la lunghezza dell'elenco
Randomizza una lista u canta Random.Sample()
Campione casuale(), Questa è una funzione piuttosto utile, migliore del metodo shuffle usato sopra in quanto crea un nuovo elenco mescolato e lo restituisce invece di disturbare l'ordine dell'elenco originale. Ciò è utile nei casi in cui è necessario conservare l'elenco originale.
Python3
media vs media
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))> |
>
>
Produzione
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [4, 3, 1, 6, 5]>
Complessità temporale: O(n), dove n è la lunghezza dell'elenco
Complessità spaziale: O(n), dove n è la lunghezza dell'elenco
Randomizza un elenco utilizzando il metodo di selezione casuale
In questo metodo, randomizzeremo un elenco utilizzando metodo di selezione casuale . Selezioniamo un indice in modo casuale e aggiungiamo quell'elemento in quell'indice all'elenco.
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)> |
>
>
Produzione
Original List: [1, 2, 3, 4, 5, 6] Shuffled List: [1, 5, 2, 6, 3, 4]>
Complessità temporale: O(n) dove n è la lunghezza della lista
Complessità spaziale: O(1)
Mescola casualmente un elenco utilizzando l'algoritmo Fisher-Yates Shuffle
Questo è uno dei famosi algoritmi Algoritmo Shuffle di Fisher-Yates , utilizzato principalmente per mescolare una sequenza di numeri in Python. Questo algoritmo prende semplicemente il valore dell'indice più alto e lo scambia con il valore corrente, questo processo si ripete in loop fino alla fine dell'elenco.
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))> |
>
>
Produzione
The original list is : [1, 4, 5, 6, 3]The shuffled list is : [3, 4, 5, 6, 1]>
Complessità temporale: O(n), dove n è la lunghezza dell'elenco
Complessità spaziale: O(n), dove n è la lunghezza dell'elenco
Randomizza un elenco utilizzando la funzione Itertools.Permutations()
Questo metodo genera tutte le possibili permutazioni dell'elenco originale utilizzando il metodo itertools.permutations() funzione, quindi selezionarne una casuale.
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)> |
>
>
Produzione
Shuffled list: (6, 5, 4, 1, 3)>
Complessità temporale: O(n!) dove n è la lunghezza della lista, dovuta alla generazione di tutte le possibili permutazioni.
Complessità spaziale: O(n!) poiché tutte le possibili permutazioni vengono generate e memorizzate in un elenco.
Randomizza una lista utilizzando Numpy
Stiamo usando NumPy() per mescolare gli elementi nell'elenco. Per randomizzare un elenco utilizzando NumPy, dobbiamo convertire l'elenco nell'array NumPy e quindi applicare la funzione di riduzione che restituisce l'elenco mescolato e stampa l'elenco mescolato.
Python3
attrice cinematografica rekha
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()))> |
>
>
Produzione
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [3, 6, 1, 5, 4]>
Complessità temporale: La complessità temporale della funzione reduce() dipende dal numero di iterazioni, che è uguale alla lunghezza dell'elenco. La complessità temporale di np.random.permutation() è O(n) dove n è la lunghezza dell'array di input. Pertanto, la complessità temporale di questo codice è O(n^2).
Complessità spaziale: La complessità spaziale di questo codice dipende dalla dimensione dell'elenco. L'elenco viene archiviato in memoria insieme ad alcune variabili aggiuntive utilizzate dalla funzione reduce(). Pertanto, la complessità dello spazio è O(n).