1   Indexing: One Item at a Time

Before slicing makes sense, you need to be comfortable with indexing — accessing a single item from a sequence using its position number. Every character in a string and every item in a list has an index: a number that says where it sits.

1.1   Zero-Based Indexing

Python counts positions starting from zero, not one. The first item is at index 0, the second at index 1, and so on. This is called zero-based indexing and it is used in almost every programming language.

language = "Python"

print(language[0])    # P  — first character
print(language[1])    # y
print(language[5])    # n  — last character

1.2   Negative Indices: Counting From the End

Python also lets you count backwards from the end using negative numbers. Index -1 is always the last item, -2 is second-to-last, and so on. This is incredibly useful when you want the end of a sequence but you do not know how long it is.

language = "Python"

print(language[-1])   # n  — last character
print(language[-2])   # o  — second to last
print(language[-6])   # P  — same as [0]

2   What Is a Slice?

An index gives you one item. A slice gives you a range of items — a section of the sequence from one position to another, returned as a new string or list.

2.1   Basic Slice Notation

A slice is written with square brackets and a colon separating two positions:

sequence[start : stop]

• start — the index of the first item to include.
• stop — the index of the first item not to include. The slice stops before this position.

language = "Python"
#            0 1 2 3 4 5

print(language[0:3])    # Pyt   — indices 0, 1, 2  (stops before 3)
print(language[2:5])    # tho   — indices 2, 3, 4  (stops before 5)
print(language[1:4])    # yth   — indices 1, 2, 3  (stops before 4)

2.2   Visualising the Slice

A helpful mental model: think of the indices as sitting between the characters, like fence posts between fence panels. A slice cuts between two fence posts and lifts out everything between them.

[0:3] cuts at position 0 and position 3, lifting out Pyt. [2:5] cuts at position 2 and position 5, lifting out tho. Position 6 is one past the end — that is why [0:6] gives you the entire string.

3   Shorthand: Omitting start or stop

Python lets you leave out either — or both — values in a slice. When you omit a value, Python uses a sensible default:

word = "Python"

print(word[:3])     # Pyt   — first 3 characters
print(word[3:])     # hon   — everything from index 3 onward
print(word[:])      # Python — a full copy

4   Negative Indices in Slices

Just like with single-item indexing, you can use negative numbers in slices to count from the end. This is especially powerful when you do not know the length of the sequence in advance.

filename = "report_2026_final.csv"

print(filename[-4:])      # .csv  — the last 4 characters (the extension)
print(filename[:-4])      # report_2026_final  — everything except the extension
print(filename[-8:-4])    # inal  — 4 characters, 8 from the end to 4 from the end

phrase = "Hello, World!"
#         0123456789...

print(phrase[-6:])       # orld!  — last 6 characters
print(phrase[:-1])       # Hello, World  — everything except the final !
print(phrase[-6:-1])     # orld   — 5 characters near the end

5   The Third Value: Step

The full slice notation actually has a third optional value — the step. It tells Python how many positions to jump between each item it picks up:

sequence[start : stop : step]

When you write [0:6], the step defaults to 1 — pick up every item. With [0:6:2], the step is 2 — pick up every other item.

5.1   Step in Action

letters = "abcdefgh"

print(letters[::2])      # aceg  — every other character (step 2)
print(letters[1::2])     # bdfh  — starting from index 1, every other
print(letters[::3])      # adg   — every third character
print(letters[0:8:2])    # aceg  — explicit start/stop with step 2

5.2   Reversing with Step -1

The most famous use of the step value is reversing a sequence. A step of -1 means "go backwards one position at a time." Combined with omitting start and stop, it reverses the entire sequence:

word = "Python"
print(word[::-1])        # nohtyP — the word reversed

numbers = [1, 2, 3, 4, 5]
print(numbers[::-1])     # [5, 4, 3, 2, 1]

[::-1] is a Python idiom — a well-known, widely used shorthand that every Python programmer recognises immediately. It is worth memorising.

6   Slicing Lists

Everything you have learned about slicing strings applies equally to lists. The notation is identical — the only difference is that you get back a list instead of a string.

scores = [85, 42, 91, 67, 55, 78, 39, 95]
#          0   1   2   3   4   5   6   7

