Tuple indexing and slicing in Python - Step-by-Step Execution

Concept Flow - Tuple indexing and slicing

Start with tuple

↓

Choose index or slice

↓

If index: get single element

↓

If slice: get sub-tuple

↓

Output result

↓

End

We start with a tuple, pick an index or a slice, then get either one element or a smaller tuple as output.

Execution Sample

Python

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

This code gets the element at index 2 and a slice from index 1 to 3 from the tuple.

Execution Table

Step	Expression	Evaluation	Result
1	t = (10, 20, 30, 40, 50)	Create tuple	(10, 20, 30, 40, 50)
2	t[2]	Get element at index 2	30
3	t[1:4]	Get slice from index 1 to 3	(20, 30, 40)
4	End	No more expressions	Execution stops

💡 All expressions evaluated, program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
t	undefined	(10, 20, 30, 40, 50)	(10, 20, 30, 40, 50)	(10, 20, 30, 40, 50)	(10, 20, 30, 40, 50)
result_index	undefined	undefined	30	30	30
result_slice	undefined	undefined	undefined	(20, 30, 40)	(20, 30, 40)

Key Moments - 2 Insights

Why does t[2] return a single number but t[1:4] returns a tuple?

Because t[2] uses a single index to get one element (row 2 in execution_table), while t[1:4] uses a slice which returns a new tuple with elements from index 1 up to but not including 4 (row 3).

What happens if the slice end index is beyond the tuple length?

Python safely returns elements up to the end of the tuple without error. This is shown by the slice behavior in row 3, which stops before index 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of t[2] at step 2?

A 20

B 30

C (30, 40)

D 40

💡 Hint

Check the 'Result' column at step 2 in the execution_table.

At which step does the slice t[1:4] get evaluated?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the expression 't[1:4]' in the execution_table rows.

If we change t[1:4] to t[1:10], what would happen to the result_slice variable?

A It would return elements from index 1 to the end of the tuple

B It would return the same slice as before

C It would cause an error

D It would return an empty tuple

💡 Hint

Remember Python slices safely handle end indexes beyond tuple length, as explained in key_moments.

Concept Snapshot

Tuple indexing and slicing:
- Use t[index] to get one element.
- Use t[start:end] to get a sub-tuple slice.
- Indexing returns a single value.
- Slicing returns a new tuple.
- Slice end is exclusive and safe beyond length.

Full Transcript

This visual execution shows how tuple indexing and slicing work in Python. We start by creating a tuple t with five numbers. Then we get the element at index 2, which is 30, a single number. Next, we get a slice from index 1 to 4, which returns a new tuple with elements 20, 30, and 40. The slice end index is exclusive, so it stops before index 4. The variable tracker shows how the tuple stays the same, while the results for index and slice change as we evaluate expressions. Key moments clarify why indexing returns one element and slicing returns a tuple, and how slices handle end indexes beyond the tuple length safely. The quiz tests understanding of these steps and results.

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