Open In App
Related Articles

Python | Ways to shuffle a list

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

In Python, Shuffling a sequence of numbers has always been a useful utility and the question that has appeared in many company placement interviews as well. Knowing more than one method to achieve this can always be a plus. Let’s discuss certain ways in which this can be achieved.

Python Random Shuffle a List

In Python, there are several ways to shuffle a list. Here are various Python ways for shuffling lists.

  • Using sorted()
  • Using random.shuffle()
  • Using random.sample() 
  • Using the Random Selection Method
  • Using Fisher-Yates shuffle Algorithm
  • Using itertools.permutations() function
  • Using NumPy

Random Shuffle a List using sorted()

A sorted version of the list can be produced using the sorted() function. We effectively shuffle the elements randomly by using them on a copy of the list that has been shuffled.

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)

                    

Output

Original list: [1, 2, 3, 4, 5]
Shuffled list: [2, 3, 4, 5, 1]

Time Complexity: O(nlogn), where n is the length of the list
Space Complexity: O(n), where n is the length of the list

Randomize a List using Random.Shuffle()

Random.Shuffle() is the most recommended method to shuffle a list. Python in its random library provides this inbuilt function which in-place shuffles the list. The drawback of this is that list ordering is lost in this process. Useful for developers who choose to save time and hustle.
 

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))

                    

Output

The original list is : [1, 4, 5, 6, 3]
The shuffled list is : [5, 1, 3, 4, 6]

Time Complexity: O(n), where n is the length of the list
Space Complexity: O(n), where n is the length of the list

Randomize a List using Random.Sample() 

Random.Sample(), This is quite a useful function, better than the shuffle method used above in aspect that it creates a new shuffled list and returns it rather than disturbing the order of the original list. This is useful in cases we require to retain the original list.
 

Python3

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))

                    

Output

The original list is : [1, 4, 5, 6, 3]
The shuffled list is : [4, 3, 1, 6, 5]

Time Complexity: O(n), where n is the length of the list
Space Complexity: O(n), where n is the length of the list

Randomize a List using Random Selection Method

In this method , we will randomize a list using random selection method . We select a index randomly and append that element at that index to the list.

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)

                    

Output

Original List:  [1, 2, 3, 4, 5, 6]
Shuffled List: [1, 5, 2, 6, 3, 4]

Time Complexity: O(n) where n is the length of the list
Space Complexity: O(1)

Random Shuffle a List using Fisher-Yates Shuffle Algorithm

This is one of the famous algorithms that is Fisher-Yates Shuffle Algorithm, mainly employed to shuffle a sequence of numbers in Python. This algorithm just takes the higher index value, and swaps it with the current value, this process repeats in a loop till the end of the list. 
 

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))

                    

Output

The original list is : [1, 4, 5, 6, 3]The shuffled list is : [3, 4, 5, 6, 1]

Time Complexity: O(n), where n is the length of the list
Space Complexity: O(n), where n is the length of the list

Randomize a List using Itertools.Permutations() Function

This method generates all possible permutations of the original list using the itertools.permutations() function, and then select a random one.

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)

                    

Output

Shuffled list: (6, 5, 4, 1, 3)

Time Complexity: O(n!) where n is the length of the list, due to the generation of all possible permutations.
Space Complexity: O(n!) as all possible permutations are generated and stored in a list.

Randomize a List using Numpy

We are using NumPy() to shuffle the items in the list. To randomize a list using numpy ,we have to convert list to NumPy array and then apply reduce function and it returns the shuffled list and Prints the shuffled list.

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()))

                    

Output

The original list is : [1, 4, 5, 6, 3]
The shuffled list is : [3, 6, 1, 5, 4]

Time Complexity: The time complexity of the reduce() function depends on the number of iterations, which is equal to the length of the list. The time complexity of np.random.permutation() is O(n) where n is the length of the input array. Therefore, the time complexity of this code is O(n^2).
Space Complexity: The space complexity of this code depends on the size of the list. The list is stored in memory along with a few additional variables used by the reduce() function. Therefore, the space complexity is O(n).



Last Updated : 25 Jul, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads