Logo
Python Introduction
Python Installation and Project Setup
Running Python Programs
Python Syntax and Indentation Rules
Python Variables
Python Comments
Python Data Types
Python Type Conversion and Type Checking
Python Input and Output Functions
Python Operators
Python Arithmetic Operators
Python Assignment Operators
Python Logical Operators
Python Comparison Operators
Python Bitwise Operators
Python Membership Operators
Python Identity Operators
Python Walrus Operator
Python Operator Precedence
Python Conditional Statements
Python if Statement
Python if else
Python if elif else
Python match case Statement
Python Loops
Python for Loop
Python for else Loop
Python while Loop
Python break statement
Python continue statement
Python pass statement
Python Strings
Python String Slicing
Python String Concatenation
Python String Formatting
Python Escape Characters
Python Lists
Python Access List Items
Python Add List Items
Python Change List Items
Python Remove List Items
Python Sort Lists
Python Copy Lists
Python Join Lists
Python List Methods
Python Tuples
Python Access Tuple Items
Python Update Tuples
Python Unpack Tuples
Python Loop Tuples
Python Join Tuples
Python Tuple Methods
Python Sets
Python Dictionaries
Python Functions
Python Lambda Functions
Python Higher Order Functions
Python Classes and Objects
Python OOP Principles
Python Magic Methods
Python Context Managers
Python Error Handling and Debugging
Python File Handling
Python Modules and Packages
Python Iterators and Generators

Python String Slicing

Python string slicing is one of the most powerful and frequently used features of the Python language. It lets you extract a specific portion of a string by specifying a start index, a stop index, and an optional step value. Whether you need to pull out the first few characters of a word, grab a file extension from the end of a filename, or reverse an entire string in a single line, Python string slicing gives you a clean and readable way to do all of that without writing loops or calling complex methods.

Strings in Python are sequences, meaning every character occupies a position called an index. Indexing starts at zero from the left side and goes up by one for each character. Python string slicing works by selecting a range of those index positions to create a brand new string from the characters at those positions. The original string is never changed in the process.

Python String Slicing Syntax

The syntax for Python string slicing uses square brackets with colons to separate the three parts. The general form looks like this:

string[start:stop:step]

Each part plays a specific role:

  • start is the index where the slice begins, and that character is included in the result
  • stop is the index where the slice ends, and that character is NOT included in the result
  • step controls how many positions Python moves forward between each character it picks

All three parts are optional. Leaving start empty tells Python to begin at the very first character. Leaving stop empty tells Python to go all the way to the last character. Leaving step empty defaults to 1, which means Python picks up every consecutive character.

Here is a direct example to show the syntax in action:

text = "Python"
print(text[0:4])
print(text[1:5])
print(text[0:6])

Output:
Pyth
ytho
Python

The first slice picks up characters at positions 0, 1, 2, and 3, stopping before position 4. The second picks positions 1, 2, 3, and 4. The third grabs the entire word because it spans from index 0 to index 6, which covers every character in a six-character string.

Slice from the Start of a String

When you want to extract characters from the beginning of a string up to a certain point, you can either write 0 as the start or simply leave it blank. Python treats an empty start the same as 0.

language = "Programming"
print(language[0:4])
print(language[:4])

Output:
Prog
Prog

Both lines produce exactly the same result. Python reads the start as 0 in both cases and stops before index 4. This is a very common pattern when you want to read a prefix from a string, such as the first few characters of a code, a country dialing prefix, or an abbreviated label.

Slice to the End of a String

Leaving the stop value empty instructs Python to continue slicing all the way to the last character of the string. This is useful whenever you want to skip the beginning and take everything that follows a certain point.

message = "Hello World"
print(message[6:])

Output:
World

The slice starts at index 6, where the letter W sits, and continues through to the final character. You do not need to know the total length of the string. Python calculates that automatically when you leave stop empty. This pattern comes up often when stripping headers, removing prefixes, or extracting the tail end of formatted strings.

Negative Indexing in Python String Slicing

Python string slicing supports negative index values. A negative index counts from the right end of the string rather than the left. The very last character is always at index -1, the second-to-last is at -2, and this pattern continues toward the beginning.

Negative slicing is particularly useful when you want to grab characters from the end of a string without caring about its total length.

filename = "report2024.csv"
print(filename[-3:])

Output:
csv

The slice begins at the third character from the end and runs to the finish. This is a reliable way to extract a file extension or check the suffix of any string regardless of how long the full string is.

You can also mix positive and negative indices within the same slice:

data = "start-middle-end"
print(data[6:-4])

Output:
middle

The slice begins at index 6 on the left and ends four positions from the right. Python figures out the exact span and returns only the characters in between. This combination is very expressive and handles variable-length strings gracefully.

Step Parameter in Python String Slicing

