Python String Manipulation

Now that you know how to create strings, let's learn how to work with their individual characters and extract specific portions. Indexing lets you access a single character by its position, while slicing lets you extract a portion of the string. These are fundamental skills you will use constantly when processing text data.

String Indexing

Each character in a string has a position called an index. Think of a string like a row of numbered boxes, where each box contains exactly one character. Python uses zero-based indexing, which means counting starts at 0, not 1. This might feel strange at first, but it is standard in most programming languages.

Accessing characters with positive indices:

Positive indices count from the beginning of the string, starting at 0. To access a character, use square brackets after the string with the index number inside. For example, text[0] gives you the first character, text[1] gives the second, and so on.

# Positive indexing starts from 0
text = "Python"

print(text[0])   # P (first character)
print(text[1])   # y (second character)
print(text[5])   # n (sixth/last character)

# Trying to access beyond length raises IndexError
# print(text[6])  # IndexError: string index out of range

Accessing characters with negative indices:

Negative indices count backwards from the end of the string. -1 is always the last character, -2 is the second-to-last, and so on. This is incredibly useful when you want to get characters from the end without knowing the exact length of the string.

# Negative indexing starts from -1 (last character)
text = "Python"

print(text[-1])  # n (last character)
print(text[-2])  # o (second to last)
print(text[-6])  # P (first character)

# Very useful for getting the last character
filename = "document.pdf"
print(filename[-4:])  # .pdf (file extension)

String Slicing

While indexing gets you one character, slicing extracts a portion (called a substring) from a string. Think of slicing like cutting a piece from a loaf of bread. You specify where to start cutting and where to stop, and Python gives you everything in between.

The slicing syntax is string[start:stop:step], where each part controls a different aspect of the slice. Do not worry if this looks complicated. Let's break it down piece by piece.

Basic slicing with start and stop:

The most common form of slicing uses just start and stop. Remember that Python includes the character at start but excludes the character at stop. If you omit start, Python assumes 0 (the beginning). If you omit stop, Python goes to the end of the string.

text = "Hello, World!"

# Basic slicing [start:stop]
print(text[0:5])    # Hello (indices 0,1,2,3,4)
print(text[7:12])   # World (indices 7,8,9,10,11)

# Omitting start or stop
print(text[:5])     # Hello (from beginning to index 5)
print(text[7:])     # World! (from index 7 to end)
print(text[:])      # Hello, World! (entire string - copy)

Slicing with step:

The step parameter controls how Python moves through the string. A step of 2 means "take every second character," step of 3 means "every third," and so on. A negative step makes Python go backwards through the string, which is the secret to reversing strings with [::-1].

text = "Hello, World!"

# Every second character
print(text[::2])    # Hlo ol! (step of 2)

# Every third character
print(text[::3])    # Hl r!

# Reverse the string (step of -1)
print(text[::-1])   # !dlroW ,olleH

Combining slicing techniques:

You can combine all three parts (start, stop, step) for powerful text extraction. Here are some common patterns you will use frequently: getting the first N characters, the last N characters, reversing strings, and more.

text = "Programming"

# First 4 characters
print(text[:4])      # Prog

# Last 4 characters
print(text[-4:])     # ming

# Middle portion
print(text[3:7])     # gram

# Every other character from index 1 to 8
print(text[1:8:2])   # rgam

# Reverse just a portion
print(text[4::-1])   # gorP

Common Slicing Patterns

Here are the most frequently used slicing patterns that you will encounter in real-world programming. Each pattern solves a specific problem, so learn them well and they will become second nature. These patterns are like tools in a toolbox. Once you memorize them, you can quickly grab the right one for any string manipulation task.

Get the first N characters using [:N] to extract the beginning of a string. When you write text[:N], you are telling Python: "Start from the very beginning (index 0) and give me everything up to, but not including, index N." Since we omit the start value, Python automatically begins at position 0. This pattern is incredibly useful for getting prefixes, creating abbreviations, truncating long text for display previews, or extracting the first word of a sentence.

text = "Python Programming"

# Get first N characters
first_three = text[:3]     # "Pyt"
first_six = text[:6]       # "Python"

# Practical: Truncate long text for preview
title = "Introduction to Machine Learning Algorithms"
preview = title[:20] + "..."  # "Introduction to Mach..."

