Slicing and Indexing

Before we dive into slicing, it's crucial to understand how indexing works in Python. Think of a Python list like a row of numbered boxes - each box (element) has a label (index) that tells you its position. What makes Python special is that every element actually has TWO ways to identify it: a positive index counting from the left (starting at 0), and a negative index counting from the right (starting at -1). This dual-indexing system is like having two different address systems for the same street - one counting from the beginning and one from the end. Once you master this concept, accessing any element from either direction becomes second nature, and you'll never need to calculate "length minus something" to get elements from the end!

Accessing Single Elements

Use square brackets with an index to access a single element. Both positive and negative indices work the same way.

fruits = ["apple", "banana", "cherry", "date", "elderberry"]

# Positive indexing (from start)
print(fruits[0])   # Output: apple (first element)
print(fruits[2])   # Output: cherry (third element)

# Negative indexing (from end)
print(fruits[-1])  # Output: elderberry (last element)
print(fruits[-3])  # Output: cherry (third from end)

Now that you understand indexing, let's learn slicing - one of Python's most powerful features! While indexing gives you a single element, slicing lets you extract an entire chunk or "slice" of elements all at once. Imagine you have a loaf of bread and want to cut out several slices at once - that's exactly what Python slicing does with your data. The syntax [start:stop:step] might look intimidating at first, but think of it as instructions for a copy machine: "Start copying at position start, stop copying right before position stop, and take every step-th copy." The crucial beginner gotcha is that the stop position is exclusive (not included) - if you want elements 0, 1, and 2, you write [0:3], not [0:2]. Once this clicks, you'll be slicing like a pro!

Basic Slicing Examples

The most common use is [start:stop], which extracts elements from start up to (but not including) stop.

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Basic slice: start to stop (exclusive)
print(nums[2:5])    # Output: [2, 3, 4]
print(nums[0:3])    # Output: [0, 1, 2]

# Omitting start (defaults to 0)
print(nums[:4])     # Output: [0, 1, 2, 3]

# Omitting stop (defaults to end)
print(nums[6:])     # Output: [6, 7, 8, 9]

# Both omitted (copy entire list)
print(nums[:])      # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Slicing with Negative Indices

Negative indices work seamlessly in slices, letting you reference positions from the end of the sequence.

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Last 3 elements
print(nums[-3:])     # Output: [7, 8, 9]

# Everything except last 2
print(nums[:-2])     # Output: [0, 1, 2, 3, 4, 5, 6, 7]

# Middle portion using negative indices
print(nums[-7:-2])   # Output: [3, 4, 5, 6, 7]

# Mix positive and negative
print(nums[2:-2])    # Output: [2, 3, 4, 5, 6, 7]

colors = ["red", "blue", "green", "yellow", "purple", "orange"]
# Extract first 3 colors using slicing

colors = ["red", "blue", "green", "yellow", "purple", "orange"]
first_three = colors[:3]
print(first_three)  # Output: ['red', 'blue', 'green']

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Extract elements at indices 3, 4, 5, 6

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
middle = numbers[3:7]
print(middle)  # Output: [4, 5, 6, 7]

data = [10, 20, 30, 40, 50, 60, 70, 80]
# Remove first 2 and last 2 elements

data = [10, 20, 30, 40, 50, 60, 70, 80]
trimmed = data[2:-2]
print(trimmed)  # Output: [30, 40, 50, 60]

The step parameter is the optional third component in slice notation, and it's like a "skip" instruction that makes slicing even more powerful. Think of it like walking through a museum where step tells you how many exhibits to skip between stops. With step=1 (the default), you look at every single item without skipping. With step=2, you look at every other item (like reading only odd pages in a book). With step=3, you skip two items and look at the third, creating a pattern of every third element. Here's where it gets really cool: negative steps let you walk backwards through your sequence! A step of -1 means "go in reverse," -2 means "go in reverse, taking every other item," and so on. This single parameter unlocks countless patterns for extracting, sampling, and reversing your data.

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Every second element
print(nums[::2])     # Output: [0, 2, 4, 6, 8]

# Every third element
print(nums[::3])     # Output: [0, 3, 6, 9]

# Every second from index 1 to 8
print(nums[1:8:2])   # Output: [1, 3, 5, 7]

# Even indices only (0, 2, 4, ...)
print(nums[0::2])    # Output: [0, 2, 4, 6, 8]

