Python Strings: Mastering Text Manipulation

Creating Strings

# Single quotes
name = 'Python'

# Double quotes
greeting = "Hello, World!"

# Triple quotes for multiline
description = '''Python is a high-level,
interpreted programming language that
supports multiple paradigms.'''

Measuring String Length

empty = ""
print(len(empty))                  # Output: 0

name = "Python"
print(len(name))                   # Output: 6

sentence = "Hello, World!"
print(len(sentence))               # Output: 13

book_excerpt = """It was the best of times,
it was the worst of times."""
print(len(book_excerpt))           # Output: 44 (includes newline character)

Positive Indexing (Left to Right)

language = "Python"
print(language[0])    # Output: 'P'
print(language[1])    # Output: 'y'
print(language[5])    # Output: 'n'

# Trying to access out of range:
# print(language[6])  # IndexError: string index out of range

Negative Indexing (Right to Left)

language = "Python"
print(language[-1])   # Output: 'n' (last character)
print(language[-2])   # Output: 'o' (second-to-last)
print(language[-6])   # Output: 'P' (first character)

Practical Example: File Extension Checker

def is_python_file(filename):
    if len(filename) < 3:
        return False
    
    # Check if the file ends with .py
    return filename[-3:] == ".py"

# Test cases
print(is_python_file("script.py"))    # Output: True
print(is_python_file("document.txt")) # Output: False
print(is_python_file("app.py.bak"))   # Output: False

Basic Slicing

text = "Python Programming"

# Extract "Python"
print(text[0:6])      # Output: 'Python'
# Shorthand for starting at index 0
print(text[:6])       # Output: 'Python'

# Extract "Programming"
print(text[7:])       # Output: 'Programming'

# Extract middle characters
print(text[3:10])     # Output: 'hon Pro'

Slicing with Step

text = "Python Programming"

# Every other character
print(text[::2])      # Output: 'Pto rgamn'

# Reverse the string
print(text[::-1])     # Output: 'gnimmargorP nohtyP'

# Every third character starting from index 1
print(text[1::3])     # Output: 'yhPr'

Practical Example: Text Truncation

def truncate_text(text, max_length=50):
    """Truncate text to max_length and add ellipsis if needed."""
    if len(text) <= max_length:
        return text
    
    # Truncate at max_length - 3 to make room for ellipsis
    truncated = text[:max_length-3] + "..."
    return truncated

article_title = "Understanding Python String Manipulation: A Comprehensive Guide for Beginners and Advanced Programmers"
print(truncate_text(article_title))
# Output: "Understanding Python String Manipulation: A Compr..."

Creating Multiline Strings

# With triple double quotes
documentation = """
Function: calculate_total
Parameters:
    - price: float
    - quantity: int
    - discount: float (optional)
Returns:
    - total_cost: float
"""

# With triple single quotes
poem = '''
Roses are red,
Violets are blue,
Python is awesome,
And so are you!
'''

print(documentation)
print(poem)

Practical Example: HTML Template

def generate_html_card(title, content, author):
    """Generate an HTML card with the provided content."""
    html_template = f'''
<div class="card">
    <div class="card-header">
        <h2>{title}</h2>
    </div>
    <div class="card-body">
        <p>{content}</p>
    </div>
    <div class="card-footer">
        <span class="author">By: {author}</span>
    </div>
</div>
'''
    return html_template

card = generate_html_card(
    "Python Strings",
    "Learn how to manipulate text in Python.",
    "Jane Developer"
)
print(card)

Basic Concatenation with +

first_name = "John"
last_name = "Doe"

# Using + operator
full_name = first_name + " " + last_name
print(full_name)  # Output: "John Doe"

# String repetition with *
divider = "-" * 20
print(divider)  # Output: "--------------------"

String Formatting Methods

# Method 1: %-formatting (older style)
print("Hello, %s. You are %d years old." % ("Alice", 30))