Get the last N characters using [-N:] to extract the end of a string. Negative indices count backwards from the end, so -1 is the last character, -2 is second-to-last, and so on. When you write text[-N:], you are saying: "Start N characters from the end and give me everything from there to the very end." Since we omit the stop value, Python goes all the way to the last character. This is perfect for extracting file extensions, getting the last few digits of a phone number, or grabbing suffixes from words.

text = "Python Programming"

# Get last N characters  
last_four = text[-4:]      # "ming"
last_word = text[-11:]     # "Programming"

# Practical: Get file extension
filename = "report_2024.pdf"
extension = filename[-4:]  # ".pdf"

Remove the first N characters using [N:] to skip the beginning and get everything after. When you write text[N:], you are telling Python: "Skip the first N characters and give me everything from index N to the end." This is the opposite of getting the first N characters. It is useful when you want to remove a known prefix, strip a protocol like "https://" from URLs, skip headers in data, or remove leading characters you do not need.

text = "Python Programming"

# Remove first N characters
without_first = text[1:]   # "ython Programming"
skip_three = text[3:]      # "hon Programming"

# Practical: Remove "https://" from URL
url = "https://www.example.com"
domain = url[8:]           # "www.example.com"

Remove the last N characters using [:-N] to exclude the ending. When you write text[:-N], you are saying: "Start from the beginning and stop N characters before the end." The negative stop index means "count backwards from the end." This pattern is great for removing file extensions (like ".txt" or ".pdf"), trimming known suffixes, cutting off trailing characters, or removing the last word from a sentence. Remember, the character at the stop index is never included.

text = "Python Programming"

# Remove last N characters
without_last = text[:-1]   # "Python Programmin"
trim_four = text[:-4]      # "Python Program"

# Practical: Remove file extension
filename = "document.txt"
name_only = filename[:-4]  # "document"

Reverse a string using [::-1]. This is one of Python's most elegant tricks. When you write text[::-1], you are saying: "Give me the entire string (from start to end), but step through it backwards one character at a time." The -1 step value means "move backwards by one position." Since we omit start and stop, Python uses the entire string. This is the easiest and most Pythonic way to reverse a string. It is commonly used for checking palindromes (words that read the same forwards and backwards, like "radar" or "level"), creating mirror effects, or simply reversing text.

text = "Python Programming"

# Reverse entire string
reversed_text = text[::-1] # "gnimmargorP nohtyP"

# Check if a word is a palindrome (same forwards and backwards)
word = "radar"
is_palindrome = word == word[::-1]  # True

word2 = "hello"
is_palindrome2 = word2 == word2[::-1]  # False

filename = "report_2024.pdf"

filename = "report_2024.pdf"
extension = filename[-4:]
print(extension)  # .pdf

words = ["radar", "hello", "level", "python", "madam"]

words = ["radar", "hello", "level", "python", "madam"]

for word in words:
    if word == word[::-1]:
        print(f"{word} is a palindrome")
    else:
        print(f"{word} is NOT a palindrome")

# Output:
# radar is a palindrome
# hello is NOT a palindrome
# level is a palindrome
# python is NOT a palindrome
# madam is a palindrome

email = "john.doe@company.com"

email = "john.doe@company.com"

# Find position of @
at_position = email.find("@")

# Slice everything after @
domain = email[at_position + 1:]
print(domain)  # company.com

secret = "Htehlelroe"

secret = "Htehlelroe"
message = secret[::2]
print(message)  # Hello

Python strings come with dozens of built-in methods (special functions attached to strings) that make text manipulation incredibly easy. Instead of writing complex code to convert text to uppercase, find a word, or split a sentence into words, you can use simple, readable methods that do the work for you.

Case Conversion Methods

One of the most common tasks is changing the case (uppercase/lowercase) of text. This is essential when you need to compare user input (since "YES", "yes", and "Yes" are all different to Python), format names properly, or normalize data for processing.

upper() and lower():

upper() converts every letter in the string to uppercase (capital letters). lower() converts every letter to lowercase. Numbers, symbols, and spaces remain unchanged. These methods are essential for case-insensitive comparisons, since "Yes" and "yes" are different strings in Python.

# Convert to uppercase
text = "Hello World"
print(text.upper())  # HELLO WORLD