# Odd indices only (1, 3, 5, ...)
print(nums[1::2])    # Output: [1, 3, 5, 7, 9]

Get ready to learn Python's most elegant party trick: the mysterious [::-1] notation that reverses any sequence in one line! When Python developers see this syntax, they smile - it's like a secret handshake in the Python community. But there's no magic here, just clever use of the step parameter. Remember that negative step means "go backwards"? Well, [::-1] simply means: "Start from the default position (the end), go to the default position (the beginning), and step backwards one element at a time." The colons with nothing before or after them mean "use the entire sequence," and the -1 means "walk backwards through it." The result? A perfectly reversed copy of your list or string without writing a single loop or calling complicated functions. This same technique works for partial reverses, palindrome checking, and many clever algorithmic tricks you'll discover as you progress!

# Reverse a list
nums = [1, 2, 3, 4, 5]
print(nums[::-1])    # Output: [5, 4, 3, 2, 1]

# Reverse a string
text = "Python"
print(text[::-1])    # Output: "nohtyP"

# Reverse with step -2 (every second, backwards)
print(nums[::-2])    # Output: [5, 3, 1]

# Reverse a portion
print(nums[3:0:-1])  # Output: [4, 3, 2]

letters = ['a', 'b', 'c', 'd', 'e']
# Reverse using slicing

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

nums = list(range(16))  # [0, 1, 2, ..., 15]
# Get every third element

nums = list(range(16))
every_third = nums[::3]
print(every_third)  # Output: [0, 3, 6, 9, 12, 15]

# Check if each word is a palindrome
word1 = "radar"
word2 = "python"

word1 = "radar"
word2 = "python"

is_palindrome1 = word1 == word1[::-1]
is_palindrome2 = word2 == word2[::-1]

print(f"'{word1}' is palindrome: {is_palindrome1}")  # True
print(f"'{word2}' is palindrome: {is_palindrome2}")  # False

Here's a delightful revelation: everything you've learned about slicing lists works identically with strings! In Python, strings are just sequences of characters, which means all your slicing superpowers apply to text too. Need to extract someone's first name from "John Smith"? Slice it. Want to remove the file extension from "document.pdf"? Slice it. Need to reverse a word to check if it's a palindrome? You guessed it - slice it! What makes string slicing especially valuable is that it's often simpler and faster than using complex string methods or regular expressions. Instead of memorizing a dozen different string functions, you can solve most text extraction and manipulation tasks with the slice notation you already know. Think of string slicing as your Swiss Army knife for text processing - whether you're parsing log files, formatting user input, extracting data from fixed-width formats, or building simple text parsers, string slicing is your reliable go-to tool.

text = "Hello, Python World!"

# Extract substrings
print(text[0:5])      # Output: Hello
print(text[7:13])     # Output: Python
print(text[-6:])      # Output: World!

# Skip characters
print(text[::2])      # Output: Hlo yhnWrd

# Common patterns
filename = "document.pdf"
print(filename[:-4])  # Output: document (remove extension)
print(filename[-3:])  # Output: pdf (get extension)

Practical String Slicing Examples

# Extract domain from email
email = "user@example.com"
domain = email[email.index('@')+1:]
print(domain)  # Output: example.com

# Format phone number
phone = "1234567890"
formatted = f"({phone[:3]}) {phone[3:6]}-{phone[6:]}"
print(formatted)  # Output: (123) 456-7890

# Mask credit card number
card = "4532015112830366"
masked = "****-****-****-" + card[-4:]
print(masked)  # Output: ****-****-****-0366

filename = "report.txt"
# Extract the extension

filename = "report.txt"
extension = filename[-3:]
print(extension)  # Output: txt

password = "secretpass"
# Create masked version: s********s

password = "secretpass"
masked = password[0] + "*" * (len(password) - 2) + password[-1]
print(masked)  # Output: s********s

url = "https://www.example.com/page/content"
# Extract: www.example.com

url = "https://www.example.com/page/content"
# Remove https://
start = url.index("//") + 2
# Find end of domain
end = url.index("/", start)
domain = url[start:end]
print(domain)  # Output: www.example.com