# Method 2: str.format() method
print("Hello, {}. You are {} years old.".format("Bob", 25))
print("Hello, {name}. You are {age} years old.".format(name="Charlie", age=35))

# Method 3: f-strings (Python 3.6+, recommended)
name = "David"
age = 40
print(f"Hello, {name}. You are {age} years old.")

# Including expressions in f-strings
print(f"The area of a 5x10 rectangle is {5 * 10} square units.")

Practical Example: Email Template Generator

def generate_email(recipient_name, appointment_date, appointment_time):
    """Generate personalized appointment reminder email."""
    email_template = f'''
Subject: Your Upcoming Appointment Reminder

Dear {recipient_name},

This is a friendly reminder that you have an appointment scheduled for:
Date: {appointment_date}
Time: {appointment_time}

Please arrive 15 minutes before your scheduled time. If you need to 
reschedule, please contact us at least 24 hours in advance.

Thank you,
Medical Office Staff
'''
    return email_template

# Generate personalized email
email = generate_email("Sarah Johnson", "May 15, 2025", "2:30 PM")
print(email)

Case Manipulation

text = "Python Programming"

print(text.upper())          # Output: "PYTHON PROGRAMMING"
print(text.lower())          # Output: "python programming"
print(text.title())          # Output: "Python Programming"
print(text.capitalize())     # Output: "Python programming"
print(text.swapcase())       # Output: "pYTHON pROGRAMMING"

Search and Replace

text = "Python is amazing and Python is fun"

# Finding substrings
print(text.find("Python"))    # Output: 0 (first occurrence)
print(text.find("Python", 1)) # Output: 20 (occurrence after index 1)
print(text.find("Java"))      # Output: -1 (not found)

# Counting occurrences
print(text.count("Python"))   # Output: 2

# Replacing substrings
print(text.replace("Python", "JavaScript"))
# Output: "JavaScript is amazing and JavaScript is fun"

# Replace with limit
print(text.replace("Python", "JavaScript", 1))
# Output: "JavaScript is amazing and Python is fun"

Checking String Properties

print("abc123".isalnum())      # Output: True (alphanumeric)
print("abc".isalpha())        # Output: True (alphabetic)
print("123".isdigit())        # Output: True (digits)
print("UPPER".isupper())      # Output: True (all uppercase)
print("lower".islower())      # Output: True (all lowercase)
print("  \t\n".isspace())     # Output: True (whitespace)
print("Title Case".istitle()) # Output: True (title case)

Whitespace Manipulation

# Remove leading/trailing whitespace
print("  Python  ".strip())      # Output: "Python"
print("  Python  ".lstrip())     # Output: "Python  "
print("  Python  ".rstrip())     # Output: "  Python"

# Center, left-align, right-align text
print("Python".center(20, '-'))  # Output: "-------Python-------"
print("Python".ljust(20, '-'))   # Output: "Python--------------"
print("Python".rjust(20, '-'))   # Output: "--------------Python"

Splitting and Joining

# Split string to list
sentence = "Python is a great programming language"
words = sentence.split()
print(words)  # Output: ['Python', 'is', 'a', 'great', 'programming', 'language']

csv_data = "apple,banana,cherry,date"
fruits = csv_data.split(",")
print(fruits)  # Output: ['apple', 'banana', 'cherry', 'date']

# Join list to string
print("-".join(words))  # Output: "Python-is-a-great-programming-language"
print(", ".join(fruits))  # Output: "apple, banana, cherry, date"

Practical Example: Simple CSV Parser

def parse_csv_line(line):
    """Parse a CSV line into a list of values."""
    return line.strip().split(',')

def format_as_table_row(values):
    """Format a list of values as an HTML table row."""
    cells = [f"<td>{value.strip()}</td>" for value in values]
    return f"<tr>{''.join(cells)}</tr>"

# Sample CSV data
csv_data = '''
Name,Age,Occupation
John Doe,32,Developer
Jane Smith,28,Designer
Mike Johnson,41,Manager
'''