# Convert to lowercase
print(text.lower())  # hello world

# Useful for case-insensitive comparison
user_input = "YES"
if user_input.lower() == "yes":
    print("User confirmed!")  # User confirmed!

capitalize() and title():

capitalize() makes only the first character uppercase and the rest lowercase. title() capitalizes the first letter of every word (like a book title). These are perfect for formatting names, titles, and headings properly.

# Capitalize first character only
text = "hello world"
print(text.capitalize())  # Hello world

# Title case - capitalize first letter of each word
print(text.title())  # Hello World

# Useful for formatting names
name = "john DOE"
print(name.title())  # John Doe

swapcase():

swapcase() inverts the case of every letter: uppercase becomes lowercase, and lowercase becomes uppercase. While not as commonly used, it can be handy for creating visual effects or toggling text.

# Swap uppercase and lowercase
text = "Hello World"
print(text.swapcase())  # hELLO wORLD

mixed = "PyThOn"
print(mixed.swapcase())  # pYtHoN

Whitespace Methods

Whitespace refers to invisible characters like spaces, tabs, and newlines. These often sneak into your data when users accidentally type extra spaces, or when you read data from files. Cleaning up whitespace is one of the most common data cleaning tasks in programming.

strip(), lstrip(), and rstrip():

strip() removes whitespace from both the beginning and end of a string. lstrip() removes only from the left (beginning), and rstrip() removes only from the right (end). You can also pass specific characters to remove instead of whitespace.

# Remove whitespace from both ends
text = "   Hello World   "
print(f"'{text.strip()}'")   # 'Hello World'

# Remove only from left (beginning)
print(f"'{text.lstrip()}'")  # 'Hello World   '

# Remove only from right (end)
print(f"'{text.rstrip()}'")  # '   Hello World'

# Remove specific characters
dirty = "###Python###"
print(dirty.strip("#"))      # Python

Search and Replace Methods

Finding text within strings and replacing it with something else are among the most frequently used string operations. Whether you are searching for keywords in documents, validating email formats, or cleaning up messy data, these methods are essential tools in your programming toolkit.

find() and index():

These methods search for a substring and return its starting position. The key difference: find() returns -1 if not found (safe), while index() raises an error (crashes your program if not handled).

# find() returns index of first occurrence, -1 if not found
text = "Hello, Hello, Hello"
print(text.find("Hello"))     # 0 (first occurrence)
print(text.find("World"))     # -1 (not found)
print(text.find("Hello", 1))  # 7 (start search from index 1)

# index() is similar but raises ValueError if not found
print(text.index("Hello"))    # 0
# text.index("World")         # ValueError!

replace():

replace(old, new) finds all occurrences of old text and replaces them with new text. It is case-sensitive, so "cats" and "Cats" are treated as different. You can optionally specify a maximum number of replacements as a third argument.

# Replace all occurrences
text = "I like cats. Cats are great."
print(text.replace("cats", "dogs"))  
# I like dogs. Cats are great.  (case-sensitive!)

# Replace with count limit
print(text.replace("a", "@", 2))  
# I like c@ts. C@ts are great.  (only first 2 'a's)

# Chain replacements
messy = "hello...world..."
clean = messy.replace("...", " ").replace("  ", " ")
print(clean)  # hello world

startswith() and endswith():

These methods check if a string begins or ends with specific text, returning True or False. They are extremely useful for checking file extensions, URL protocols, or any prefix/suffix validation. You can even check multiple options at once by passing a tuple.

# Check if string starts with prefix
filename = "report_2024.pdf"
print(filename.startswith("report"))  # True
print(filename.startswith("data"))    # False

# Check if string ends with suffix
print(filename.endswith(".pdf"))      # True
print(filename.endswith(".txt"))      # False

# Check multiple options with tuple
print(filename.endswith((".pdf", ".doc", ".txt")))  # True

Split and Join Methods

split() and join() are a powerful pair of methods that convert between strings and lists. Think of split() as breaking a sentence into individual words, and join() as gluing words back together into a sentence.

split():

Breaks a string into a list of substrings. By default, it splits on any whitespace (spaces, tabs, newlines). You can specify a different delimiter like commas, dashes, or any character.