The step value is the third part of the Python string slicing syntax. While start and stop define where you begin and end, the step defines how Python moves through that range. A step of 1 is the default and picks every character in order. A step of 2 skips one character between each selection. A step of 3 skips two.

word = "abcdefghij"
print(word[0:10:2])

Output:
acegi

The slice covers the full string from index 0 to 10, but with a step of 2 it only picks characters at positions 0, 2, 4, 6, and 8. Every odd-positioned character is skipped. This is a compact way to sample characters at regular intervals, extract alternating items, or create patterns from strings.

You can also limit the step to a specific range within the string:

phrase = "abcdefghij"
print(phrase[1:8:3])

Output:
beh

This starts at index 1, stops before index 8, and jumps by 3 each time. Python picks the characters at positions 1, 4, and 7.

Reverse a String with Python String Slicing

One of the most well-known techniques using Python string slicing is reversing a string. By setting the step to -1 and leaving both start and stop empty, Python walks through the string from the last character to the first.

name = "Python"
print(name[::-1])

Output:
nohtyP

With a negative step, Python works backwards. An empty start means Python begins at the far right end. An empty stop means Python continues all the way to the far left end. The result is the full string in reverse.

This technique is frequently used to check if a string is a palindrome, to undo text transformations, or to process strings in reverse order without using any extra libraries.

word = "racecar"
print(word == word[::-1])

Output:
True

The reversed slice of racecar matches the original, confirming it reads the same forwards and backwards.

How Python Handles Out-of-Range Slice Indices

A helpful property of Python string slicing is that it does not raise an error when the stop index goes beyond the length of the string. Instead, Python quietly adjusts to the last available character and returns what it can.

text = "Hello"
print(text[2:100])

Output:
llo

Index 100 is far beyond the length of the five-character string, but Python does not complain. It starts at index 2 and returns every character up to the end. This makes Python string slicing very safe to use in situations where you are not certain about the exact size of the input string.

This behavior is different from direct indexing, where accessing an index that does not exist raises an IndexError. Slicing is forgiving by design because it represents a range request rather than a precise position lookup.

Extracting a Substring from the Middle

Python string slicing is the standard approach for extracting a substring, which is any contiguous portion of a larger string. You simply define the start and stop positions around the text you want.

sentence = "Learning Python is fun"
print(sentence[9:15])

Output:
Python

Index 9 is where the word Python begins in this sentence. Index 15 is one position past where it ends. The result is the word Python cleanly extracted from the middle of the sentence.

In real programs, developers often calculate these positions dynamically using string methods like find or replace, but the slicing itself always follows the same pattern. Understanding how start and stop indices work is the core skill that makes all of that possible.

Slicing with Only the Step

You can use the step parameter without specifying start or stop. This applies the step across the entire string from beginning to end. The full string is sampled at the interval you choose.

alphabet = "abcdefghijklmnopqrstuvwxyz"
print(alphabet[::3])

Output:
adgjmpsvy

The slice covers all 26 characters and picks every third one starting from position 0. This produces characters at positions 0, 3, 6, 9, 12, 15, 18, 21, and 24.

Negative step values with no start or stop are what make string reversal so easy. Python uses the length of the string to determine the correct default bounds when you use a negative step, which is why the reversal trick works with just three characters.

Python String Slicing Creates a New String

An important detail about Python string slicing is that it always returns a new string. It never modifies the original. Strings in Python are immutable, meaning their content cannot be changed after they are created. Every slice operation produces an entirely new string object.

original = "Hello World"
sliced = original[6:]
print(original)
print(sliced)

Output:
Hello World
World

The original string is still intact after the slice. The variable sliced holds a brand new string. This is important to understand when writing programs that manipulate strings, because you always need to store the result of a slice in a new variable or use it directly, since the source string remains unchanged.

Full Working Example

This complete script demonstrates the key techniques of Python string slicing in a single runnable program. Each line shows a different way to use start, stop, step, and negative indices to extract exactly the characters you need from a string.

text = "HelloPythonWorld"

basic_slice = text[5:11]
from_start = text[:5]
to_end = text[11:]
negative_slice = text[-5:]
every_second = text[::2]
reversed_text = text[::-1]
step_in_range = text[5:11:2]

print(basic_slice)
print(from_start)
print(to_end)
print(negative_slice)
print(every_second)
print(reversed_text)
print(step_in_range)

Output:
Python
Hello
World
World
HloPtoWrd
dlroWnohtyPolleh
Pto

The first line extracts the word Python from the middle. The second takes the opening greeting. The third captures the final word by slicing from index 11 onward. The fourth uses a negative index to reach the same five characters from the right. The fifth samples every other character across the entire string. The sixth reverses the full string using a step of -1. The seventh applies a step of 2 within a specific range to pick alternating characters from just the Python portion.