# Process the CSV data
html_rows = []
for line in csv_data.strip().split('\n'):
    if line:  # Skip empty lines
        values = parse_csv_line(line)
        html_row = format_as_table_row(values)
        html_rows.append(html_row)

# Create an HTML table
html_table = f'''
<table>
    {''.join(html_rows)}
</table>
'''

print(html_table)

Basic f-string Usage

name = "Alice"
age = 30
height = 1.75

# Basic variable insertion
greeting = f"Hello, {name}!"
print(greeting)  # Output: "Hello, Alice!"

# Expressions in f-strings
print(f"{name} is {age} years old and {height * 100} cm tall.")
# Output: "Alice is 30 years old and 175.0 cm tall."

Formatting Options in f-strings

# Number formatting
pi = 3.14159265359
print(f"Pi is approximately {pi:.2f}")  # Output: "Pi is approximately 3.14"

# Width and alignment
for i in range(1, 6):
    print(f"Square of {i:2d} is {i*i:3d}")
# Output:
# Square of  1 is   1
# Square of  2 is   4
# Square of  3 is   9
# Square of  4 is  16
# Square of  5 is  25

# Using thousands separator
amount = 1234567.89
print(f"Amount: ${amount:,.2f}")  # Output: "Amount: $1,234,567.89"

# Percentage formatting
ratio = 0.8543
print(f"Completion: {ratio:.1%}")  # Output: "Completion: 85.4%"

# Hex, binary, octal representation
value = 42
print(f"Decimal: {value}, Hex: {value:x}, Binary: {value:b}")
# Output: "Decimal: 42, Hex: 2a, Binary: 101010"

Advanced f-string Features

# Date formatting
import datetime
today = datetime.datetime.now()
print(f"Today is {today:%B %d, %Y}")  # e.g., "Today is May 13, 2025"

# Using dictionaries with f-strings
user = {"name": "Bob", "role": "Developer", "level": 3}
print(f"{user['name']} is a level {user['level']} {user['role']}")
# Output: "Bob is a level 3 Developer"

# Self-documentation using the = operator (Python 3.8+)
x = 10
y = 20
print(f"{x=}, {y=}, {x+y=}")
# Output: "x=10, y=20, x+y=30"

Practical Example: Financial Report Generator

def generate_financial_report(name, transactions):
    """Generate a financial report for a customer."""
    total = sum(amount for _, amount in transactions)
    
    report = f'''
FINANCIAL SUMMARY FOR: {name.upper()}
{'-' * 40}
{"DATE":10} | {"DESCRIPTION":20} | {"AMOUNT":>10}
{'-' * 40}
'''
    
    for date, amount in transactions:
        status = "CREDIT" if amount >= 0 else "DEBIT"
        report += f"{date:10} | {status:20} | {amount:>10,.2f}\n"
    
    report += f"{'-' * 40}\n"
    report += f"{'TOTAL':31} | {total:>10,.2f}\n"
    
    return report

# Sample data
customer = "John Smith"
transactions = [
    ("2025-04-01", 1250.50),
    ("2025-04-15", -340.25),
    ("2025-04-22", 800.00),
    ("2025-04-29", -120.75)
]

print(generate_financial_report(customer, transactions))

Common Escape Sequences

# Newline
print("First line\nSecond line")
# Output:
# First line
# Second line

# Tab
print("Name:\tJohn")  # Output: "Name:   John"

# Backslash
print("Path: C:\\Users\\John")  # Output: "Path: C:\Users\John"

# Quotes inside strings
print("He said, \"Hello!\"")  # Output: 'He said, "Hello!"'
print('It\'s a great day')   # Output: "It's a great day"

# Unicode characters
print("\u03C0")  # Output: "π" (Greek letter pi)
print("\U0001F600")  # Output: "😀" (Grinning Face emoji)

Raw Strings

Raw strings (prefixed with r) ignore escape sequences, useful for regular expressions and file paths:

# Regular string with escape sequences
print("C:\\Users\\John\\Documents")  # Output: "C:\Users\John\Documents"

