Tuple indexing and slicing in Python

Introduction

Tuples store multiple items together. Indexing and slicing help you get specific items or parts from a tuple easily.

You want to get the first or last item from a list of fixed values.

You need to extract a part of a tuple, like a few elements in the middle.

You want to loop through only a section of a tuple.

You want to quickly check or use a single item from a tuple.

You want to reverse or skip items in a tuple.

Syntax

Python

tuple_name[index]
tuple_name[start:end]
tuple_name[start:end:step]

Indexing starts at 0 for the first item.

Slicing extracts items from start up to but not including end.

Examples

Gets the first item 'red' from the tuple.

Python

colors = ('red', 'green', 'blue')
print(colors[0])

Gets items from index 1 to 3: (20, 30, 40).

Python

numbers = (10, 20, 30, 40, 50)
print(numbers[1:4])

Negative index -1 gets the last item 'e'.

Python

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

Gets every second item: (1, 3, 5).

Python

values = (1, 2, 3, 4, 5, 6)
print(values[::2])

Sample Program

This program shows how to get items from a tuple using indexing and slicing.

Python

fruits = ('apple', 'banana', 'cherry', 'date', 'fig')

# Get first fruit
first = fruits[0]

# Get last fruit
last = fruits[-1]

# Get middle fruits
middle = fruits[1:4]

# Get every other fruit
every_other = fruits[::2]

print(f"First fruit: {first}")
print(f"Last fruit: {last}")
print(f"Middle fruits: {middle}")
print(f"Every other fruit: {every_other}")

Important Notes

Trying to change a tuple item by index will cause an error because tuples cannot be changed.

Negative indexes count from the end: -1 is last, -2 is second last, and so on.

If you omit start in slicing, it starts from the beginning; if you omit end, it goes to the end.

Summary

Use indexing to get a single item from a tuple by position.

Use slicing to get a part of a tuple as a new tuple.

Negative indexes and steps help access items from the end or skip items.

Practice

1.

What does my_tuple[2] return if my_tuple = (10, 20, 30, 40)?

easy

A. 30

B. 20

C. 40

D. 10

Solution

1. Step 1: Understand tuple indexing

   Indexing starts at 0, so index 2 means the third item in the tuple.

2. Step 2: Identify the item at index 2

   The tuple is (10, 20, 30, 40), so the item at index 2 is 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Index 2 in tuple = 30 [OK]

Hint: Remember: indexing starts at zero in tuples [OK]

Common Mistakes:

• Counting from 1 instead of 0
• Confusing index 2 with index 3
• Mixing up tuple with list indexing

2.

Which of the following is the correct syntax to get the last item of a tuple t?

easy

A. t[1]

B. t[-1]

C. t[last]

D. t[len(t)]

Solution

1. Step 1: Recall negative indexing in tuples

   Negative index -1 accesses the last item in a tuple.

2. Step 2: Check each option

   t[-1] correctly accesses the last item. t[1] accesses second item, t[last] is invalid syntax, t[len(t)] causes IndexError because indexing starts at 0.

3. Final Answer:

   t[-1] -> Option B

4. Quick Check:

   Last item index = -1 [OK]

Hint: Use -1 to get last item from any tuple [OK]

Common Mistakes:

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

3.

What is the output of this code?

t = (5, 10, 15, 20, 25)
print(t[1:4])

medium

A. (10, 15, 20)

B. (10, 15, 20, 25)

C. (5, 10, 15)

D. (15, 20, 25)

Solution

1. Step 1: Understand slicing syntax

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

2. Step 2: Extract the slice from the tuple

   Tuple is (5, 10, 15, 20, 25). Index 1 is 10, index 2 is 15, index 3 is 20. Index 4 (25) is excluded.

3. Final Answer:

   (10, 15, 20) -> Option A

4. Quick Check:

   Slicing excludes end index [OK]

Hint: Slice excludes the end index, so stop before it [OK]

Common Mistakes:

• Including the end index in slice
• Confusing indexes with values
• Using parentheses instead of brackets for slicing

4.

Find the error in this code:

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

medium

A. Prints 5

B. SyntaxError

C. IndexError: tuple index out of range

D. Prints 1

Solution

1. Step 1: Check tuple length and indexing

   Tuple has 5 items indexed 0 to 4. Index 5 is outside this range.

2. Step 2: Understand what happens when accessing invalid index

   Accessing t[5] causes an IndexError because the index is out of range.

3. Final Answer:

   IndexError: tuple index out of range -> Option C

4. Quick Check:

   Index must be less than length [OK]

Hint: Index must be less than tuple length [OK]

Common Mistakes:

• Using index equal to length
• Confusing SyntaxError with IndexError
• Assuming last index is length instead of length-1

5.

Given t = (2, 4, 6, 8, 10, 12), which expression returns a tuple with every second item starting from the last item going backwards?

hard

A. t[1::2]

B. t[::2]

C. t[-2::-1]

D. t[::-2]

Solution

1. Step 1: Understand slicing with negative step

   A negative step means slicing backwards. t[::-2] starts from the end and takes every second item backwards.

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

   Tuple is (2,4,6,8,10,12). t[::-2] picks 12 (last), 8, 4, resulting in (12, 8, 4).

3. Final Answer:

   t[::-2] -> Option D

4. Quick Check:

   Negative step slices backwards skipping items [OK]

Hint: Use negative step in slice to go backwards [OK]

Common Mistakes:

• Using positive step for backward slicing
• Starting slice incorrectly
• Confusing slice start and step positions