List indexing and slicing in Python

Introduction

List indexing and slicing help you get parts or single items from a list easily. It is like picking fruits from a basket by their position.

When you want to get the first or last item from a list.

When you want to get a group of items from the middle of a list.

When you want to reverse a list or get every other item.

When you want to copy a list or part of it.

When you want to check or change specific items in a list.

Syntax

Python

my_list = [10, 20, 30, 40, 50]

# Indexing
single_item = my_list[index]

# Slicing
sub_list = my_list[start:stop:step]

Indexing starts at 0 for the first item.

Slicing uses start (inclusive), stop (exclusive), and step (optional) to get parts of the list.

Examples

Index 0 gets the first item. Negative index -1 gets the last item.

Python

my_list = [10, 20, 30, 40, 50]
print(my_list[0])  # First item
print(my_list[-1]) # Last item

Slicing examples: from middle, from start, and from middle to end.

Python

my_list = [10, 20, 30, 40, 50]
print(my_list[1:4])  # Items from index 1 to 3
print(my_list[:3])   # First three items
print(my_list[2:])   # From index 2 to end

Step in slicing lets you skip items or reverse the list.

Python

my_list = [10, 20, 30, 40, 50]
print(my_list[::2])  # Every other item
print(my_list[::-1]) # Reverse the list

Edge cases: empty list slicing returns empty list, indexing single item works normally.

Python

empty_list = []
print(empty_list[0:1])  # Slicing empty list returns []

single_item_list = [100]
print(single_item_list[0])  # Indexing single item
print(single_item_list[0:1]) # Slicing single item

Sample Program

This program shows how to use indexing and slicing on different lists: normal, single item, and empty. It prints the results clearly.

Python

def print_list_info(my_list):
    print(f"Original list: {my_list}")
    if my_list:
        print(f"First item (index 0): {my_list[0]}")
        print(f"Last item (index -1): {my_list[-1]}")
    else:
        print("List is empty, no items to show.")
    print(f"Slice from index 1 to 3: {my_list[1:4]}")
    print(f"Slice first 3 items: {my_list[:3]}")
    print(f"Slice from index 2 to end: {my_list[2:]}")
    print(f"Every other item: {my_list[::2]}")
    print(f"Reversed list: {my_list[::-1]}")

# Test with a normal list
numbers = [10, 20, 30, 40, 50]
print_list_info(numbers)

print("\n")

# Test with a single item list
single_item_list = [100]
print_list_info(single_item_list)

print("\n")

# Test with an empty list
empty_list = []
print_list_info(empty_list)

Important Notes

Indexing and slicing are very fast operations with time complexity O(k), where k is the size of the slice.

Slicing creates a new list, so it uses extra space proportional to the slice size.

Common mistake: forgetting that the stop index in slicing is not included.

Use indexing to get single items, slicing to get parts or copies of lists.

Summary

Indexing gets one item by position, starting at 0.

Slicing gets a part of the list using start, stop, and step.

Negative indexes count from the end, and step can reverse or skip items.

Practice

1. What does the expression my_list[2] return when my_list = [10, 20, 30, 40, 50]?

easy

A. 40

B. 20

C. 30

D. 50

Solution

1. Step 1: Understand list indexing

   Indexing starts at 0, so my_list[0] is 10, my_list[1] is 20, and my_list[2] is 30.

2. Step 2: Identify the value at index 2

   The value at index 2 is 30.

3. Final Answer:

   30 -> Option C

4. Quick Check:

   Index 2 value = 30 [OK]

Hint: Remember indexing starts at zero, so count from 0 [OK]

Common Mistakes:

• Starting count from 1 instead of 0
• Confusing index 2 with index 3
• Mixing up values and indexes

2. Which of the following is the correct syntax to get the last element of a list nums using indexing?

easy

A. nums[last]

B. nums[1]

C. nums[len(nums)]

D. nums[-1]

Solution

1. Step 1: Recall negative indexing

   Negative indexes count from the end, so -1 means the last element.

2. Step 2: Check each option

   nums[-1] uses nums[-1], which correctly accesses the last element. nums[1] accesses the second element. nums[last] is invalid syntax. nums[len(nums)] causes an IndexError because list indexes go from 0 to len(nums)-1.

3. Final Answer:

   nums[-1] -> Option D

4. Quick Check:

   Last element index = -1 [OK]

Hint: Use -1 to get the last item in a list [OK]

Common Mistakes:

• Using len(nums) as index (out of range)
• Trying to use 'last' as an index
• Confusing positive and negative indexes

3. What is the output of this code?

letters = ['a', 'b', 'c', 'd', 'e']
print(letters[1:4])

medium

A. ['b', 'c', 'd']

B. ['c', 'd', 'e']

C. ['b', 'c', 'd', 'e']

D. ['a', 'b', 'c']

Solution

1. Step 1: Understand slicing syntax

   Slicing letters[1:4] means start at index 1 up to but not including index 4.

2. Step 2: Identify elements at indexes 1, 2, 3

   Index 1 is 'b', index 2 is 'c', index 3 is 'd'. So the slice is ['b', 'c', 'd'].

3. Final Answer:

   ['b', 'c', 'd'] -> Option A

4. Quick Check:

   Slicing excludes stop index [OK]

Hint: Slice stops before the stop index, not including it [OK]

Common Mistakes:

• Including the stop index element
• Confusing start and stop indexes
• Using wrong indexes for slicing

4. The code below causes an error. What is the problem?

nums = [1, 2, 3, 4, 5]
print(nums[5])

medium

A. SyntaxError due to wrong brackets

B. IndexError because index 5 is out of range

C. TypeError because nums is not a list

D. No error, prints 5

Solution

1. Step 1: Check list length and valid indexes

   List nums has 5 elements with indexes 0 to 4.

2. Step 2: Understand index 5 usage

   Index 5 is outside the valid range, so accessing nums[5] causes an IndexError.

3. Final Answer:

   IndexError because index 5 is out of range -> Option B

4. Quick Check:

   Index must be less than list length [OK]

Hint: Indexes go from 0 to length-1 only [OK]

Common Mistakes:

• Thinking index 5 is valid for 5 elements
• Confusing SyntaxError with IndexError
• Assuming list indexes start at 1

5. Given data = [5, 10, 15, 20, 25, 30], which expression returns a new list with every second element in reverse order?

hard

A. data[::-2]

B. data[::2]

C. data[-2::-1]

D. data[1::2]

Solution

1. Step 1: Understand slicing with step and negative step

   The slice data[::-2] starts from the end and takes every second element backwards.

2. Step 2: Check what data[::-2] returns

   It returns [30, 20, 10], which is every second element in reverse order.

3. Step 3: Verify other options

   data[::2] returns every second element forward: [5, 15, 25]. data[-2::-1] returns from index -2 backwards: [25, 20, 15, 10, 5]. data[1::2] returns every second element starting at index 1: [10, 20, 30].

4. Final Answer:

   data[::-2] -> Option A

5. Quick Check:

   Negative step reverses and skips elements [OK]

Hint: Use negative step to reverse and skip elements [OK]

Common Mistakes:

• Using positive step for reverse
• Confusing start index with step sign
• Misunderstanding slice boundaries