# Split by whitespace (default)
sentence = "Python is amazing"
words = sentence.split()
print(words)  # ['Python', 'is', 'amazing']

# Split by specific delimiter
data = "apple,banana,cherry"
fruits = data.split(",")
print(fruits)  # ['apple', 'banana', 'cherry']

# Split with max splits
path = "home/user/documents/file.txt"
parts = path.split("/", 2)
print(parts)  # ['home', 'user', 'documents/file.txt']

join():

join() is the opposite of split(). It takes a list of strings and combines them into one string, inserting a separator between each element. The syntax is separator.join(list). Use an empty string "" to concatenate without any separator.

# Join list elements with separator
words = ['Python', 'is', 'awesome']

# Join with space
print(" ".join(words))      # Python is awesome

# Join with comma
print(",".join(words))      # Python,is,awesome

# Join with nothing (concatenate)
letters = ['H', 'e', 'l', 'l', 'o']
print("".join(letters))     # Hello

# Useful for creating CSV lines
data = ["John", "25", "Engineer"]
csv_line = ",".join(data)
print(csv_line)             # John,25,Engineer

Validation Methods

When accepting user input or processing external data, you often need to verify that strings contain the expected type of characters. Is this a valid username (only letters and numbers)? Is this a valid age (only digits)? Python's validation methods make these checks simple and readable.

isalpha() checks if every character in the string is a letter (A-Z or a-z). It returns True only if the string contains nothing but alphabetic characters. This is useful for validating names, checking if a word contains only letters, or ensuring input has no numbers or special characters. Spaces, numbers, and punctuation will cause it to return False.

# Check if string contains only letters
print("Hello".isalpha())      # True
print("Hello123".isalpha())   # False (contains digits)
print("Hello World".isalpha())# False (space is not a letter)
print("John".isalpha())       # True - valid for name validation

isdigit() checks if every character in the string is a digit (0-9). It returns True only if the string contains nothing but numeric digits. This is perfect for validating numeric input like age, phone numbers, or PIN codes. Note that decimal points, negative signs, and spaces are not digits, so "12.34" and "-5" return False.

# Check if string contains only digits
print("12345".isdigit())      # True
print("12.34".isdigit())      # False (dot is not a digit)
print("-123".isdigit())       # False (minus sign is not a digit)
print("25".isdigit())         # True - valid for age validation

isalnum() checks if every character is either a letter OR a digit (alphanumeric). It returns True if the string contains only letters and numbers with no spaces, punctuation, or special characters. This is ideal for validating usernames, product codes, or any identifier that should only contain letters and numbers.

# Check if string contains only letters and numbers
print("Hello123".isalnum())   # True
print("Hello 123".isalnum())  # False (space is not alphanumeric)
print("user_name".isalnum())  # False (underscore is not alphanumeric)
print("Python3".isalnum())    # True - valid username format

isspace() checks if every character in the string is whitespace (spaces, tabs, newlines). It returns True only if the string contains nothing but whitespace characters. This is useful for checking if a string is "blank" (contains only spaces), detecting empty lines in text processing, or validating that input is not just spaces.

# Check if string is all whitespace
print("   ".isspace())        # True (only spaces)
print("\t\n".isspace())       # True (tab and newline are whitespace)
print("  x  ".isspace())      # False (contains letter 'x')
print("".isspace())           # False (empty string returns False)

isupper(), islower(), istitle() check the case formatting of letters in a string. isupper() returns True if all letters are uppercase. islower() returns True if all letters are lowercase. istitle() returns True if the string is in title case (first letter of each word capitalized). These are useful for enforcing formatting rules or validating that input matches expected case patterns.

# Check case formatting
print("HELLO".isupper())      # True (all uppercase)
print("Hello".isupper())      # False (not all uppercase)
print("hello".islower())      # True (all lowercase)
print("Hello".islower())      # False (not all lowercase)
print("Hello World".istitle())# True (title case)
print("Hello world".istitle())# False (second word not capitalized)

user_input = "   jOHN sMITH   "

user_input = "   jOHN sMITH   "
clean_name = user_input.strip().title()
print(clean_name)  # John Smith

sentence = "The quick brown fox jumps over the lazy dog"

