5 Best Ways to Reverse a List by List Slicing in Python

💡 Problem Formulation: How can a list in Python be reversed in place without using built-in functions? Given an input list [1, 2, 3, 4, 5], the desired output is a list in reversed order: [5, 4, 3, 2, 1]. This article demonstrates five ways to reverse a list using list slicing in Python.

Method 1: Using Standard List Slicing

This method involves reversing a list by using the slicing technique. In Python, slicing allows you to obtain a sublist by specifying the start, stop, and step; by setting the step to -1, the list is returned in reverse order.

Here’s an example:

def reverse_list(lst):
    return lst[::-1]

original_list = [1, 2, 3, 4, 5]
reversed_list = reverse_list(original_list)
print(reversed_list)

Output:

[5, 4, 3, 2, 1]

This snippet defines a function reverse_list() that takes a list lst as an argument and returns it in reverse order. The slice notation lst[::-1] reads the list from end to start, effectively reversing it.

Method 2: Reversing a Subsection of the List

This approach utilizes list slicing to reverse only a specific portion of the list. The indices of the subsection are specified in the slicing operation, with a step of -1 to reverse that particular segment.

Here’s an example:

def reverse_subsection(lst, start, end):
    lst[start:end] = lst[start:end][::-1]
    return lst

original_list = ['a', 'b', 'c', 'd', 'e']
reversed_subsection_list = reverse_subsection(original_list, 1, 4)
print(reversed_subsection_list)

Output:

['a', 'd', 'c', 'b', 'e']

This snippet defines the reverse_subsection() function that reverses a section of the list from the start index to the end index. It modifies the original list in place, keeping the remainder of the list intact.

Method 3: Extending List Slicing with Assignment

In this method, the entire list is sliced in reverse order and then assigned back to itself. This is a variant of the standard slicing technique that works without defining an extra function.

Here’s an example:

original_list = [10, 20, 30, 40, 50]
original_list[:] = original_list[::-1]
print(original_list)

Output:

[50, 40, 30, 20, 10]

By assigning the reversed slice to original_list[:], the original list variable itself holds the reversed elements. This in-place modification does not return a new list but alters the original list.

Method 4: Nested List Slicing

A less common but interesting way of reversing a list is by using nested list slicing. This method involves an outer slice that iterates through the list in reverse, containing an inner slice that reverses each item if it is a sublist.

Here’s an example:

original_list = [[1,2], [3,4], [5,6]]
reversed_list = [sublist[::-1] for sublist in original_list[::-1]]
print(reversed_list)

Output:

[[6, 5], [4, 3], [2, 1]]

This code snippet uses a list comprehension to iterate in reverse order through the original list of sublists, reversing each sublist in the process. This results in the top-level list and its nested lists being reversed.

Bonus One-Liner Method 5: Using the reversed() Built-In

Though not list slicing, Python provides a built-in function reversed() which returns an iterator that accesses the given sequence in the reverse order. A list constructor can convert this iterator back into a list.

Here’s an example:

original_list = [1, 'two', 3.0]
reversed_list = list(reversed(original_list))
print(reversed_list)

Output:

[3.0, 'two', 1]

The reversed() function provides a simple one-liner to reverse any iterable. Wrapping the iterator with the list() function call creates a new reversed list.

Summary/Discussion

• Method 1: Standard List Slicing. Simple and direct. Suitable for fully reversing a list. Does not work in-place on large lists.
• Method 2: Reversing a Subsection of the List. Offers control over which part of the list to reverse. It can be more complex and is less commonly used for full-list reverse operations.
• Method 3: Extending List Slicing with Assignment. Alters the original list in-place. Ideal for reversing without additional memory overhead. Syntax may be less readable for beginners.
• Method 4: Nested List Slicing. Useful for lists containing sublists. Adds complexity and is not very common for simple reverse operations.
• Method 5: Using the reversed() Built-In. Not slicing-based, but very readable and easy to use for all iterables. It creates a new list, which could be a drawback with very large lists.