## What is Shuffle in Python

Shuffling in Python refers to randomly reordering a sequence’s elements, such as a list or tuple. This operation is commonly used in various applications, including games, statistical simulations, and data analysis, to introduce randomness or permute a random collection of items.

The **random** module in Python provides the **shuffle()** function, which allows you to shuffle the elements of a sequence in place. This function rearranges the elements randomly, ensuring that each possible ordering has an equal probability of occurring.

Shuffling is straightforward to implement and offers versatility in generating randomized sequences for different purposes. Whether you’re creating a randomized playlist, conducting statistical experiments, or implementing algorithms that require random permutations, shuffling in Python provides a simple yet powerful tool for introducing randomness into your programs.

##### Table of Contents

**Syntax and Parameters**

You can achieve shuffling in Python using the random.shuffle() function from the random module. This is the syntax of the shuffle() function:

`random.shuffle(sequence, random=random.random)`

#### Parameters:

**sequence:**The sequence (list, tuple, etc.) to be shuffled.**random:**This optional parameter returns a random float between 0.0 and 1.0. You can use random.shuffle() by default. It will just randomize the functions used in shuffling.

Note that the random.shuffle() function shuffles the sequence in place. It modifies the original sequence and does not return anything.

**Time complexity and efficiency considerations**

The time complexity and efficiency considerations for shuffling depend on the method used. We will discuss various algorithms, along with their time complexity and efficiency.

**Importing the shuffle function**

You can import the shuffle function directly from the random module in Python. This is how you can do this:

`from random import shuffle`

After importing the shuffle function, you can use it directly in your code without referencing the random module. For example,

```
my_list = [1, 2, 3, 4, 5]
shuffle(my_list)
print(my_list)
```

You can shuffle the given list of elements in my_list in place. Since it is done in place, it returns nothing. The output of the above code will be any random order of the given sequence.

**Output:**

This output will change every time you execute it.

### Simple examples of shuffling lists

These are some simple examples of shuffling lists in Python.

**1. Shuffling a List**

In Python, you can directly shuffle lists using the shuffle() method of the random module.

For example,

```
from random import shuffle
my_list = [1, 2, 3, 4, 5]
shuffle(my_list)
print(my_list)
```

The output of this code will change every time you execute it. The time output is

**2. Shuffling a String**

You can shuffle strings in Python after converting the string into a list. Then, you can convert the shuffled list back to the string.

For example,

```
from random import shuffle
my_string = "EDUCBA"
# Convert string to list
my_list = list(my_string)
shuffle(my_list)
# Convert back to string
shuffled_string = ''.join(my_list)
print(shuffled_string)
```

In this code, we have converted the string ‘EduCBA’ into a list using the list() function. Then, we applied the shuffle() function to this list. Finally, we converted this shuffled list back into a string. The output is:

The result of running this code will vary each time you execute it.

**3. Shuffle a Tuple**

Tuples are comparable to lists in Python but are immutable, while lists are not. Immutability denotes the inability to change their values. Because of the immutable nature of the Python tuple, you must convert the tuple into a list.

For example,

```
from random import shuffle
my_tuple = (1, 2, 3, 4, 5)
# Convert tuple to list
my_list = list(my_tuple)
shuffle(my_list)
# Convert back to tuple
shuffled_tuple = tuple(my_list)
print(shuffled_tuple)
```

In this code, there is a tuple named my_tuple. Parentheses, i.e., (), enclose values of a tuple, and values of a list are enclosed by square brackets, i.e., [].

We used the list() function to turn the provided tuple into a list. Next, we used the tuple() function to return this list to a tuple after shuffling it. The output is:

Again, the result of running this code will vary each time you execute it.

**4. Shuffling a Nested List**

Nested lists consist of lists within lists, which contain other lists as their elements. Since a nested list is a list type, it is mutable, which means values can be modified directly. For example, we can apply the shuffle() function directly.

For example,

```
from random import shuffle
nested_list = [[2, 1], [4, 3], [6, 5]]
shuffle(nested_list)
print(nested_list)
```

This code has a nested list where the shuffle() method has been applied directly. The output is

Note that the result of running this code will vary each time you execute it.

### Common Use Cases for Shuffle

You can use shuffling in various use cases across domains. These are various common use cases for shuffle.

**1. Random Sampling**

You can shuffle a list and datasets to achieve an unbiased and random subset of the original dataset. This is useful in statistical analysis, machine learning, and data preprocessing tasks.