sentence = "The quick brown fox jumps over the lazy dog"
words = sentence.lower().split()
count = words.count("the")
print(f"'the' appears {count} times")  # 'the' appears 2 times

header = "name,age,city"
row = "Alice,28,Boston"

header = "name,age,city"
row = "Alice,28,Boston"

keys = header.split(",")
values = row.split(",")

# Method 1: Using dict() and zip()
person = dict(zip(keys, values))

# Method 2: Manual loop
person = {}
for i in range(len(keys)):
    person[keys[i]] = values[i]

print(person)  # {'name': 'Alice', 'age': '28', 'city': 'Boston'}

password = "SecurePass123"

password = "SecurePass123"

has_upper = any(c.isupper() for c in password)
has_lower = any(c.islower() for c in password)
has_digit = any(c.isdigit() for c in password)

if has_upper and has_lower and has_digit:
    print("Strong password")
else:
    print("Weak password")
# Output: Strong password

Imagine you want to display a message like "Hello, Alice! You have 3 new messages." The name "Alice" and the number 3 come from variables, not fixed text. String formatting is the technique of creating strings that mix static text with dynamic values from variables, calculations, or function calls.

F-Strings (Formatted String Literals)

F-strings (formatted string literals) are the modern, recommended way to create strings with embedded values. They are called "f-strings" because you put the letter f before the opening quote. Any expression you place inside curly braces {} will be evaluated and inserted into the string automatically.

Basic f-string usage:

To create an f-string, just put f before your quote marks. Inside the string, wrap any variable name or Python expression in curly braces {}. Python will evaluate what is inside the braces and insert the result into your string.

# Embedding variables
name = "Alice"
age = 25
print(f"Hello, {name}! You are {age} years old.")
# Output: Hello, Alice! You are 25 years old.

# Expressions inside braces
x = 10
y = 5
print(f"{x} + {y} = {x + y}")  # 10 + 5 = 15
print(f"{x} * {y} = {x * y}")  # 10 * 5 = 50

Calling methods inside f-strings:

Since f-strings evaluate Python expressions, you can call methods directly inside the curly braces. This is powerful because you can transform data right as you insert it into the string, without needing separate variables. You can call string methods, use built-in functions like len(), or any expression.

# Methods can be called directly
name = "alice"
print(f"Hello, {name.title()}!")  # Hello, Alice!

# String methods
text = "python"
print(f"Uppercase: {text.upper()}")  # Uppercase: PYTHON

# List methods
items = ["apple", "banana", "cherry"]
print(f"Total items: {len(items)}")  # Total items: 3

Number Formatting

When displaying numbers, you often need precise control over their appearance. F-strings support format specifiers that let you control decimal places, add thousand separators, display percentages, and more. The syntax is {value:format_spec} where the colon separates the value from formatting instructions.

Decimal places and padding:

Use .Nf to show exactly N decimal places (the "f" stands for fixed-point notation). Use a number to specify minimum width, and add a leading zero to pad with zeros. For example, :05 means "at least 5 characters, padded with zeros on the left."

# Fixed decimal places
pi = 3.14159265359
print(f"Pi: {pi:.2f}")     # Pi: 3.14 (2 decimal places)
print(f"Pi: {pi:.4f}")     # Pi: 3.1416 (4 decimal places)

# Minimum width with padding
num = 42
print(f"Number: {num:5}")  # Number:    42 (5 chars wide, right-aligned)
print(f"Number: {num:05}") # Number: 00042 (5 chars, zero-padded)

Thousands separator and percentage:

Use a comma , to add thousand separators for readability. Use .N% to display a decimal as a percentage with N decimal places (Python automatically multiplies by 100 and adds the % sign). You can combine these with decimal place formatting for professional-looking financial data.

# Thousands separator with comma
population = 1234567890
print(f"Population: {population:,}")  # Population: 1,234,567,890

# Combine with decimal places
revenue = 1234567.89
print(f"Revenue: ${revenue:,.2f}")    # Revenue: $1,234,567.89

# Percentage formatting
ratio = 0.856
print(f"Success rate: {ratio:.1%}")   # Success rate: 85.6%
print(f"Success rate: {ratio:.0%}")   # Success rate: 86%

Alignment and Padding

