Search⌘ K
AI Features
Home
Courses
Learn Data Structures and Algorithms

Basic String Operations

Explore fundamental string operations such as slicing, concatenation, repetition, splitting, and joining. Understand their syntax, behavior, and computational costs in Python. This lesson helps you build a solid foundation for implementing efficient string algorithms and recognizing performance implications.

We'll cover the following...

Having established that strings are immutable and that any apparent modification produces a new string rather than altering the original, the next step is to build familiarity with the operations that are actually available on strings. These operations form the practical foundation of string algorithm implementation. Each one has a defined behavior and a measurable cost, and understanding both is essential before moving on to writing algorithms that use them.

Slicing: Extracting part of a string

Slicing is the operation of extracting a contiguous portion of a string. The extracted portion is called a substring, and it is returned as a new string. The original string remains unchanged.

In Python, slicing is performed using the following syntax:

s[start:end]

The result contains all characters from the start index up to but not including the end index. Consider the following example:

Python 3.14.0
# Initialization of the string data
s = "hello world"
# Accessing the first five characters (indices 0 to 4)
# The character at index 5 (' ') is excluded.
print(f"Substring from index 0 to 5: \"{s[0:5]}\"\n")
# Accessing characters from index 6 to the end (indices 6 to 10)
# This represents the second word in the sequence.
print(f"Substring from index 6 to 11: \"{s[6:11]}\"\n")
# Accessing a shorter prefix (indices 0 to 2)
print(f"Substring from index 0 to 3: \"{s[0:3]}\"")

In this example, s[0:5] extracts the first five characters, and s[6:11] extracts the last five. The character at the end index is never included in the result.

Now, let's look at the following visualiser for a better understanding of slicing in strings:

Omitting start and end in slicing

If the start or end values are omitted, Python uses default values:

  • When the start index is omitted, the slice begins from the first character.

  • When the end index is omitted, the slice extends to the last character.

  • When both are omitted, the entire string is returned as a new copy.

Python 3.14.0
s = "hello world"
# Accessing from the start of the string to index 4 (indices 0 to 4)
# When the start index is omitted, it defaults to 0.
print(f"Substring from the start to index 5: \"{s[:5]}\"\n")
# Accessing from index 6 to the end of the string
# When the end index is omitted, it defaults to the length of the string.
print(f"Substring from index 6 to the end: \"{s[6:]}\"\n")
# Accessing the entire string sequence
# Omitting both indices creates a complete shallow copy of the string.
print(f"Full string copy using slicing: \"{s[:]}\"")

Step in slicing

Slicing also accepts a third argument called the step, which determines how characters are selected within the specified range. 

s[start:end:step]

A step of 2 selects every second character, and a step of -1 traverses the string in reverse order.

Python 3.14.0
s = "hello world"
# The third parameter (step) determines the increment between indices.
# Indices accessed: 0, 2, 4, 6, 8, 10
print(f"Every second character from the string: \"{s[::2]}\"\n")
# Accessing the string in reverse order
# A negative step of -1 starts from the end and moves toward the beginning.
print(f"The string in reverse order: \"{s[::-1]}\"")

Complexity analysis of slicing

Producing a slice of length kk ...