Ready to level up? So far you've used slicing to read data, but here's where things get really interesting: you can also write to slices! This opens up a whole new dimension of Python mastery. Imagine being able to replace multiple elements at once, insert items anywhere without loops, or delete sections of a list with surgical precision - all using the same slice notation you already know. These advanced techniques leverage Python's mutable sequences (like lists) to let you modify your data in place efficiently. Instead of writing verbose loops with counters and conditionals, you'll write clean, expressive one-liners that clearly communicate your intent. Many beginners don't even know these features exist, which is why mastering slice assignment, deletion, and copying techniques is your ticket from "learning Python" to "thinking in Python." These patterns appear constantly in professional code, and once you internalize them, you'll wonder how you ever lived without them!

Slice Assignment Basics

You can assign to a slice to replace multiple elements at once. The replacement doesn't need to be the same length as the slice.

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Replace a slice with same-length sequence
nums[2:5] = [20, 30, 40]
print(nums)  # Output: [0, 1, 20, 30, 40, 5, 6, 7, 8, 9]

# Replace with shorter sequence (list shrinks)
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
nums[2:7] = [99]
print(nums)  # Output: [0, 1, 99, 7, 8, 9]

# Replace with longer sequence (list grows)
nums = [0, 1, 2, 3, 4, 5]
nums[2:4] = [20, 21, 22, 23, 24]
print(nums)  # Output: [0, 1, 20, 21, 22, 23, 24, 4, 5]

Inserting Elements with Empty Slices

An empty slice (where start equals stop) selects zero elements. Assigning to an empty slice inserts new elements without replacing anything.

nums = [1, 2, 5, 6]

# Insert at position 2 (empty slice nums[2:2])
nums[2:2] = [3, 4]
print(nums)  # Output: [1, 2, 3, 4, 5, 6]

# Insert at beginning
nums[0:0] = [0]
print(nums)  # Output: [0, 1, 2, 3, 4, 5, 6]

# Insert at end (same as append/extend)
nums[len(nums):] = [7, 8, 9]
print(nums)  # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Deleting Elements with Slice Assignment

Assigning an empty list to a slice deletes those elements. This is equivalent to using del but more explicit.

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Delete elements 2-5
nums[2:6] = []
print(nums)  # Output: [0, 1, 6, 7, 8, 9]

# Same as using del statement
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del nums[2:6]
print(nums)  # Output: [0, 1, 6, 7, 8, 9]

# Delete every second element
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del nums[::2]
print(nums)  # Output: [1, 3, 5, 7, 9]

Replacing with Step Slices

When using a step in slice assignment, the replacement must have exactly the same number of elements as the slice selects.

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Replace every second element
nums[::2] = [10, 20, 30, 40, 50]
print(nums)  # Output: [10, 1, 20, 3, 30, 5, 40, 7, 50, 9]

# Replace specific positions
nums = list(range(10))
nums[2:8:2] = [99, 99, 99]
print(nums)  # Output: [0, 1, 99, 3, 99, 5, 99, 7, 8, 9]

Copying Lists - Shallow vs Deep

Slicing creates a shallow copy of a list. Understanding the difference between shallow and deep copies prevents subtle bugs with nested structures.

# Shallow copy with slicing
original = [1, 2, 3, 4, 5]
copy = original[:]
copy[0] = 99
print(original)  # Output: [1, 2, 3, 4, 5] (unchanged)
print(copy)      # Output: [99, 2, 3, 4, 5]

# Problem with nested lists (shallow copy)
original = [[1, 2], [3, 4]]
shallow = original[:]
shallow[0][0] = 99
print(original)  # Output: [[99, 2], [3, 4]] (changed!)
print(shallow)   # Output: [[99, 2], [3, 4]]

# Deep copy for nested structures
import copy
deep = copy.deepcopy(original)
deep[0][0] = 88
print(original)  # Output: [[99, 2], [3, 4]] (unchanged)
print(deep)      # Output: [[88, 2], [3, 4]]

Common Slicing Patterns Cheat Sheet

nums = [0, 1, 2, 3, 4, 5]
# Insert 99 and 100 at index 3

nums = [0, 1, 2, 3, 4, 5]
nums[3:3] = [99, 100]
print(nums)  # Output: [0, 1, 2, 99, 100, 3, 4, 5]

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Replace elements at indices 1, 3, 5, 7, 9 with 0

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
nums[1::2] = [0] * 5
print(nums)  # Output: [0, 0, 2, 0, 4, 0, 6, 0, 8, 0]

nums = [1, 2, 3, 4, 5]
# Rotate right by 2: [4, 5, 1, 2, 3]

nums = [1, 2, 3, 4, 5]
rotated = nums[-2:] + nums[:-2]
print(rotated)  # Output: [4, 5, 1, 2, 3]