print(scores[0:3])      # [85, 42, 91]  — first three scores
print(scores[3:])       # [67, 55, 78, 39, 95]  — from index 3 onward
print(scores[:3])       # [85, 42, 91]  — same as [0:3]
print(scores[-3:])      # [78, 39, 95]  — last three scores
print(scores[::2])      # [85, 91, 55, 39]  — every other score
print(scores[::-1])     # [95, 39, 78, 55, 67, 91, 42, 85]  — reversed

6.1   Slices Create New Lists — The Original Is Unchanged

A slice never modifies the original. It creates a brand-new sequence containing the selected items. This means you can slice freely without worrying about damaging your data:

scores = [85, 42, 91, 67, 55]

top_three = scores[:3]        # a new list — [85, 42, 91]
bottom_two = scores[-2:]      # a new list — [67, 55]

print(scores)                 # [85, 42, 91, 67, 55] — unchanged
print(top_three)              # [85, 42, 91]
print(bottom_two)             # [67, 55]

6.2   Practical List Slicing

students = ["Alice", "Bob", "Carol", "Dan", "Eve", "Fran"]

# First half vs second half
midpoint = len(students) // 2
group_a = students[:midpoint]
group_b = students[midpoint:]
print("Group A:", group_a)     # ['Alice', 'Bob', 'Carol']
print("Group B:", group_b)     # ['Dan', 'Eve', 'Fran']

# Skip the first and last (sometimes used to ignore header/footer rows)
middle = students[1:-1]
print("Middle:", middle)       # ['Bob', 'Carol', 'Dan', 'Eve']

7   An Important Difference: Strings vs. Lists

Slicing behaves identically on strings and lists — with one crucial difference: strings are immutable. You cannot change a character inside a string. Lists are mutable — you can change, add, and remove items.

# Strings — immutable, cannot change individual characters
name = "Python"
name[0] = "J"        # TypeError: 'str' object does not support item assignment

# To "change" a string, you must build a new one using slices:
name = "J" + name[1:]
print(name)          # Jython

# Lists — mutable, individual items can be changed directly
colours = ["red", "green", "blue"]
colours[1] = "yellow"
print(colours)       # ['red', 'yellow', 'blue']

# You can also replace a slice of a list:
colours[0:2] = ["pink", "purple"]
print(colours)       # ['pink', 'purple', 'blue']

8   Common Slice Patterns Worth Memorising

These patterns come up so frequently in real Python code that they are worth learning by name, just like the loop patterns in Article 5.

9   Putting It All Together

Here is a program that uses slicing in several realistic ways. Read it and predict the output before running it.

def is_palindrome(word):
    """Returns True if word reads the same forwards and backwards."""
    return word.lower() == word.lower()[::-1]

def file_extension(filename):
    """Returns the file extension including the dot."""
    dot_index = filename.rfind(".")         # find the last dot
    return filename[dot_index:]

def truncate(text, max_length):
    """Shortens text to max_length characters, adding '...' if needed."""
    if len(text) <= max_length:
        return text
    return text[:max_length] + "..."

def initials(full_name):
    """Returns initials from a full name, e.g. 'Ada Lovelace' -> 'A.L.'"""
    parts = full_name.split()               # split into a list of words
    return ".".join(word[0] for word in parts) + "."


# ── Testing each function ─────────────────────────────────────────
test_words = ["racecar", "python", "level", "hello"]
for word in test_words:
    result = "✓ palindrome" if is_palindrome(word) else "✗ not a palindrome"
    print(f"  {word:<10} {result}")

print()
filenames = ["report.docx", "data_2026.csv", "image.final.png"]
for f in filenames:
    print(f"  {f:<25} extension: {file_extension(f)}")

print()
long_text = "The quick brown fox jumped over the lazy dog"
print(truncate(long_text, 20))
print(truncate("Short text", 20))

print()
names = ["Ada Lovelace", "Alan Turing", "Grace Hopper"]
for name in names:
    print(f"  {name:<20} initials: {initials(name)}")

Slicing at work in this program:

• word.lower()[::-1] — reverses the lowercased word to check for palindromes.
• filename[dot_index:] — slices from the dot to the end to get the extension.
• text[:max_length] — takes the first max_length characters for truncation.
• word[0] — single-character index to get each word's first letter for initials.

10   Final Check: The Big Picture

11   Quick-Reference Summary