Slicing with start:stop:step in NumPy - Step-by-Step Execution

Concept Flow - Slicing with start:stop:step

Start with array

↓

Apply slice start:stop:step

↓

Calculate indices from start to stop by step

↓

Extract elements at these indices

↓

Return sliced array

We take an array, pick elements starting at 'start', up to but not including 'stop', stepping by 'step', and return those elements.

Execution Sample

NumPy

import numpy as np
arr = np.array([10,20,30,40,50,60])
slice_arr = arr[1:5:2]
print(slice_arr)

This code slices the array from index 1 to 4 stepping by 2, extracting elements at indices 1 and 3.

Execution Table

Step	Action	Indices Calculated	Elements Selected	Resulting Slice
1	Start with array	-	[10, 20, 30, 40, 50, 60]	[10, 20, 30, 40, 50, 60]
2	Apply slice 1:5:2	Indices 1, 3	-	-
3	Extract elements at indices	-	[20, 40]	-
4	Return sliced array	-	-	[20, 40]

💡 Slicing stops before index 5; step 2 selects indices 1 and 3.

Variable Tracker

Variable	Start	After slice
arr	[10, 20, 30, 40, 50, 60]	[10, 20, 30, 40, 50, 60]
slice_arr	N/A	[20, 40]

Key Moments - 3 Insights

Why does the slice stop before index 5 and not include it?

In slicing, the stop index is exclusive, so elements are taken up to but not including index 5, as shown in execution_table step 2.

What happens if the step is negative?

A negative step means slicing goes backward. Indices are calculated from start down to stop+1, stepping backward. This changes which elements are selected.

What if start or stop is omitted?

If start is omitted, slicing starts at the beginning (index 0). If stop is omitted, slicing goes to the end of the array. Step defaults to 1 if omitted.

Visual Quiz - 3 Questions

Look at the execution table, what elements are selected at step 3?

A [30, 50]

B [10, 30]

C [20, 40]

D [40, 60]

💡 Hint

Check the 'Elements Selected' column in execution_table row 3.

At which step does the slicing calculate the indices to use?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Indices Calculated' column in execution_table.

If the step was changed to 1, how would the resulting slice change?

A [10, 20, 30, 40]

B [20, 30, 40, 50]

C [20, 40]

D [30, 50, 60]

💡 Hint

Step 1 means selecting every element from start to stop-1, check variable_tracker for slice_arr.

Concept Snapshot

Slicing syntax: array[start:stop:step]
- start: index to begin (inclusive)
- stop: index to end (exclusive)
- step: how many indices to jump
Defaults: start=0, stop=array length, step=1
Returns a new array with selected elements.

Full Transcript

We start with a numpy array. When we slice with start:stop:step, numpy calculates indices from start up to but not including stop, jumping by step. Then it extracts elements at those indices and returns them as a new array. For example, arr[1:5:2] picks elements at indices 1 and 3. The stop index is exclusive, so index 5 is not included. If step is negative, slicing goes backward. Omitting start or stop uses defaults: start at 0, stop at array end. This slicing method is a quick way to pick parts of an array.

Practice

1. What does the step value control in a NumPy array slice like arr[start:stop:step]?

easy

A. How many elements to skip between each selected element

B. The total number of elements to select

C. The starting index of the slice

D. The ending index of the slice

Solution

1. Step 1: Understand the slice syntax

   The slice arr[start:stop:step] selects elements from start up to but not including stop, moving by step.

2. Step 2: Identify the role of step

   The step determines how many elements to skip between each selected element. For example, step=2 picks every second element.

3. Final Answer:

   How many elements to skip between each selected element -> Option A

4. Quick Check:

   Step controls skipping elements = A [OK]

Hint: Step is the gap between elements in slicing [OK]

Common Mistakes:

• Confusing step with start or stop index
• Thinking step is total count of elements
• Ignoring that step can be negative

2. Which of the following is the correct syntax to slice a NumPy array arr to get every 3rd element from index 1 to 10?

easy

A. arr[10:1:3]

B. arr[1:3:10]

C. arr[1:10:3]

D. arr[3:1:10]

Solution

1. Step 1: Recall slice order

   The slice syntax is arr[start:stop:step]. Here, start=1, stop=10, step=3 means from index 1 up to 9, every 3rd element.

2. Step 2: Check each option

   arr[1:10:3] matches the correct order and values. Others have wrong order or values that don't match the requirement.

3. Final Answer:

   arr[1:10:3] -> Option C

4. Quick Check:

   Correct slice syntax = D [OK]

Hint: Remember slice is start:stop:step in order [OK]

Common Mistakes:

• Mixing up stop and step positions
• Using step as stop index
• Reversing start and stop incorrectly

3. Given arr = np.array([10, 20, 30, 40, 50, 60, 70]), what is the output of arr[1:6:2]?

medium

A. [10 30 50 70]

B. [20 30 40 50 60]

C. [30 50]

D. [20 40 60]

Solution

1. Step 1: Identify slice indices

   The slice arr[1:6:2] starts at index 1 (value 20), stops before index 6, stepping by 2.

2. Step 2: Select elements

   Indexes selected: 1 (20), 3 (40), 5 (60). So output is [20 40 60].

3. Final Answer:

   [20 40 60] -> Option D

4. Quick Check:

   Elements at 1,3,5 = [20 40 60] [OK]

Hint: Pick elements at start, start+step, ... until stop-1 [OK]

Common Mistakes:

• Including stop index element
• Using wrong step size
• Starting from index 0 instead of 1

4. What is wrong with this code snippet?
arr = np.array([1,2,3,4,5])
slice = arr[4:1:-1]
What will slice contain?

medium

A. [4 3 2]

B. [5 4 3]

C. Empty array

D. IndexError

Solution

1. Step 1: Understand negative step slicing

   With step=-1, slicing goes backwards from start index 4 down to stop index 1 (exclusive).

2. Step 2: Identify elements selected

   Indexes selected: 4 (5), 3 (4), 2 (3). So slice contains [5 4 3].

3. Final Answer:

   [5 4 3] -> Option B

4. Quick Check:

   Backward slice from 4 to 2 = [5 4 3] [OK]

Hint: Negative step slices backward, stop is exclusive [OK]

Common Mistakes:

• Expecting forward slice with negative step
• Including stop index element
• Thinking it causes error

5. You have a NumPy array arr = np.arange(20). How would you slice it to get every 4th element in reverse order starting from the last element?

hard

A. arr[19::-4]

B. arr[::4]

C. arr[19:0:4]

D. arr[0:19:-4]

Solution

1. Step 1: Understand array and goal

   arr = np.arange(20) creates array from 0 to 19. We want every 4th element backward starting from last element (index 19).

2. Step 2: Check slicing options

   arr[19::-4] starts at index 19, goes backward to start (index 0), stepping by 4, which matches the goal.

3. Step 3: Verify other options

   A: arr[::4] every 4th forward [0,4,8,...], wrong direction. C: arr[19:0:4] positive step with start>stop gives empty. D: arr[0:19:-4] start<stop with negative step gives empty.

4. Final Answer:

   arr[19::-4] -> Option A

5. Quick Check:

   Reverse every 4th from last = arr[19::-4] [OK]

Hint: Use start index with negative step for reverse slicing [OK]

Common Mistakes:

• Using positive step with decreasing indices
• Wrong start or stop indices
• Assuming arr[::-4] always starts at last element