Let's step out of the classroom and into the real world! You might be wondering, "When will I actually use all this slicing knowledge?" The answer: constantly! Every day, professional Python developers use slicing to solve practical problems across virtually every domain - web development, data science, automation, game development, financial analysis, and more. In this section, we'll explore concrete, real-world scenarios where slicing shines. You'll see how slicing handles pagination for e-commerce sites showing products 10 at a time, how data analysts use it to create rolling windows for stock price analysis, how web scrapers extract specific portions of text, how log parsers skip headers and footers, and how game developers manipulate 2D grids for tile maps. These aren't toy examples - they're actual patterns you'll use in your career. By seeing slicing in context, you'll develop intuition for when and how to apply it. Consider this section your bridge from "I understand slicing" to "I know exactly when to use it."

Data Processing and Cleaning

When working with CSV files, APIs, or databases, you often need to extract or transform specific portions of data. Slicing makes these operations concise and efficient.

# Remove header and footer from data
data = [
    "HEADER: Report 2026",
    "Name,Age,City",
    "Alice,28,NYC",
    "Bob,35,LA",
    "Charlie,42,Chicago",
    "FOOTER: Total 3 records"
]

# Extract only the data rows (skip first 2 and last 1)
records = data[2:-1]
print(records)
# Output: ['Alice,28,NYC', 'Bob,35,LA', 'Charlie,42,Chicago']

# Process each record
for record in records:
    name, age, city = record.split(',')
    print(f"{name} is {age} years old from {city}")

Pagination and Data Chunking

When displaying large datasets, pagination breaks data into manageable chunks. Slicing makes implementing pagination trivial.

# Paginate a large dataset
products = [f"Product_{i}" for i in range(1, 101)]  # 100 products

# Pagination settings
page_size = 10
current_page = 3  # Show page 3

# Calculate slice indices
start = (current_page - 1) * page_size
end = start + page_size

# Get current page
page_items = products[start:end]
print(f"Page {current_page}:")
print(page_items)
# Output: ['Product_21', 'Product_22', ..., 'Product_30']

# Total pages
import math
total_pages = math.ceil(len(products) / page_size)
print(f"Total pages: {total_pages}")

Rolling Windows for Time Series

In data analysis, rolling windows compute statistics over sliding intervals. Slicing creates these windows efficiently.

# Calculate 3-day moving average of stock prices
prices = [100, 102, 98, 105, 103, 107, 106, 110]
window_size = 3

# Compute moving averages
moving_averages = []
for i in range(len(prices) - window_size + 1):
    window = prices[i:i+window_size]
    avg = sum(window) / window_size
    moving_averages.append(round(avg, 2))

print("Prices:", prices)
print("3-day MA:", moving_averages)
# Output: 3-day MA: [100.0, 101.67, 102.0, 105.0, 105.33, 107.67]

Text Processing and Parsing

Extracting patterns from text - URLs, timestamps, codes - often uses slicing for known-position data.

# Parse log entries with fixed-width fields
log_entry = "2026-01-22 14:32:51 ERROR Database connection timeout"

# Extract components using slicing (fixed positions)
date = log_entry[0:10]        # "2026-01-22"
time = log_entry[11:19]       # "14:32:51"
level = log_entry[20:25]      # "ERROR"
message = log_entry[26:]      # "Database connection timeout"

print(f"Date: {date}")
print(f"Time: {time}")
print(f"Level: {level}")
print(f"Message: {message}")

# Format timestamp differently
year = date[0:4]
month = date[5:7]
day = date[8:10]
formatted = f"{month}/{day}/{year}"
print(f"Formatted date: {formatted}")  # Output: 01/22/2026

Image Processing (Pixel Arrays)

Images are often represented as 2D arrays. Slicing crops images, extracts regions, or flips them without complex libraries.

# Simulate grayscale image as 2D list (5x5 pixels)
image = [
    [10, 20, 30, 40, 50],
    [15, 25, 35, 45, 55],
    [20, 30, 40, 50, 60],
    [25, 35, 45, 55, 65],
    [30, 40, 50, 60, 70]
]

# Crop to center 3x3 region
cropped = [row[1:4] for row in image[1:4]]
print("Cropped image:")
for row in cropped:
    print(row)
# Output:
# [25, 35, 45]
# [30, 40, 50]
# [35, 45, 55]