**2. Generating Permutations**

You can generate various permutations of given elements in a sequence. Permutations are valid in combinatorial optimization problems, cryptography, and generating test cases for algorithms.

**3. Data Augmentation**

You can use shuffling for data augmentation in machine learning and computer vision tasks. You can avoid overfitting using the shuffle dataset.

**4. Ensuring Fairness in Simulations**

Shuffling can provide fairness in simulations.

**5. User Experience Enhancement**

For example, if you shuffle the order of items in a playlist, slideshow, and news feed, it can have a better user experience.

**6. Randomization in Games**

You need to shuffle in cards, boards, puzzles, etc. This changes the positions of elements on a game board.

**7. Security and Cryptography**

You can use shuffling in security and cryptography. You can randomize the order of elements and generate random permutations for cryptographic operations like generating keys, data privacy, preventing attacks, etc.

### Advanced Techniques with Shuffle

There are various methods to shuffle a list in Python. We have discussed the following ways to shuffle() a list in Python.

#### 1. By using Fisher-Yates shuffle algorithm

It uses the random module to replace the list’s random value, and its algorithm time complexity is O(n). We start from the last element and swap it with the randomly selected component of the list (including the last element). Then, consider the array from index 0 to n-2 (reducing the size by 1) and repeat the process until reaching the first element.

These are the steps of the algorithm:

- Start a loop from i = n – 1 down to 1.
- Within each iteration:

- Generate a random integer j such that 0 <= j <= i.
- Swap the elements a[j] and a[i].

This process shuffles the array randomly and uniformly.

For example,

```
import random
def fisher_yates_shuffle(input_list):
# Iterate through the list in reverse order
for i in range(len(input_list)-1, 0, -1):
# Generate a random index within the unshuffled portion of the list
j = random.randint(0, i + 1)
# Element Swapping
input_list[i], input_list[j] = input_list[j], input_list[i]
return input_list
# Example usage:
original_list = [1, 2, 3, 4, 5]
print("Original list:", original_list)
shuffled_list = fisher_yates_shuffle(original_list)
print("Shuffled list:", shuffled_list)
```

In this code, we have defined the fisher_yates_shuffle function. It takes a list as input. This function shuffles it using the Fisher-Yates algorithm as given above in steps. Finally, it returns the shuffled list.

The output

**Time and Space complexity**

The Fisher-Yates Shuffle Algorithm scans input only once in linear time. Because fisher_yates_shuffle does not use extra memory, it has an O(n) time complexity and an O(1) space complexity.

#### 2. By using random.shuffle()

The random module has a shuffle() function. You can shuffle a list using this method. It changes the positions of the elements of a given sequence. This method shuffles the list inplace, which means you do not need extra space to shuffle the list. You must call this function and pass your list as an argument. The syntax of this method is as follows:

`random.shuffle(sequence, function)`

The sequence parameter can be a list and random() function, which is optional here.

For example,

```
import random
# Original list
my_list = [1, 2, 3, 4, 5]
print("Original list:", my_list)
# Shuffle the list in place
random.shuffle(my_list)
# Display the shuffled list
print("Shuffled list:", my_list)
```

In the above code, we have a list of 5 numbers to which we applied the random.shuffle() function and then print the result. The output is:

**Time and Space complexity**

This code has an O(n) time complexity since we must scan the input at least once. O(1) is the space complexity.

#### 3. By using random.sample()

You can also shuffle a list using the random.sample() function. You can create a shuffled version without modifying the original list. Like shuffle(), sample() is also an inbuilt random module in Python. The sequence of this method is as follows:

`random.sample(sequence, k)`

The sequence parameter is the sequence from which to generate the sample. The k is the number of elements to include in the sample. The sample() function returns a list of k elements from the sequence. This element is chosen randomly without replacement. So, you can replace each element only once.

For example,

```
import random
# Original list
my_list = [1, 2, 3, 4, 5]
print("Original list:", my_list)
# Shuffle the list using random.sample()
shuffled_list = random.sample(my_list, len(my_list))
# Display the shuffled list
print("Shuffled list:", shuffled_list)
```

In the above code, we have a list of 5 numbers. We have applied the sample() method of random module. It has a list and the length of the list as arguments. Then, we printed this shuffled list. The output is:

This output may change when we execute the code again.

#### Time and Space complexity

This code has an O(n) time complexity since we must scan the input at least once. O(1) is the space complexity.

### Comparison with Alternative Methods