Format specifiers let you align text within a fixed-width space and add padding characters. This is extremely useful for creating neatly formatted tables, reports, receipts, and aligned columns of data. When you specify a width, Python reserves that many character spaces and positions your text within them.

Left alignment using < positions your text at the left side of the reserved space, with padding added on the right. This is the default alignment for strings. When you write {name:<10}, you are saying: "Reserve 10 character spaces and put the text on the left, filling the remaining space with blanks." Left alignment is commonly used for names, descriptions, and text columns in tables.

# Left alignment with <
name = "Alice"
print(f"|{name:<10}|")  # |Alice     | (left-aligned, 5 spaces on right)
print(f"|{name:<15}|")  # |Alice          | (left-aligned, 10 spaces on right)

# Practical: Align product names in a list
products = ["Laptop", "Mouse", "Keyboard"]
for product in products:
    print(f"{product:<12} - In Stock")

Right alignment using > positions your text at the right side of the reserved space, with padding added on the left. This is the default alignment for numbers. When you write {value:>10}, you are saying: "Reserve 10 character spaces and put the text on the right, filling the left side with blanks." Right alignment is perfect for numbers, prices, and quantities so decimal points line up in columns.

# Right alignment with >
name = "Alice"
print(f"|{name:>10}|")  # |     Alice| (right-aligned, 5 spaces on left)

# Practical: Align prices so decimals line up
prices = [999.99, 29.99, 1234.50]
for price in prices:
    print(f"${price:>10.2f}")

Center alignment using ^ positions your text in the middle of the reserved space, with padding distributed equally on both sides. When you write {title:^20}, Python centers your text within 20 characters. If the padding cannot be split evenly, the extra space goes on the right. Center alignment is great for titles, headers, and creating visually balanced output.

# Center alignment with ^
name = "Alice"
print(f"|{name:^10}|")  # |  Alice   | (centered, 2 spaces left, 3 right)

# Practical: Create a centered header
title = "Sales Report"
print(f"{title:^30}")   #          Sales Report         
print("=" * 30)

Custom fill characters let you replace the default space padding with any character you choose. Place your fill character immediately before the alignment symbol. For example, {name:*^10} centers the text and fills with asterisks, while {name:-<10} left-aligns and fills with dashes. This is useful for creating visual separators, decorative borders, or emphasizing text.

# Custom fill characters
name = "Alice"
print(f"|{name:*^10}|")  # |**Alice***| (centered with asterisks)
print(f"|{name:-<10}|")  # |Alice-----| (left-aligned with dashes)
print(f"|{name:.>10}|")  # |.....Alice| (right-aligned with dots)

# Practical: Create a decorative header
title = " MENU "
print(f"{title:=^30}")   # ============ MENU ============

Building formatted tables combines all these alignment techniques to create professional-looking output. By using consistent widths and appropriate alignment (left for text, right for numbers), you can create tables that are easy to read. This is invaluable for reports, receipts, invoices, and any data presentation.

# Practical example: formatted product table
products = [("Laptop", 999.99), ("Mouse", 29.99), ("Keyboard", 79.99)]

# Print header
print(f"{'Product':<15} {'Price':>10}")
print("-" * 26)

# Print each row with proper alignment
for product, price in products:
    print(f"{product:<15} ${price:>9.2f}")

# Output:
# Product              Price
# --------------------------
# Laptop            $  999.99
# Mouse             $   29.99
# Keyboard          $   79.99

The format() Method

Before f-strings (Python 3.6), the format() method was the standard way to format strings. You will still encounter it in older code and documentation. It works by placing empty {} or named placeholders in the string, then calling .format() with the values to insert.

Basic positional placeholders use empty curly braces {} that get filled in order with the arguments you pass to .format(). The first {} gets the first argument, the second {} gets the second argument, and so on. This is the simplest form of the format method and works well when you have just a few values to insert.

# Basic format() with positional placeholders
name = "Alice"
age = 25
print("Hello, {}! You are {} years old.".format(name, age))
# Output: Hello, Alice! You are 25 years old.

# The first {} gets 'name', the second {} gets 'age'
print("My name is {} and I love {}.".format("Bob", "Python"))
# Output: My name is Bob and I love Python.

Named placeholders use descriptive names inside the curly braces like {name} and {age}. You then pass the values as keyword arguments to .format(). This makes your code more readable and self-documenting, especially when you have many placeholders. The order of arguments does not matter since they are matched by name.