# Flip image horizontally
flipped = [row[::-1] for row in image]
print("Flipped horizontally:")
for row in flipped[:3]:  # Show first 3 rows
    print(row)
# Output:
# [50, 40, 30, 20, 10]
# [55, 45, 35, 25, 15]
# [60, 50, 40, 30, 20]

Game Development: Grid Operations

2D games use grids for maps, boards, or tilemaps. Slicing accesses specific regions or patterns efficiently.

# Tic-tac-toe board (3x3 grid)
board = [
    ['X', 'O', 'X'],
    ['O', 'X', 'O'],
    ['O', 'X', 'X']
]

# Check rows for winner
for row in board:
    if row[0] == row[1] == row[2] != ' ':
        print(f"Winner: {row[0]} (row)")

# Check columns using slicing
for col in range(3):
    column = [board[row][col] for row in range(3)]
    if column[0] == column[1] == column[2] != ' ':
        print(f"Winner: {column[0]} (column {col})")

# Check diagonals
diagonal1 = [board[i][i] for i in range(3)]
diagonal2 = [board[i][2-i] for i in range(3)]

if diagonal1[0] == diagonal1[1] == diagonal1[2] != ' ':
    print(f"Winner: {diagonal1[0]} (diagonal)")
if diagonal2[0] == diagonal2[1] == diagonal2[2] != ' ':
    print(f"Winner: {diagonal2[0]} (diagonal)")

logs = [f"Log entry {i}" for i in range(1, 51)]  # 50 entries
# Get last 5 entries

logs = [f"Log entry {i}" for i in range(1, 51)]
recent_logs = logs[-5:]
print(recent_logs)
# Output: ['Log entry 46', 'Log entry 47', 'Log entry 48', 
#          'Log entry 49', 'Log entry 50']

items = list(range(1, 101))  # 100 items
# Create get_page(page_num, page_size) function

items = list(range(1, 101))

def get_page(page_num, page_size=10):
    start = (page_num - 1) * page_size
    end = start + page_size
    return items[start:end]

# Test
print(get_page(1, 10))   # First page: [1, 2, ..., 10]
print(get_page(5, 10))   # Page 5: [41, 42, ..., 50]

line = "John Doe            28  New York            "
# Extract name, age, and city using slicing (strip whitespace)

line = "John Doe            28  New York            "

name = line[0:20].strip()
age = line[21:24].strip()
city = line[25:40].strip()

print(f"Name: {name}")   # "John Doe"
print(f"Age: {age}")     # "28"
print(f"City: {city}")   # "New York"

As a beginner, you might think performance optimization is an advanced topic to tackle later, but understanding slicing performance from the start will save you from writing slow code! Here's the good news: Python's slicing operations are implemented in highly-optimized C code, making them incredibly fast - often 2-3 times faster than equivalent Python loops. However (and this is important), not all slicing patterns are created equal. Creating unnecessary slices in tight loops can waste memory and CPU cycles, while choosing the right approach can make your code blazingly fast. In this section, we'll demystify what happens behind the scenes when you slice, explore the time and space complexity (don't worry, we'll explain these terms!), and learn practical rules of thumb for writing efficient code. You'll discover why lst[::-1] is faster than list(reversed(lst)), when to use slice objects for better performance, and how to avoid common performance pitfalls. Think of this section as learning to drive efficiently - you don't need to understand every engine component, but knowing when to shift gears makes a huge difference!

Time Complexity of Slicing

Slicing creates a new sequence containing copies of elements from the original. The time complexity is O(k) where k is the number of elements in the slice.

Slicing vs Iteration Performance

For simple operations, slicing is often faster than equivalent loops because it's implemented in highly-optimized C code.

import time

# Large list
data = list(range(1_000_000))

# Method 1: Slicing (fast)
start = time.time()
even_slice = data[::2]
slice_time = time.time() - start
print(f"Slicing: {slice_time:.4f} seconds")

# Method 2: List comprehension (slower)
start = time.time()
even_comp = [data[i] for i in range(0, len(data), 2)]
comp_time = time.time() - start
print(f"Comprehension: {comp_time:.4f} seconds")

# Method 3: Loop with append (slowest)
start = time.time()
even_loop = []
for i in range(0, len(data), 2):
    even_loop.append(data[i])
loop_time = time.time() - start
print(f"Loop: {loop_time:.4f} seconds")

# Slicing is typically 2-3x faster!

Memory Considerations