** Sorting:**

**Description**: Sorting the list and then shuffling is not an efficient way to achieve randomness. If the original list is already sorted, the output will be the same as the input, defeating the purpose of shuffling. Additionally, sorting has a higher time complexity compared to other shuffling methods.**Time Complexity**: O(n log n) for typical sorting algorithms like Timsort used in Python’s sorted() function.**Space Complexity**: O(n) for most sorting algorithms.

** Random Selection:**

**Description:**This method randomly selects an index and adds the corresponding element to the shuffled list. It’s similar to the Fisher-Yates shuffle algorithm but might need to be more efficient and random.**Time Complexity:**Depends on the implementation, but generally O(n^2) due to potential repeated selections.**Space Complexity:**O(n) for the resulting shuffled list.

**Itertools.permutations():**

**Description:**This method generates all possible list permutations and selects one randomly. However, the time and space complexities are prohibitively high for more extensive lists due to the exponential growth of permutations.**Time Complexity:**O(n!) due to generating all permutations.**Space Complexity**: O(n!) due to storing all permutations.

** NumPy:**

**Description:**NumPy provides the numpy. random.shuffle() function, which shuffles the elements in place. It’s efficient and widely used, especially in numerical computing tasks.**Time Complexity:**O(n) for shuffling.**Space Complexity:**O(n) for the shuffled array.

### Best Practices and Tips

These are some best practices and tips for shuffling lists in Python.

**1. Choose the Right Method**

You can shuffle a Python list in multiple ways. However, each method has its benefits and drawbacks. So, you must choose the best method for your project with lower time and space complexity. You can select random.shuffle() for inplace shuffling and random.sample() for outplace shuffling with linear time complexity.

**2. Preserve the Original List (if needed)**

If you need the project’s original list, you should choose an outplace shuffling method like random.sample(). Otherwise, you can select the random.shuffle() method for inplace.

**3. Seed Randomness for Reproducibility**

If you need reproducibility across runs. Then, set a seed value using random.seed(). For example,

```
import random
# Set seed for reproducibility
random.seed(42)
my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
print("Shuffled list:", my_list)
```

The output is:

**4. Handle errors**

You should implement error handling to handle edge cases, like empty lists and invalid inputs. For example,

import random

```
def shuffle_list(input_list):
If not input_list:
raise ValueError("Input list is empty")
random.shuffle(input_list)
return input_list
```

In this code, we have handled empty list errors.

**5. Document Your Code**

You should document your code to explain the purpose of the shuffling operation and any assumptions made. For example,

```
import random
"""
Shuffles a list using random.shuffle() method.
:param input_list: List to be shuffled
:return: Shuffled list
"""
def shuffle_list(input_list):
random.shuffle(input_list)
return input_list
```

In this code, we have documented our code to explain it.

### Conclusion

Shuffling is a basic concept in Python programming where elements are rearranged in a random order. In Python, you can shuffle a list in various ways, like Fisher-Yates shuffle algorithm, the random.shuffle() function, and random.sample() function. These methods are easier and more efficient than sorting and permutations. Shuffling is used in various business use cases like random sampling, generating permutation data augmentation, etc. You can better user experience, game randomization, security, and cryptography using shuffling.

### Frequently Asked Questions (FAQs)

**Q1: Is shuffling reversible?**

**Answer:** No. Shuffling is irreversible if you use a shuffling method like random.shuffle(). However, you can have the original list and shuffle a copy of that list using the random.Sample() method.

**Q2: Can shuffling be applied to immutable data structures like tuples?**

**Answer:** No. Shuffling cannot be directly applied to immutable data structures like tuples because they cannot be modified. However, you can convert a tuple to a list, shuffle it, and then back to a tuple.

**Q3: Does shuffling guarantee a unique order every time it’s applied?**

**Answer:** No. Shuffling cannot be directly applied to immutable data structures like tuples because they cannot be modified. On the other hand, a tuple can be transformed into a list, shuffled, and then returned to a tuple.

**Q4: Can shuffling be applied to non-linear data structures like trees or graphs?**

**Answer:** Shuffling is used in linear data structures like lists, arrays, tuples, strings, etc. However, it does not apply directly to nonlinear structures like trees and graphs. For these non-linear structures, you can use other techniques for traversal and manipulation.

### Recommended Articles

We hope that this EDUCBA information on “Shuffle in Python” was beneficial to you. You can view EDUCBA’s recommended articles for more information