# Named placeholders for clarity
print("Hello, {name}! You are {age} years old.".format(name="Bob", age=30))
# Output: Hello, Bob! You are 30 years old.

# Order of arguments doesn't matter with named placeholders
print("Welcome to {city}, {name}!".format(name="Alice", city="Paris"))
# Output: Welcome to Paris, Alice!

Indexed placeholders use numbers inside the curly braces like {0}, {1}, {2} to refer to specific arguments by their position. This is useful when you need to use the same value multiple times in a string, or when you want to reorder how values appear. Index 0 is the first argument, index 1 is the second, and so on.

# Indexed placeholders - refer to arguments by position
print("{0} vs {1}: {0} wins!".format("Python", "Java"))
# Output: Python vs Java: Python wins!

# Reuse the same value multiple times
print("{0}, {0}, {0}! Go {0}!".format("Team"))
# Output: Team, Team, Team! Go Team!

# Mix different indices
print("First: {0}, Second: {1}, First again: {0}".format("Apple", "Banana"))
# Output: First: Apple, Second: Banana, First again: Apple

String Concatenation vs Formatting

Beginners often build strings by joining pieces with the + operator (concatenation). While this works, it quickly becomes messy with multiple variables and requires converting non-strings manually with str(). F-strings handle type conversion automatically and are much more readable.

The concatenation approach uses the + operator to join string pieces together. Every piece must be a string, so you must wrap numbers and other types with str() to convert them. With many variables, this creates a long chain of + signs and quotes that is hard to read and easy to make mistakes with (forgetting spaces, missing quotes, etc.).

# Concatenation - joining strings with +
name = "Alice"
age = 25
city = "New York"

# Must convert age to string with str()
message = "Hello, " + name + "! You are " + str(age) + " years old from " + city + "."
print(message)
# Output: Hello, Alice! You are 25 years old from New York.

# Easy to forget spaces or make mistakes
wrong = "Hello," + name  # Missing space after comma!
print(wrong)  # Hello,Alice

The f-string approach is cleaner, more readable, and automatically converts any type to string. You write your message as a natural sentence with variables embedded directly where they belong. No manual type conversion, no chains of + signs, and you can see exactly what the final string will look like. This is why f-strings are the recommended approach for modern Python code.

# F-string - much cleaner and more readable!
name = "Alice"
age = 25
city = "New York"

# No str() needed, variables go right where they belong
message = f"Hello, {name}! You are {age} years old from {city}."
print(message)
# Output: Hello, Alice! You are 25 years old from New York.

# Can even do calculations inline
price = 19.99
quantity = 3
print(f"Total: ${price * quantity:.2f}")  # Total: $59.97

price = 1234.5

price = 1234.5
print(f"${price:,.2f}")  # $1,234.50

title = "SALES REPORT"
print(f"{title:=^40}")
# ===========SALES REPORT============

products = [
    ("Laptop", 5, 999.99),
    ("Mouse", 25, 29.99),
    ("Keyboard", 15, 79.99)
]

products = [
    ("Laptop", 5, 999.99),
    ("Mouse", 25, 29.99),
    ("Keyboard", 15, 79.99)
]

# Header
print(f"{'Product':<15} {'Qty':>5} {'Price':>10} {'Total':>12}")
print("-" * 44)

# Data rows
for name, qty, price in products:
    total = qty * price
    print(f"{name:<15} {qty:>5} ${price:>9.2f} ${total:>11.2f}")

# Output:
# Product           Qty      Price        Total
# --------------------------------------------
# Laptop              5    $999.99    $4,999.95
# Mouse              25     $29.99      $749.75
# Keyboard           15     $79.99    $1,199.85

completed = 75
total = 100

Progress: 75.0%
[===============-----]

completed = 75
total = 100
percentage = completed / total

print(f"Progress: {percentage:.1%}")

# Progress bar
bar_width = 20
filled = int(bar_width * percentage)
empty = bar_width - filled
print(f"[{'=' * filled}{'-' * empty}]")

# Output:
# Progress: 75.0%
# [===============-----]

Experiment with string slicing in real-time! Enter a string and adjust the slice parameters to see exactly how Python's slicing syntax works.