# Raw string ignores escape sequences
print(r"C:\Users\John\Documents")    # Output: "C:\Users\John\Documents"

# Useful for regular expressions
import re
pattern = r"\b\w+\b"  # Word boundary pattern, \b doesn't become a backspace
matches = re.findall(pattern, "Hello, world!")

Practical Example: CSV Generator

def escape_csv_field(field):
    """
    Escape a field for inclusion in a CSV file:
    - Enclose in quotes if it contains commas, quotes, or newlines
    - Double any existing quotes
    """
    if isinstance(field, (int, float)):
        return str(field)
    
    needs_quoting = "," in field or '"' in field or "\n" in field
    
    if needs_quoting:
        # Double any existing quotes
        field = field.replace('"', '""')
        # Enclose in quotes
        return f'"{field}"'
    else:
        return field

def generate_csv_row(fields):
    """Generate a CSV row from a list of fields."""
    escaped_fields = [escape_csv_field(field) for field in fields]
    return ",".join(escaped_fields)

# Example usage
row1 = ["Product Name", "Price", "Description"]
row2 = ["Widget X", 19.99, "A \"premium\" widget\nwith multi-line description"]

print(generate_csv_row(row1))
print(generate_csv_row(row2))

Example 1: Username Validator

def validate_username(username):
    """
    Validate a username according to these rules:
    - 3-20 characters long
    - Only letters, numbers, and underscores
    - Must start with a letter
    - Case insensitive (convert to lowercase)
    """
    # Remove leading/trailing whitespace and convert to lowercase
    username = username.strip().lower()
    
    # Check length
    if len(username) < 3 or len(username) > 20:
        return False, "Username must be 3-20 characters long"
    
    # Check if starts with a letter
    if not username[0].isalpha():
        return False, "Username must start with a letter"
    
    # Check if contains only allowed characters
    for char in username:
        if not (char.isalnum() or char == '_'):
            return False, "Username can only contain letters, numbers, and underscores"
    
    return True, username

# Test cases
test_usernames = [
    "john_doe",
    "user123",
    "a",                    # Too short
    "1user",                # Doesn't start with letter
    "user@name",            # Contains special character
    "really_long_username123"  # Too long
]

for username in test_usernames:
    valid, message = validate_username(username)
    if valid:
        print(f"'{username}' is valid. Normalized: '{message}'")
    else:
        print(f"'{username}' is invalid: {message}")

Example 2: Simple Text Analysis

def analyze_text(text):
    """Perform basic text analysis on a given string."""
    # Normalize text: remove extra whitespace and convert to lowercase
    text = ' '.join(text.split()).lower()
    
    # Character count (excluding spaces)
    char_count = len(text.replace(" ", ""))
    
    # Word count
    words = text.split()
    word_count = len(words)
    
    # Average word length
    avg_word_length = char_count / word_count if word_count > 0 else 0
    
    # Count unique words
    unique_words = len(set(words))
    
    # Find most common word
    word_freq = {}
    for word in words:
        # Remove punctuation from word
        clean_word = ''.join(c for c in word if c.isalnum())
        if clean_word:
            word_freq[clean_word] = word_freq.get(clean_word, 0) + 1
    
    most_common_word = max(word_freq.items(), key=lambda x: x[1]) if word_freq else ("", 0)
    
    return {
        "character_count": char_count,
        "word_count": word_count,
        "average_word_length": round(avg_word_length, 2),
        "unique_word_count": unique_words,
        "most_common_word": most_common_word[0],
        "most_common_word_frequency": most_common_word[1]
    }

# Example usage
sample_text = """
Python is a programming language that lets you work quickly and integrate systems more effectively.
Python is powerful, and fast; plays well with others; runs everywhere; is friendly & easy to learn.
"""

analysis = analyze_text(sample_text)
for key, value in analysis.items():
    print(f"{key.replace('_', ' ').title()}: {value}")

Example 3: Simple URL Parser