Every slice creates a new object in memory. For large datasets, this can consume significant memory. Consider alternatives when memory is constrained.

# Memory-heavy approach (creates 10 copies)
big_list = list(range(10_000_000))  # ~80 MB
slices = [big_list[i:i+1_000_000] for i in range(0, 10_000_000, 1_000_000)]
# Now using ~800 MB (10 slices * ~80 MB each)

# Memory-efficient approach (uses iterators)
import itertools

def chunk_iterator(lst, chunk_size):
    for i in range(0, len(lst), chunk_size):
        yield lst[i:i+chunk_size]

# Process chunks one at a time
for chunk in chunk_iterator(big_list, 1_000_000):
    # Process chunk
    result = sum(chunk)  # Only one chunk in memory at a time
    
# Alternative: Use islice for memory efficiency
from itertools import islice

def process_chunks(lst, chunk_size):
    it = iter(lst)
    while True:
        chunk = list(islice(it, chunk_size))
        if not chunk:
            break
        yield chunk

for chunk in process_chunks(big_list, 1_000_000):
    # Process each chunk
    pass

Best Practices for Production Code

Optimizing Slice Operations

For repeated slices with same parameters, create a slice object once and reuse it.

# Inefficient: Creating slice repeatedly
data = list(range(100))
for _ in range(1000):
    subset = data[10:20:2]  # Slice created 1000 times

# Efficient: Create slice object once
data = list(range(100))
my_slice = slice(10, 20, 2)  # Create once
for _ in range(1000):
    subset = data[my_slice]  # Reuse slice object

# Slice objects can be named and reused
FIRST_TEN = slice(None, 10)
LAST_TEN = slice(-10, None)
EVEN_INDICES = slice(None, None, 2)

nums = list(range(100))
print(nums[FIRST_TEN])   # [0, 1, 2, ..., 9]
print(nums[LAST_TEN])    # [90, 91, ..., 99]
print(nums[EVEN_INDICES])  # [0, 2, 4, ..., 98]

# Slow for large strings
result = ""
for char in large_string:
    result = result + char  # Creates new string each time

# Fast alternative
result = "".join(list(large_string))  # Single operation

data = list(range(20))
# Create FIRST_HALF and SECOND_HALF slice objects

data = list(range(20))