def parse_url(url):
    """
    Parse a URL into its components:
    - scheme (http, https)
    - domain
    - path
    - query parameters
    - fragment
    """
    result = {
        "scheme": "",
        "domain": "",
        "path": "",
        "query_params": {},
        "fragment": ""
    }
    
    # Extract scheme
    if "://" in url:
        result["scheme"], url = url.split("://", 1)
    
    # Extract fragment (part after #)
    if "#" in url:
        url, result["fragment"] = url.split("#", 1)
    
    # Extract query parameters
    if "?" in url:
        url, query_string = url.split("?", 1)
        # Parse query parameters
        query_parts = query_string.split("&")
        for part in query_parts:
            if "=" in part:
                key, value = part.split("=", 1)
                result["query_params"][key] = value
            else:
                result["query_params"][part] = ""
    
    # Extract domain and path
    if "/" in url:
        result["domain"], result["path"] = url.split("/", 1)
        result["path"] = "/" + result["path"]
    else:
        result["domain"] = url
    
    return result

# Example usage
test_urls = [
    "https://example.com",
    "https://api.example.com/v2/users",
    "http://example.com/search?q=python&limit=10",
    "https://docs.python.org/3/library/stdtypes.html#string-methods"
]

for url in test_urls:
    parts = parse_url(url)
    print(f"\nURL: {url}")
    for key, value in parts.items():
        print(f"{key.title()}: {value}")

Basic Regular Expression Usage

import re

text = "Contact us at info@example.com or support@company.org"

# Find all email addresses
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
emails = re.findall(email_pattern, text)
print(emails)  # Output: ['info@example.com', 'support@company.org']

# Check if string matches a pattern
date_text = "2025-05-13"
is_date = re.match(r'^\d{4}-\d{2}-\d{2}$', date_text)
print(bool(is_date))  # Output: True

# Replace based on pattern
censored = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', 
                 '[EMAIL REDACTED]', 
                 text)
print(censored)  # Output: "Contact us at [EMAIL REDACTED] or [EMAIL REDACTED]"

Common Regular Expression Patterns

import re

patterns = {
    "phone_number": r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
    "us_zipcode": r'\b\d{5}(?:-\d{4})?\b',
    "ip_address": r'\b(?:\d{1,3}\.){3}\d{1,3}\b',
    "html_tag": r'<[^>]+>',
    "url": r'https?://[^\s]+'
}

test_strings = {
    "phone_number": "Contact us at 555-123-4567 or 555.123.4567",
    "us_zipcode": "Ship to 90210 or 20500-0003",
    "ip_address": "Server IP: 192.168.1.1",
    "html_tag": "
Text
",
    "url": "Visit https://python.org for more information"
}

for name, pattern in patterns.items():
    matches = re.findall(pattern, test_strings[name])
    print(f"{name}: {matches}")

Practical Example: Log File Parser

import re

def parse_log_line(line):
    """Parse a log line with format: [YYYY-MM-DD HH:MM:SS] [LEVEL] Message"""
    # Regular expression pattern to match log line components
    pattern = r'\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[([A-Z]+)\] (.+)'
    
    match = re.match(pattern, line)
    if not match:
        return None
    
    timestamp, level, message = match.groups()
    return {
        "timestamp": timestamp,
        "level": level,
        "message": message
    }

# Sample log data
log_data = """
[2025-05-13 10:23:45] [INFO] Application started
[2025-05-13 10:23:47] [DEBUG] Connection pool initialized
[2025-05-13 10:24:01] [WARNING] Low memory detected
[2025-05-13 10:24:30] [ERROR] Database connection failed: timeout
Invalid log line
[2025-05-13 10:25:15] [INFO] Retry attempt 1
"""

# Parse each line
for line in log_data.strip().split('\n'):
    parsed = parse_log_line(line)
    if parsed:
        print(f"[{parsed['level']}] at {parsed['timestamp']}: {parsed['message']}")
    else:
        print(f"Could not parse: '{line}'")