FIRST_HALF = slice(None, len(data)//2)
SECOND_HALF = slice(len(data)//2, None)

print(data[FIRST_HALF])   # [0, 1, 2, ..., 9]
print(data[SECOND_HALF])  # [10, 11, 12, ..., 19]

data = list(range(1000))
results = []
for i in range(100):
    # Repeatedly creating same slice - optimize this
    subset = data[10:50:2]
    results.append(sum(subset))

data = list(range(1000))
results = []

# Create slice once
my_slice = slice(10, 50, 2)
for i in range(100):
    subset = data[my_slice]  # Reuse slice object
    results.append(sum(subset))

# Even better: Extract once if data doesn't change
data = list(range(1000))
subset = data[10:50:2]  # Extract once before loop
results = [sum(subset) for _ in range(100)]

# Create generator that yields chunks of size 1000
def chunk_generator(data, size):
    # Your code here
    pass

# Test with large dataset
data = list(range(10000))
for chunk in chunk_generator(data, 1000):
    print(f"Processing chunk with {len(chunk)} elements")

def chunk_generator(data, size):
    for i in range(0, len(data), size):
        yield data[i:i+size]

# Test
data = list(range(10000))
chunk_count = 0
for chunk in chunk_generator(data, 1000):
    chunk_count += 1
    # Process chunk
    
print(f"Processed {chunk_count} chunks")  # 10 chunks

Let's be honest: everyone makes slicing mistakes, especially when starting out! The difference between a struggling beginner and a confident developer isn't avoiding mistakes - it's recognizing and fixing them quickly. This section is your troubleshooting guide and mistake-prevention manual rolled into one. We'll walk through the most common slicing errors that trip up beginners (and sometimes even experienced developers!), from the classic "off-by-one" error where you get one fewer element than expected, to the subtle shallow copy trap that causes mysterious bugs with nested lists. You'll learn about surprising edge cases like what happens when you slice with out-of-bounds indices (spoiler: it doesn't crash!), why negative steps can confuse direction, and the tricky rules for slice assignment with steps. Each mistake is presented with clear examples showing both the wrong approach and the correct fix. Think of this section as learning from others' mistakes so you don't have to make them yourself. By the end, you'll have the debugging intuition to spot slicing bugs instantly and the knowledge to avoid them in the first place!

Mistake #1: Off-by-One Errors

The most common slicing mistake is forgetting that the stop index is exclusive, not inclusive.

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

# WRONG: Trying to get first 3 elements
wrong = nums[0:2]  # Only gets 2 elements!
print(wrong)  # Output: [10, 20]

# CORRECT: Stop index is exclusive
correct = nums[0:3]  # Gets indices 0, 1, 2
print(correct)  # Output: [10, 20, 30]

# Common mistake: "Get elements from index 2 to 4"
# Wrong interpretation: nums[2:4] gets 2 elements (indices 2,3)
# Correct understanding: nums[2:5] gets indices 2, 3, 4
print(nums[2:5])  # Output: [30, 40, 50]

Mistake #2: Modifying While Iterating

Modifying a list while slicing or iterating can lead to unexpected behavior and bugs.

# WRONG: Modifying list during iteration
nums = [1, 2, 3, 4, 5, 6]
for i in range(len(nums)):
    if nums[i] % 2 == 0:
        nums.pop(i)  # ERROR: List changes size during iteration!

# CORRECT: Iterate over a copy
nums = [1, 2, 3, 4, 5, 6]
for num in nums[:]:  # Slice creates a copy
    if num % 2 == 0:
        nums.remove(num)
print(nums)  # Output: [1, 3, 5]

# BETTER: Use list comprehension
nums = [1, 2, 3, 4, 5, 6]
nums = [n for n in nums if n % 2 != 0]
print(nums)  # Output: [1, 3, 5]

Mistake #3: Shallow Copy Surprise

Slicing creates a shallow copy, which can cause unexpected behavior with nested structures.

# Shallow copy problem with nested lists
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
copy = matrix[:]  # Shallow copy

# Modifying nested list affects both!
copy[0][0] = 999
print(matrix)  # Output: [[999, 2, 3], [4, 5, 6], [7, 8, 9]] ← Changed!
print(copy)    # Output: [[999, 2, 3], [4, 5, 6], [7, 8, 9]]

# Explanation: Outer list is copied, but inner lists are references
print(matrix[0] is copy[0])  # True - same object!

# CORRECT: Deep copy for nested structures
import copy
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
deep = copy.deepcopy(matrix)
deep[0][0] = 999
print(matrix)  # Output: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] ← Unchanged
print(deep)    # Output: [[999, 2, 3], [4, 5, 6], [7, 8, 9]]

Mistake #4: Forgetting String Immutability

Strings are immutable, so slice assignment doesn't work. You must create a new string.

text = "Hello World"

# WRONG: Can't assign to string slice
try:
    text[0:5] = "Goodbye"  # TypeError!
except TypeError as e:
    print(f"Error: {e}")

# CORRECT: Create new string
text = "Goodbye" + text[5:]
print(text)  # Output: "Goodbye World"

# Or use string methods
text = "Hello World"
text = text.replace("Hello", "Goodbye")
print(text)  # Output: "Goodbye World"

Edge Case #1: Empty Slices

When start >= stop (with positive step), the slice is empty. This is often surprising but intentional.

nums = [1, 2, 3, 4, 5]

# Empty slices
print(nums[3:3])   # Output: [] (start == stop)
print(nums[5:3])   # Output: [] (start > stop)
print(nums[10:20]) # Output: [] (both out of bounds)

# Useful for insertion
nums[3:3] = [99]
print(nums)  # Output: [1, 2, 3, 99, 4, 5]

# Edge case: Empty list slicing
empty = []
print(empty[0:5])   # Output: [] (doesn't raise error!)
print(empty[-5:5])  # Output: []

Edge Case #2: Out-of-Bounds Indices

Unlike indexing, slicing never raises IndexError even if indices are out of bounds.

nums = [1, 2, 3]

# Indexing raises error
try:
    value = nums[10]  # IndexError!
except IndexError:
    print("Index error!")

# Slicing handles gracefully
print(nums[10:20])    # Output: [] (no error)
print(nums[1:1000])   # Output: [2, 3] (truncated to list end)
print(nums[-1000:2])  # Output: [1, 2] (truncated to list start)

# This makes slicing safer for unknown indices
def get_first_n(lst, n):
    return lst[:n]  # Works even if n > len(lst)

print(get_first_n(nums, 100))  # Output: [1, 2, 3]

Edge Case #3: Negative Step Edge Cases

Negative steps reverse direction, which changes how start/stop work and can be confusing.

nums = [0, 1, 2, 3, 4, 5]

# With negative step, start should be > stop
print(nums[5:2:-1])  # Output: [5, 4, 3] (correct - goes backwards)
print(nums[2:5:-1])  # Output: [] (wrong - can't go backwards from 2 to 5)

# Common mistake: reversing a range
# WRONG
print(nums[0:5:-1])  # Output: [] (can't go backwards from 0 to 5)

# CORRECT
print(nums[5:0:-1])  # Output: [5, 4, 3, 2, 1] (stops before 0)
print(nums[5::-1])   # Output: [5, 4, 3, 2, 1, 0] (goes to start)
print(nums[::-1])    # Output: [5, 4, 3, 2, 1, 0] (full reverse)

# Tricky: Default values with negative step
print(nums[:2:-1])   # Output: [5, 4, 3] (starts from end, stops before 2)
print(nums[2::-1])   # Output: [2, 1, 0] (starts at 2, goes to start)

Edge Case #4: Step Size Greater Than Length

Large step sizes can result in single-element or empty slices, which is often unexpected.

nums = [0, 1, 2, 3, 4]

# Step larger than list
print(nums[::10])   # Output: [0] (only first element)
print(nums[1::10])  # Output: [1] (only second element)
print(nums[10::])   # Output: [] (start out of bounds)

# Practical example: sampling
large_list = list(range(1000))
sample = large_list[::100]  # Every 100th element
print(sample)  # Output: [0, 100, 200, 300, 400, 500, 600, 700, 800, 900]
print(len(sample))  # 10 elements

Edge Case #5: Assignment Length Mismatch with Step

When assigning to a stepped slice, replacement must have exact length. This is a frequent error.

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Stepped slice selects 5 elements
print(nums[::2])  # [0, 2, 4, 6, 8]

# WRONG: Length mismatch
try:
    nums[::2] = [10, 20, 30]  # ValueError: only 3 values for 5 positions
except ValueError as e:
    print(f"Error: {e}")

# CORRECT: Exact length match
nums[::2] = [10, 20, 30, 40, 50]
print(nums)  # Output: [10, 1, 20, 3, 30, 5, 40, 7, 50, 9]

# Works fine without step (flexible length)
nums = [0, 1, 2, 3, 4, 5]
nums[2:5] = [99]  # OK - replaces 3 elements with 1
print(nums)  # Output: [0, 1, 99, 5]

Debugging Tips

s = slice(2, 8, 2)
print(f"Start: {s.start}")
print(f"Stop: {s.stop}")
print(f"Step: {s.step}")

# Use indices() method
indices = s.indices(10)  # For length 10
print(f"Indices: {indices}")
# (2, 8, 2)

nums = [0, 1, 2, 3, 4, 5]
s = slice(1, 5, 2)

# Show what will be selected
result = nums[s]
print(f"nums[{s.start}:{s.stop}:{s.step}]")
print(f"Selects: {result}")
print(f"Indices: {list(range(*s.indices(len(nums))))}")

Best Practices to Avoid Mistakes

nums = [10, 20, 30, 40, 50, 60]
result = nums[2:4]  # BUG: Only gets [30, 40]
# Fix to get [30, 40, 50]

nums = [10, 20, 30, 40, 50, 60]
result = nums[2:5]  # Stop index is exclusive, so use 5 to include index 4
print(result)  # Output: [30, 40, 50]

original = [[1, 2], [3, 4]]
copy = original[:]
copy[0][0] = 999
print(original)  # BUG: Shows [[999, 2], [3, 4]] - should be unchanged!
# Fix this so original stays [[1, 2], [3, 4]]

import copy
original = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original)
deep_copy[0][0] = 999
print(original)    # Output: [[1, 2], [3, 4]] - unchanged!
print(deep_copy)   # Output: [[999, 2], [3, 4]]

nums = [0, 1, 2, 3, 4, 5]
result = nums[2:5:-1]  # BUG: Returns [] instead of [5, 4, 3, 2]
# Fix to get elements from index 5 down to 2

nums = [0, 1, 2, 3, 4, 5]
# With negative step, start > stop
result = nums[5:1:-1]  # Goes from 5 to 2 (stops before 1)
print(result)  # Output: [5, 4, 3, 2]