← Python

Strings & String Methods

← Strings & String Methods

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

How are strings created in Python and what are the different string literal types?

Python provides several ways to create strings:

Single quotes: 'hello'
Double quotes: "hello" (functionally identical to single quotes)
Triple quotes: '''multi-line''' or """multi-line""" for multi-line strings and docstrings
Raw strings: r'no\escape' -- backslashes treated literally
F-strings: f'Hello, {name}' -- inline expressions (Python 3.6+)
Byte strings: b'bytes' -- bytes, not text
str() constructor: str(42) converts other types to string

Strings are immutable sequences of Unicode characters. You cannot modify a string in-place; all string methods return new strings.

Pseudo Code

Single: 'hello'
Double: "hello"
Triple: '''multi-line''' or """multi-line"""
Raw: r'C:\path\to\file' (no escape processing)
F-string: f'Hello, {name}' (expression interpolation)
Bytes: b'hello' (bytes, not str)
Constructor: str(42) -> '42'

Code

# Single and double quotes are identical
s1 = 'hello'
s2 = "hello"
print(s1 == s2)  # True

# Use one to contain the other
print("it's easy")        # it's easy
print('He said "hi"')     # He said "hi"

# Triple-quoted strings for multi-line
message = """This is
a multi-line
string."""
print(message)

# Raw strings -- backslashes are literal
path = r'C:\Users\alice\documents'
print(path)  # C:\Users\alice\documents

# Without raw: need to escape
path2 = 'C:\\Users\\alice\\documents'
print(path == path2)  # True

# F-strings (Python 3.6+)
name = "Alice"
age = 30
print(f"Hello, {name}! You are {age} years old.")
print(f"Next year: {age + 1}")           # expressions
print(f"Name: {name!r}")                 # repr: 'Alice'
print(f"Pi: {3.14159:.2f}")              # formatting: 3.14
print(f"{'hello':>20}")                  # right-align in 20 chars

# String constructor
print(str(42))       # '42'
print(str(3.14))     # '3.14'
print(str([1, 2]))   # '[1, 2]'
print(str(True))     # 'True'

# Byte strings
b = b"hello"
print(type(b))       # <class 'bytes'>
print(b.decode('utf-8'))  # 'hello' (bytes -> str)

# String immutability
s = "hello"
try:
    s[0] = "H"
except TypeError as e:
    print(f"Error: {e}")  # 'str' object does not support item assignment

# Create modified string instead
s = "H" + s[1:]
print(s)  # Hello

True
it's easy
He said "hi"
This is
a multi-line
string.
C:\Users\alice\documents
True
Hello, Alice! You are 30 years old.
Next year: 31
Name: 'Alice'
Pi: 3.14
hello
42
3.14
[1, 2]
True
<class 'bytes'>
hello
Error: 'str' object does not support item assignment
Hello

Key Points

•Single and double quotes are identical in Python
•Triple quotes for multi-line strings and docstrings
•Raw strings (r'...') treat backslashes as literal characters
•F-strings allow inline expressions with formatting
•Strings are immutable -- all methods return new strings

Gotchas

•Raw strings cannot end with an odd number of backslashes: r'path\' is a SyntaxError
•b'hello' is bytes, not str -- they are different types
•Triple-quoted strings include leading newlines and indentation
•f'{value}' calls str() on the value, f'{value!r}' calls repr()

Strings: single/double quotes (identical), triple quotes (multi-line), raw strings (r'...'), f-strings (f'...'), bytes (b'...'). Strings are immutable Unicode sequences.

•Single and double quotes are identical
•Strings are immutable

s = 'hello'           # or "hello"
multi = """line 1
line 2"""
raw = r'C:\path'      # no escape
f = f'Hello, {name}'  # interpolation
b = b'bytes'           # bytes, not str

Raw strings cannot end with an odd number of backslashes

Question 2 / 15

How do f-strings work and what formatting options do they support?

F-strings (formatted string literals), introduced in Python 3.6, allow you to embed expressions inside string literals using {expression} syntax.

Syntax: f"text {expression} text"

Features:

Any valid Python expression inside {}
Format specifiers with : -- {value:.2f}
Conversion flags: !s (str), !r (repr), !a (ascii)
Nested f-strings (Python 3.12+: any quotes inside)
Self-documenting expressions with = (Python 3.8+): f'{x=}'

Format spec mini-language: {value:[[fill]align][sign][#][0][width][grouping][.precision][type]}

Common format types: d (integer), f (float), e (scientific), % (percentage), s (string), b (binary), x (hex), o (octal).

Pseudo Code

f'{expr}'         -- basic interpolation
f'{expr:.2f}'     -- 2 decimal places
f'{expr:>10}'     -- right-align in 10 chars
f'{expr:010d}'    -- zero-padded integer
f'{expr:,}'       -- thousands separator
f'{expr=}'        -- self-documenting (3.8+)
f'{expr!r}'       -- repr() of expression

Code

name = "Alice"
age = 30
pi = 3.14159265

# Basic interpolation
print(f"Hello, {name}!")           # Hello, Alice!
print(f"Age: {age}, Next: {age+1}")  # Age: 30, Next: 31

# Number formatting
print(f"Pi: {pi:.2f}")             # Pi: 3.14
print(f"Pi: {pi:.4f}")             # Pi: 3.1416
print(f"Integer: {42:05d}")         # Integer: 00042
print(f"Hex: {255:x}")             # Hex: ff
print(f"Hex: {255:#x}")            # Hex: 0xff
print(f"Binary: {10:b}")           # Binary: 1010
print(f"Binary: {10:#010b}")       # Binary: 0b00001010
print(f"Octal: {8:o}")             # Octal: 10
print(f"Scientific: {1234.5:e}")   # Scientific: 1.2345e+03
print(f"Percentage: {0.85:.1%}")   # Percentage: 85.0%

# Thousands separator
big_number = 1234567890
print(f"{big_number:,}")           # 1,234,567,890
print(f"{big_number:_}")           # 1_234_567_890

# Alignment and padding
print(f"{'left':<20}|")     # left                |
print(f"{'right':>20}|")    #                right|
print(f"{'center':^20}|")   #       center       |
print(f"{'padded':*^20}")   # *******padded*******

# Conversion flags
print(f"str: {name!s}")    # str: Alice
print(f"repr: {name!r}")   # repr: 'Alice'

# Self-documenting expressions (Python 3.8+)
x = 42
y = 3.14
print(f"{x=}")              # x=42
print(f"{x=}, {y=:.1f}")   # x=42, y=3.1
print(f"{x + y = }")       # x + y = 45.14

# Conditional in f-string
count = 5
print(f"{count} item{'s' if count != 1 else ''}")  # 5 items

# Dictionary access in f-string
user = {"name": "Alice"}
print(f"Name: {user['name']}")  # Name: Alice

# Calling methods
print(f"Upper: {name.upper()}")        # Upper: ALICE
print(f"Length: {len(name)}")           # Length: 5

# Date formatting
from datetime import datetime
now = datetime.now()
print(f"{now:%Y-%m-%d %H:%M}")  # e.g., 2026-03-16 14:30

Hello, Alice!
Age: 30, Next: 31
Pi: 3.14
Pi: 3.1416
Integer: 00042
Hex: ff
Hex: 0xff
Binary: 1010
Binary: 0b00001010
Octal: 10
Scientific: 1.234500e+03
Percentage: 85.0%
1,234,567,890
1_234_567_890
left                |
right|
center       |
*******padded*******
str: Alice
repr: 'Alice'
x=42
x=42, y=3.1
x + y = 45.14
5 items
Name: Alice
Upper: ALICE
Length: 5
2026-03-18 11:27

Key Points

•Any Python expression can go inside {}
•Format specifiers after : for alignment, width, precision
•!r for repr, !s for str, !a for ascii
•f'{x=}' for self-documenting debug output (Python 3.8+)
•Supports date formatting with strftime codes

Gotchas

•Backslashes are not allowed inside f-string expressions before Python 3.12
•Use different quotes inside {} than the f-string delimiter
•f-strings are evaluated at runtime, not compile time
•Empty braces f'{}' are a SyntaxError -- must contain an expression

F-strings (f'...') embed expressions with {expr}. Support formatting ({x:.2f}), alignment ({x:>10}), conversion ({x!r}), and self-documenting ({x=} in 3.8+).

•Any expression inside {}
•Format spec after : for precision, alignment

name = "Alice"
print(f"Hello, {name}!")       # Hello, Alice!
print(f"{3.14159:.2f}")        # 3.14
print(f"{42:05d}")             # 00042
print(f"{'center':^20}")       #       center
x = 42
print(f"{x=}")                 # x=42

Hello, Alice!
3.14
00042
center
x=42

No backslashes in expressions before Python 3.12

Question 3 / 15

How does string slicing work in Python?

String slicing extracts a substring using the syntax s[start:stop:step].

Index rules:

Positive indices count from the left (0-based)
Negative indices count from the right (-1 is last character)
start is inclusive, stop is exclusive
Omitted start defaults to 0, omitted stop defaults to len(s)
Omitted step defaults to 1

Slicing NEVER raises IndexError -- it silently returns what it can. Out-of-range indices are clamped.

Common patterns:

s[:n] -- first n characters
s[n:] -- everything from index n
s[-n:] -- last n characters
s[:-n] -- everything except last n
s[::-1] -- reverse the string
s[::2] -- every other character

Pseudo Code

s[start:stop:step]
  start: inclusive (default 0)
  stop: exclusive (default len(s))
  step: stride (default 1)

s[:n]   first n chars
s[n:]   from index n to end
s[-n:]  last n chars
s[::-1] reverse

Code

s = "Hello, World!"

# Single character access
print(s[0])    # H
print(s[-1])   # !
print(s[7])    # W

# Basic slicing
print(s[0:5])    # Hello
print(s[:5])     # Hello (start defaults to 0)
print(s[7:])     # World!
print(s[7:12])   # World

# Negative indices
print(s[-6:])    # World!
print(s[-6:-1])  # World
print(s[:-1])    # Hello, World

# Step
print(s[::2])    # Hlo ol!
print(s[1::2])   # el,Wrd
print(s[::-1])   # !dlroW ,olleH (reverse)

# First/last n characters
n = 5
print(s[:n])     # Hello (first 5)
print(s[-n:])    # orld! (last 5)
print(s[:-n])    # Hello, W (all except last 5)

# Slicing never raises IndexError
print(s[0:100])  # Hello, World! (clamped to string length)
print(s[100:])   # '' (empty string)
print(s[-100:5]) # Hello (clamped)

# Slicing returns a new string
substr = s[0:5]
print(substr)      # Hello
print(s)           # Hello, World! (original unchanged)

# Practical examples
url = "https://www.example.com/page"
protocol = url[:url.index('://')]
print(protocol)  # https

# Check palindrome
def is_palindrome(s):
    s = s.lower().replace(" ", "")
    return s == s[::-1]

print(is_palindrome("racecar"))     # True
print(is_palindrome("A man a plan a canal Panama".replace(" ", "")))  # True

# Extract every nth character
text = "abcdefghij"
print(text[::3])  # adgj

H
!
W
Hello
Hello
World!
World
World!
World
Hello, World
Hlo ol!
el,Wrd
!dlroW ,olleH
Hello
orld!
Hello, W
Hello, World!

Hello
Hello
Hello, World!
https
True
True
adgj

Key Points

•s[start:stop:step] -- start inclusive, stop exclusive
•Negative indices count from the end
•Slicing never raises IndexError -- out-of-range is clamped
•s[::-1] reverses a string
•Slicing returns a new string (strings are immutable)

Gotchas

•s[0:5] includes index 0 but NOT index 5 (half-open interval)
•Single index s[100] raises IndexError, but slicing s[100:] returns ''
•s[::-1] reverses but creates a new string -- not memory-efficient for huge strings
•Slicing creates a copy, not a view (unlike NumPy)

s[start:stop:step] extracts substrings. Start is inclusive, stop is exclusive. Negative indices count from end. s[::-1] reverses. Slicing never raises IndexError.

•start inclusive, stop exclusive
•s[::-1] reverses

s = "Hello, World!"
print(s[:5])     # Hello
print(s[7:])     # World!
print(s[-6:])    # World!
print(s[::-1])   # !dlroW ,olleH

Hello
World!
World!
!dlroW ,olleH

Single index out of range raises IndexError, but slicing does not

Question 4 / 15

What are the most commonly used string methods in Python?

Python strings have over 40 built-in methods. The most commonly used ones fall into categories:

Searching:

find(sub) / rfind(sub) -- returns index or -1
index(sub) / rindex(sub) -- returns index or raises ValueError
count(sub) -- counts non-overlapping occurrences
startswith(prefix) / endswith(suffix) -- boolean checks

Modifying (returns new string):

replace(old, new) -- replaces all occurrences
strip() / lstrip() / rstrip() -- removes whitespace
upper() / lower() / title() / capitalize() / swapcase()

Splitting and Joining:

split(sep) -- splits into list
rsplit(sep) -- splits from right
splitlines() -- splits by line breaks
'sep'.join(iterable) -- joins with separator

Testing:

isdigit(), isalpha(), isalnum(), isspace(), isupper(), islower()

Pseudo Code

Search: find, index, count, startswith, endswith
Modify: replace, strip, upper, lower, title
Split/Join: split, join, splitlines
Test: isdigit, isalpha, isalnum, isspace
Format: center, ljust, rjust, zfill

Code

s = "  Hello, World! Hello, Python!  "

# strip -- remove leading/trailing whitespace
print(s.strip())         # 'Hello, World! Hello, Python!'
print(s.lstrip())        # 'Hello, World! Hello, Python!  '
print(s.rstrip())        # '  Hello, World! Hello, Python!'
print("###hello###".strip("#"))  # 'hello' (strip specific chars)

# split -- split into list
print("a,b,c,d".split(","))       # ['a', 'b', 'c', 'd']
print("hello world".split())       # ['hello', 'world'] (splits on whitespace)
print("a,b,c,d".split(",", 2))    # ['a', 'b', 'c,d'] (max 2 splits)
print("a,,b".split(","))           # ['a', '', 'b'] (empty strings kept)

# join -- join iterable with separator
words = ["Hello", "World"]
print(" ".join(words))      # 'Hello World'
print(", ".join(words))     # 'Hello, World'
print("".join(words))        # 'HelloWorld'
print("-".join("hello"))    # 'h-e-l-l-o' (string is iterable)

# replace
print("hello world".replace("world", "Python"))  # 'hello Python'
print("aabaa".replace("a", "x", 2))  # 'xxbaa' (max 2 replacements)

# find / index
print("hello".find("ll"))    # 2
print("hello".find("xyz"))   # -1 (not found)
print("hello".index("ll"))   # 2
# "hello".index("xyz")  # raises ValueError

# count
print("banana".count("an"))  # 2 (non-overlapping)

# startswith / endswith
print("hello.py".endswith(".py"))    # True
print("hello.py".endswith((".py", ".js")))  # True (tuple of suffixes)
print("hello".startswith("he"))      # True

# upper / lower / title / capitalize
print("hello".upper())       # 'HELLO'
print("HELLO".lower())       # 'hello'
print("hello world".title()) # 'Hello World'
print("hello world".capitalize())  # 'Hello world'

# Testing methods
print("123".isdigit())       # True
print("abc".isalpha())       # True
print("abc123".isalnum())    # True
print("   ".isspace())       # True
print("HELLO".isupper())     # True
print("hello".islower())     # True

# splitlines
multiline = "line1\nline2\nline3"
print(multiline.splitlines())  # ['line1', 'line2', 'line3']

Hello, World! Hello, Python!
Hello, World! Hello, Python!
Hello, World! Hello, Python!
hello
['a', 'b', 'c', 'd']
['hello', 'world']
['a', 'b', 'c,d']
['a', '', 'b']
Hello World
Hello, World
HelloWorld
h-e-l-l-o
hello Python
xxbaa
2
-1
2
2
True
True
True
HELLO
hello
Hello World
Hello world
True
True
True
True
True
True
['line1', 'line2', 'line3']

Key Points

•All string methods return new strings (strings are immutable)
•split() without args splits on any whitespace and removes empty strings
•join() is called on the separator, not the list
•find() returns -1 on failure, index() raises ValueError
•startswith/endswith accept tuples for multiple checks

Gotchas

•split(',') keeps empty strings: 'a,,b'.split(',') = ['a', '', 'b']
•split() (no args) vs split(' ') behave differently on multiple spaces
•strip() removes characters, not substrings: 'abcba'.strip('ab') = 'c'
•find() returning -1 can cause bugs if used as a boolean: -1 is truthy

Key methods: split() (to list), join() (from list), strip() (trim whitespace), replace(), find()/index(), upper()/lower(), startswith()/endswith(). All return new strings.

•All string methods return new strings
•join() is called on the separator

print("a,b,c".split(","))     # ['a', 'b', 'c']
print(", ".join(["a", "b"]))  # 'a, b'
print("  hi  ".strip())       # 'hi'
print("hello".replace("l", "r"))  # 'herro'
print("file.py".endswith(".py"))  # True

['a', 'b', 'c']
a, b
hi
herro
True

split() (no args) and split(' ') behave differently

Question 5 / 15

Why are Python strings immutable and what are the implications?

Python strings are immutable: once created, they cannot be modified. Any operation that appears to modify a string actually creates a new string object.

Why immutable?

Hashability: Strings can be dict keys and set members
Thread safety: No race conditions on shared strings
Interning: Python can cache and reuse string objects
Security: Strings passed to functions cannot be modified unexpectedly
Simplicity: Easier to reason about

Performance implications:

String concatenation with += in a loop creates many temporary objects: O(n^2)
Use ''.join(list) instead: O(n)
Use io.StringIO for building strings incrementally
Small modifications require creating an entirely new string

Pseudo Code

Immutable means:
  s[0] = 'H'  -> TypeError
  s.replace() returns NEW string, does not modify s
  s + 'x' creates NEW string

Performance:
  BAD: s += char in loop -> O(n^2)
  GOOD: ''.join(parts) -> O(n)
  GOOD: io.StringIO for incremental building

Code

# Strings cannot be modified in-place
s = "hello"
try:
    s[0] = "H"
except TypeError as e:
    print(f"Error: {e}")  # 'str' object does not support item assignment

# Methods return NEW strings
s = "hello"
upper_s = s.upper()
print(s)        # 'hello' (original unchanged)
print(upper_s)  # 'HELLO' (new string)

# Concatenation creates new objects
a = "hello"
print(id(a))
a = a + " world"  # creates new string, rebinds 'a'
print(id(a))  # different id

# BAD: String concatenation in loop - O(n^2)
import time

parts = ["word"] * 10000

start = time.time()
result = ""
for word in parts:
    result += word + " "  # creates new string each iteration
bad_time = time.time() - start

# GOOD: join - O(n)
start = time.time()
result = " ".join(parts)
good_time = time.time() - start

print(f"Concat: {bad_time:.4f}s, Join: {good_time:.4f}s")

# GOOD: io.StringIO for incremental building
import io

buffer = io.StringIO()
for i in range(5):
    buffer.write(f"Line {i}\n")
result = buffer.getvalue()
print(result)

# Strings are hashable (can be dict keys)
word_count = {}
for word in "the cat sat on the mat".split():
    word_count[word] = word_count.get(word, 0) + 1
print(word_count)  # {'the': 2, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1}

# String interning
a = "hello"
b = "hello"
print(a is b)  # True (Python interns short strings)

# Workaround: convert to list, modify, join back
s = "hello"
chars = list(s)    # ['h', 'e', 'l', 'l', 'o']
chars[0] = 'H'
s = ''.join(chars)
print(s)  # 'Hello'

Error: 'str' object does not support item assignment
hello
HELLO
4388650080
4382093936
Concat: 0.0047s, Join: 0.0000s
Line 0
Line 1
Line 2
Line 3
Line 4

{'the': 2, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1}
True
Hello

Key Points

•Strings cannot be modified in-place -- all operations return new strings
•Immutability enables hashing, interning, and thread safety
•String concatenation in loops is O(n^2) -- use join() for O(n)
•Use io.StringIO for incremental string building
•Convert to list to perform character-level modifications

Gotchas

•s += 'x' looks like mutation but creates a new string
•CPython has an optimization that makes += O(n) in some cases, but do not rely on it
•join() only works on iterables of strings -- convert non-strings first
•String interning is an implementation detail -- never rely on 'is' for string comparison

Strings are immutable: s[0] = 'H' raises TypeError. All methods return new strings. Use ''.join(list) instead of += in loops (O(n) vs O(n^2)). Immutability enables hashing and interning.

•All string operations return new strings
•Use join() not += in loops

s = "hello"
# s[0] = 'H'  # TypeError!

# BAD: O(n^2)
result = ""
for w in words: result += w

# GOOD: O(n)
result = "".join(words)

CPython sometimes optimizes += but do not rely on it

Question 6 / 15

What is the difference between str.format() and f-strings?

Python has had several string formatting approaches:

% formatting (old style): 'Hello, %s' % name -- C-style, limited
str.format(): 'Hello, {}'.format(name) -- Python 2.6+, powerful
f-strings: f'Hello, {name}' -- Python 3.6+, most readable and fastest

str.format() advantages:

Works with format strings stored in variables
Can reuse arguments: '{0} {0}'.format('hi') -> 'hi hi'
Works in older Python versions
Supports __format__ protocol

f-string advantages:

More readable (expression right where it's used)
Faster (compiled at parse time)
Supports any Python expression
Self-documenting with = (Python 3.8+)

When to use which:

Default to f-strings for new code
Use .format() when the template is a variable or from external source
Avoid % formatting in new code

Pseudo Code

% style:    'Hello, %s! Age: %d' % (name, age)
format():   'Hello, {}! Age: {}'.format(name, age)
f-string:   f'Hello, {name}! Age: {age}'

f-strings are fastest and most readable
format() when template is a variable

Code

name = "Alice"
age = 30

# % formatting (old style)
print("Hello, %s! Age: %d" % (name, age))
print("Pi: %.2f" % 3.14159)

# str.format()
print("Hello, {}! Age: {}".format(name, age))
print("Hello, {0}! {0} is {1}".format(name, age))  # reuse args
print("Hello, {name}! Age: {age}".format(name=name, age=age))
print("{:.2f}".format(3.14159))

# f-strings (preferred)
print(f"Hello, {name}! Age: {age}")
print(f"Pi: {3.14159:.2f}")

# f-strings can contain any expression
print(f"Upper: {name.upper()}")
print(f"Even: {[x for x in range(10) if x % 2 == 0]}")

# format() with templates from variables
template = "Dear {name}, your order #{order_id} is ready."
print(template.format(name="Alice", order_id=42))
# f-strings can't do this (expression must be literal)

# Reusing arguments with format()
print("{0} loves {1}. {1} loves {0}".format("Alice", "Bob"))
# f-string equivalent is repetitive:
print(f"{name} loves Bob. Bob loves {name}")

# Dictionary unpacking with format()
data = {"name": "Alice", "city": "NYC"}
print("{name} lives in {city}".format(**data))

# Performance comparison
import timeit

# f-strings are fastest
f_time = timeit.timeit(lambda: f"Hello, {'Alice'}! Age: {30}", number=100000)
format_time = timeit.timeit(lambda: "Hello, {}! Age: {}".format("Alice", 30), number=100000)
percent_time = timeit.timeit(lambda: "Hello, %s! Age: %d" % ("Alice", 30), number=100000)

print(f"f-string: {f_time:.4f}s")
print(f"format(): {format_time:.4f}s")
print(f"% style:  {percent_time:.4f}s")

# format_map with defaultdict
from collections import defaultdict
template = "{name} from {city}"
defaults = defaultdict(lambda: "Unknown", name="Alice")
print(template.format_map(defaults))  # Alice from Unknown

Hello, Alice! Age: 30
Pi: 3.14
Hello, Alice! Age: 30
Hello, Alice! Alice is 30
Hello, Alice! Age: 30
3.14
Hello, Alice! Age: 30
Pi: 3.14
Upper: ALICE
Even: [0, 2, 4, 6, 8]
Dear Alice, your order #42 is ready.
Alice loves Bob. Bob loves Alice
Alice loves Bob. Bob loves Alice
Alice lives in NYC
f-string: 0.0061s
format(): 0.0096s
% style:  0.0072s
Alice from Unknown

Key Points

•f-strings are the most readable and fastest option
•str.format() is needed when template is a variable
•f-strings evaluate expressions inline
•format() supports argument reuse with {0}, {1}
•Avoid % formatting in new code

Gotchas

•f-strings require the expression to be in the source code -- cannot use dynamic templates
•format() with user-supplied templates can be a security risk (format string attacks)
•% formatting with a single tuple needs a trailing comma: '%s' % (value,)
•f-strings evaluate at runtime, not compile time -- exceptions happen at runtime

F-strings (f'...') are fastest and most readable. str.format() is needed when the template is a variable. Avoid % formatting in new code.

•Default to f-strings for new code
•Use format() for dynamic templates

name = "Alice"
# f-string (preferred)
print(f"Hello, {name}!")

# format() when template is a variable
template = "Hello, {name}!"
print(template.format(name=name))

Hello, Alice!
Hello, Alice!

User-supplied format strings can be a security risk

Question 7 / 15

How do raw strings and escape sequences work in Python?

Escape sequences use backslash (\) to represent special characters:

Escape	Meaning
`\n`	Newline
`\t`	Tab
`\\`	Literal backslash
`\'`	Single quote
`\"`	Double quote
`\0`	Null character
`\xhh`	Hex character
`\uhhhh`	Unicode (16-bit)
`\Uhhhhhhhh`	Unicode (32-bit)
`\N{name}`	Unicode by name

Raw strings (r'...') treat backslashes as literal characters. No escape sequences are processed (except that you still cannot end with an odd number of backslashes).

Use cases for raw strings:

Windows file paths: r'C:\Users\file.txt'
Regular expressions: r'\d+\.\d+'
Any string with many backslashes

Pseudo Code

Regular: '\n' = newline, '\t' = tab, '\\' = backslash
Raw: r'\n' = literal backslash + n

Use raw strings for:
  - File paths: r'C:\path\to\file'
  - Regex: r'\d+\.\d+'
  - Any string with many backslashes

Code

# Common escape sequences
print("Hello\nWorld")     # newline between Hello and World
print("Tab\there")        # tab between Tab and here
print("Back\\slash")      # literal backslash
print("She said \"hi\"")  # escaped quotes

# Unicode escapes
print("\u00e9")          # e with accent
print("\N{SNOWMAN}")     # Unicode by name
print("\U0001F600")      # emoji (32-bit Unicode)

# Raw strings -- no escape processing
print(r"Hello\nWorld")   # Hello\nWorld (literal \n)
print(r"C:\Users\alice")  # C:\Users\alice

# Comparison
print(len("\n"))     # 1 (one newline character)
print(len(r"\n"))    # 2 (backslash + n)

# Raw strings for regex
import re

# Without raw string: need double backslashes
pattern1 = "\\d+\\.\\d+"  # matches digits.digits

# With raw string: single backslashes
pattern2 = r"\d+\.\d+"    # same pattern, much cleaner

print(re.findall(pattern2, "Pi is 3.14 and e is 2.72"))
# ['3.14', '2.72']

# Raw string limitation: cannot end with odd number of backslashes
# r"path\" is a SyntaxError
# Workaround:
path = r"C:\path" + "\\"
print(path)  # C:\path\

# Or use os.path / pathlib
from pathlib import Path
path = Path("C:/Users/alice/documents")
print(path)  # C:\Users\alice\documents (on Windows)

# Multiline raw string
regex = r"""
    ^           # start of string
    (\d{3})     # area code
    [-.]        # separator
    (\d{3})     # exchange
    [-.]        # separator
    (\d{4})     # number
    $           # end of string
"""
print(re.match(regex, "555-123-4567", re.VERBOSE))

Hello
World
Tab	here
Back\slash
She said "hi"
é
☃
😀
Hello\nWorld
C:\Users\alice
1
2
['3.14', '2.72']
C:\path\
C:/Users/alice/documents
<re.Match object; span=(0, 12), match='555-123-4567'>

Key Points

•Escape sequences: \n (newline), \t (tab), \\ (backslash)
•Raw strings (r'...') treat backslashes as literal characters
•Raw strings are essential for regex patterns
•Use pathlib for file paths instead of raw strings
•Unicode escapes: \uXXXX (16-bit), \UXXXXXXXX (32-bit), \N{name}

Gotchas

•Raw strings cannot end with an odd number of backslashes
•r'\n' is 2 characters (backslash + n), not a newline
•In Python 3.12+, unrecognized escape sequences generate DeprecationWarning
•Raw strings still process quote escaping for the string delimiter

Escape sequences use \ for special chars: \n (newline), \t (tab), \\ (backslash). Raw strings (r'...') disable escape processing. Essential for regex and file paths.

•r'...' disables escape sequence processing
•Essential for regex patterns

print("Hello\nWorld")    # Hello (newline) World
print(r"Hello\nWorld")   # Hello\nWorld (literal)

import re
pattern = r"\d+\.\d+"   # raw string for regex
print(re.findall(pattern, "3.14"))  # ['3.14']

Hello
World
Hello\nWorld
['3.14']

Raw strings cannot end with an odd number of backslashes

Question 8 / 15

How do encode() and decode() work for string encoding?

In Python 3, str is Unicode text and bytes is raw binary data. Converting between them:

str.encode(encoding='utf-8') converts str -> bytes
bytes.decode(encoding='utf-8') converts bytes -> str

Common encodings:

utf-8 -- universal, variable-width (1-4 bytes), default in Python 3
ascii -- 7-bit, English only
latin-1 (iso-8859-1) -- 8-bit, Western European
utf-16 -- used by Windows internally

Error handling modes:

strict (default) -- raises UnicodeEncodeError/UnicodeDecodeError
ignore -- silently drops problematic characters
replace -- replaces with ? (encode) or \ufffd (decode)
xmlcharrefreplace -- replaces with XML character references

Pseudo Code

str -> bytes: string.encode('utf-8')
bytes -> str: bytestring.decode('utf-8')

Default encoding is utf-8
Errors: strict (raise), ignore (drop), replace (? or replacement char)

Code

# str to bytes (encode)
text = "Hello, World!"
b = text.encode('utf-8')
print(b)           # b'Hello, World!'
print(type(b))     # <class 'bytes'>

# bytes to str (decode)
s = b.decode('utf-8')
print(s)           # 'Hello, World!'
print(type(s))     # <class 'str'>

# Unicode encoding
text = "cafe\u0301"  # cafe with accent
print(text)                           # cafe with accent
print(text.encode('utf-8'))           # b'caf\xc3\xa9' (multi-byte)
print(text.encode('ascii', 'ignore')) # b'caf' (drops non-ASCII)
print(text.encode('ascii', 'replace'))# b'caf?'

# Different encodings produce different bytes
text = "Hello"
print(text.encode('utf-8'))    # b'Hello' (5 bytes)
print(text.encode('utf-16'))   # b'\xff\xfeH\x00e\x00l\x00l\x00o\x00' (12 bytes)
print(text.encode('ascii'))    # b'Hello' (5 bytes)

# Error handling
try:
    "cafe\u0301".encode('ascii')
except UnicodeEncodeError as e:
    print(f"Error: {e}")

# Handling bytes from external sources
raw_bytes = b'\xc3\xa9'  # UTF-8 encoded 'e with accent'
print(raw_bytes.decode('utf-8'))     # correct character
try:
    raw_bytes.decode('ascii')
except UnicodeDecodeError as e:
    print(f"Error: {e}")

# Practical: reading/writing files with encoding
import tempfile
import os

with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', suffix='.txt', delete=False) as f:
    f.write("Hello, Unicode! Emoji: \U0001F600")
    fname = f.name

with open(fname, 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

os.unlink(fname)

# Byte length vs character length
emoji = "\U0001F600"  # grinning face
print(len(emoji))                    # 1 (one character)
print(len(emoji.encode('utf-8')))    # 4 (four bytes in UTF-8)
print(len(emoji.encode('utf-16')))   # 4 + 2 BOM = 6 bytes

b'Hello, World!'
<class 'bytes'>
Hello, World!
<class 'str'>
café
b'cafe\xcc\x81'
b'cafe'
b'cafe?'
b'Hello'
b'\xff\xfeH\x00e\x00l\x00l\x00o\x00'
b'Hello'
Error: 'ascii' codec can't encode character '\u0301' in position 4: ordinal not in range(128)
é
Error: 'ascii' codec can't decode byte 0xc3 in position 0: ordinal not in range(128)
Hello, Unicode! Emoji: 😀
1
4
6

Key Points

•str is Unicode text, bytes is raw binary data
•encode() converts str -> bytes, decode() converts bytes -> str
•Default encoding is UTF-8
•Character length (len(str)) differs from byte length (len(bytes))
•Always specify encoding explicitly when opening files

Gotchas

•str and bytes are different types: 'hello' != b'hello'
•UTF-8 characters can be 1-4 bytes: len(s) != len(s.encode())
•Opening files without specifying encoding uses the system default (may not be UTF-8)
•b'...' literals can only contain ASCII characters

str.encode('utf-8') converts text to bytes. bytes.decode('utf-8') converts bytes to text. Default is UTF-8. Character length and byte length differ for non-ASCII text.

•encode: str -> bytes, decode: bytes -> str
•Always specify encoding explicitly

text = "Hello"
b = text.encode('utf-8')    # b'Hello'
s = b.decode('utf-8')       # 'Hello'

# Character vs byte length
emoji = "\U0001F600"
print(len(emoji))                 # 1 character
print(len(emoji.encode('utf-8'))) # 4 bytes

1
4

len(str) != len(str.encode()) for non-ASCII characters

Question 9 / 15

How do you use regular expressions (regex) in Python?

Python's re module provides regular expression support.

Key functions:

re.search(pattern, string) -- finds first match anywhere
re.match(pattern, string) -- matches at the beginning only
re.findall(pattern, string) -- returns all matches as list
re.finditer(pattern, string) -- returns match objects iterator
re.sub(pattern, replacement, string) -- replace matches
re.split(pattern, string) -- split by pattern
re.compile(pattern) -- pre-compile for reuse

Common patterns:

\d -- digit, \w -- word char, \s -- whitespace
. -- any char, * -- 0+, + -- 1+, ? -- 0 or 1
^ -- start, $ -- end
[abc] -- character class, (group) -- capture group
{n,m} -- between n and m repetitions

Always use raw strings (r'...') for regex patterns to avoid double-escaping.

Pseudo Code

re.search(pattern, string) -> first match or None
re.match(pattern, string) -> match at start or None
re.findall(pattern, string) -> list of all matches
re.sub(pattern, repl, string) -> replaced string

Always use r'...' for patterns

Code

import re

# search -- find first match anywhere
match = re.search(r'\d+', 'abc 123 def 456')
if match:
    print(match.group())   # '123'
    print(match.start())   # 4
    print(match.end())     # 7

# match -- match at beginning only
print(re.match(r'\d+', '123abc'))   # match object
print(re.match(r'\d+', 'abc123'))   # None (not at start)

# findall -- all matches as list
print(re.findall(r'\d+', 'abc 123 def 456'))  # ['123', '456']

# Groups in findall return tuples
print(re.findall(r'(\w+)=(\w+)', 'a=1 b=2'))
# [('a', '1'), ('b', '2')]

# sub -- replace
result = re.sub(r'\d+', 'NUM', 'abc 123 def 456')
print(result)  # 'abc NUM def NUM'

# sub with function
def double_number(match):
    return str(int(match.group()) * 2)

result = re.sub(r'\d+', double_number, 'abc 10 def 20')
print(result)  # 'abc 20 def 40'

# split
print(re.split(r'[,;\s]+', 'a,b; c  d'))  # ['a', 'b', 'c', 'd']

# Compile for reuse
email_pattern = re.compile(r'[\w.]+@[\w.]+\.\w+')
emails = email_pattern.findall('Contact: alice@example.com or bob@test.org')
print(emails)  # ['alice@example.com', 'bob@test.org']

# Named groups
match = re.search(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})', '2026-03-16')
if match:
    print(match.group('year'))   # '2026'
    print(match.group('month'))  # '03'
    print(match.groupdict())     # {'year': '2026', 'month': '03', 'day': '16'}

# Flags
print(re.findall(r'hello', 'Hello HELLO hello', re.IGNORECASE))
# ['Hello', 'HELLO', 'hello']

# VERBOSE mode for readable patterns
phone = re.compile(r"""
    ^(\d{3})    # area code
    [-.]         # separator
    (\d{3})     # exchange
    [-.]         # separator
    (\d{4})$    # number
""", re.VERBOSE)

match = phone.match('555-123-4567')
if match:
    print(match.groups())  # ('555', '123', '4567')

123
4
7
<re.Match object; span=(0, 3), match='123'>
None
['123', '456']
[('a', '1'), ('b', '2')]
abc NUM def NUM
abc 20 def 40
['a', 'b', 'c', 'd']
['alice@example.com', 'bob@test.org']
2026
03
{'year': '2026', 'month': '03', 'day': '16'}
['Hello', 'HELLO', 'hello']
('555', '123', '4567')

Key Points

•Always use raw strings (r'...') for regex patterns
•search() finds first match anywhere, match() only at the start
•findall() returns list of strings, finditer() returns match objects
•Compile patterns with re.compile() for reuse
•Use named groups (?P<name>...) for readable extraction

Gotchas

•re.match() only matches at the beginning -- use re.search() for anywhere
•findall() with groups returns tuples, not the full match
•Forgetting raw strings: '\bword\b' vs r'\bword\b' -- \b is a word boundary in regex but a backspace in Python
•Regex is greedy by default: .* matches as much as possible -- use .*? for non-greedy

Use re module: search() for first match, findall() for all matches, sub() for replace. Always use raw strings (r'...'). match() only checks the start.

•Use raw strings for patterns
•search() anywhere, match() at start only

import re
print(re.findall(r'\d+', 'a1 b22 c333'))  # ['1', '22', '333']
print(re.sub(r'\d+', 'X', 'a1 b22'))       # 'aX bX'

match = re.search(r'(\w+)@(\w+)', 'user@host')
print(match.groups())  # ('user', 'host')

['1', '22', '333']
aX bX
('user', 'host')

match() only checks start of string, not full string

Question 10 / 15

How does string comparison work in Python?

Python compares strings lexicographically (character by character) using Unicode code points.

Comparison operators: ==, !=, <, >, <=, >=

Rules:

Characters are compared by their Unicode code point (ordinal value)
Comparison proceeds character by character from left to right
First difference determines the result
If all characters match, the shorter string is "less than" the longer one
Comparison is case-sensitive by default

Case-insensitive comparison:

str.lower() or str.upper() for simple cases
str.casefold() for proper Unicode case-insensitive comparison

Note: Lexicographic order is NOT the same as human alphabetical order for non-ASCII text. Use locale.strxfrm() or third-party libraries for locale-aware sorting.

Pseudo Code

Character-by-character comparison using Unicode code points:
  'apple' < 'banana' (a < b)
  'abc' < 'abd' (c < d at index 2)
  'abc' < 'abcd' (shorter is less)

Case matters: 'Z' < 'a' (uppercase < lowercase)
Case-insensitive: use .casefold()

Code

# Basic comparison
print("apple" < "banana")    # True (a < b)
print("abc" < "abd")         # True (c < d)
print("abc" < "abcd")        # True (shorter < longer)
print("abc" == "abc")        # True

# Unicode code points
print(ord('A'))  # 65
print(ord('Z'))  # 90
print(ord('a'))  # 97
print(ord('z'))  # 122

# Uppercase comes before lowercase
print('A' < 'a')     # True (65 < 97)
print('Z' < 'a')     # True (90 < 97)
print('Apple' < 'apple')  # True (A < a)

# Case-insensitive comparison
a = "Hello"
b = "hello"
print(a == b)                 # False
print(a.lower() == b.lower()) # True
print(a.casefold() == b.casefold())  # True (better for Unicode)

# casefold vs lower for Unicode
german = "stra\u00dfe"   # strasse with sharp s
print(german.lower())     # 'strasse' (keeps sharp s)
print(german.casefold())  # 'strasse' (converts sharp s to ss)

# Sorting strings
words = ["banana", "Apple", "cherry", "apple"]
print(sorted(words))                        # ['Apple', 'apple', 'banana', 'cherry']
print(sorted(words, key=str.casefold))       # ['apple', 'Apple', 'banana', 'cherry']

# Numeric strings sort lexicographically, not numerically
nums = ["10", "9", "100", "2"]
print(sorted(nums))           # ['10', '100', '2', '9'] (lexicographic!)
print(sorted(nums, key=int))  # ['2', '9', '10', '100'] (numeric)

# startswith and endswith for prefix/suffix checks
filename = "document.pdf"
print(filename.endswith(".pdf"))              # True
print(filename.endswith((".pdf", ".doc")))    # True (tuple)
print(filename.startswith("doc"))             # True

# Identity vs equality for strings
a = "hello"
b = "hello"
print(a == b)   # True (value equality)
print(a is b)   # True (interning, but unreliable!)
# Always use == for string comparison, never 'is'

True
True
True
True
65
90
97
122
True
True
True
False
True
True
straße
strasse
['Apple', 'apple', 'banana', 'cherry']
['Apple', 'apple', 'banana', 'cherry']
['10', '100', '2', '9']
['2', '9', '10', '100']
True
True
True
True
True

Key Points

•Strings compare lexicographically by Unicode code point
•Case-sensitive by default: 'A' < 'a'
•Use casefold() for proper case-insensitive comparison
•Numeric strings sort lexicographically: '10' < '9'
•Always use == for string comparison, never 'is'

Gotchas

•'10' < '9' is True (lexicographic) -- sort numeric strings with key=int
•'Z' < 'a' is True because uppercase has lower code points
•casefold() is better than lower() for Unicode case-insensitive comparison
•Never use 'is' for string comparison -- interning is unreliable

Strings compare lexicographically by Unicode code point. Case-sensitive by default ('A' < 'a'). Use casefold() for case-insensitive comparison. Numeric strings sort lexicographically, not numerically.

•Lexicographic comparison by Unicode code point
•Use casefold() for case-insensitive

print("apple" < "banana")     # True
print("A" < "a")              # True (65 < 97)
print("10" < "9")             # True (lexicographic!)

# Case-insensitive
print("Hello".casefold() == "hello".casefold())  # True

True
True
True
True

'10' < '9' is True -- sort numeric strings with key=int

Question 11 / 15

How do startswith() and endswith() work and what are their common use cases?

startswith(prefix) and endswith(suffix) check if a string begins or ends with a specific substring. Both return bool.

Signature:

str.startswith(prefix[, start[, end]])
str.endswith(suffix[, start[, end]])

Key feature: Both accept a tuple of strings to check multiple prefixes/suffixes at once (acts as OR check).

Common use cases:

File type checking: filename.endswith('.py')
URL protocol: url.startswith('https://')
Filtering lists: [f for f in files if f.endswith('.py')]
Input validation: checking for expected prefixes

These are preferred over slicing (s[:3] == 'abc') or regex for simple prefix/suffix checks because they are more readable and efficient.

Pseudo Code

str.startswith(prefix) -> bool
str.endswith(suffix) -> bool
str.startswith((prefix1, prefix2)) -> bool (any match)

Optional start/end to check a substring:
str.startswith(prefix, start, end)

Code

# Basic usage
print("hello".startswith("he"))    # True
print("hello".endswith("lo"))      # True
print("hello".startswith("lo"))    # False

# Tuple of options (OR check)
filename = "report.pdf"
print(filename.endswith((".pdf", ".doc", ".txt")))  # True
print(filename.endswith((".jpg", ".png")))           # False

url = "https://example.com"
print(url.startswith(("http://", "https://")))  # True

# With start/end parameters
s = "Hello, World!"
print(s.startswith("World", 7))     # True (check from index 7)
print(s.endswith("World", 0, 12))   # True (check s[0:12])

# Practical: filter files by extension
files = ["main.py", "utils.py", "style.css", "index.html", "test.py"]
python_files = [f for f in files if f.endswith(".py")]
print(python_files)  # ['main.py', 'utils.py', 'test.py']

# Practical: categorize URLs
urls = [
    "https://api.example.com/data",
    "http://old.example.com/page",
    "ftp://files.example.com/doc"
]

for url in urls:
    if url.startswith("https://"):
        print(f"Secure: {url}")
    elif url.startswith("http://"):
        print(f"Insecure: {url}")
    else:
        print(f"Other: {url}")

# Prefer startswith/endswith over slicing
# Good:
if filename.endswith(".py"):
    print("Python file")

# Less readable:
if filename[-3:] == ".py":
    print("Python file")

# Stripping known prefix/suffix (Python 3.9+)
print("HelloWorld".removeprefix("Hello"))  # 'World'
print("test_file.py".removesuffix(".py"))  # 'test_file'

True
True
False
True
False
True
True
True
['main.py', 'utils.py', 'test.py']
Secure: https://api.example.com/data
Insecure: http://old.example.com/page
Other: ftp://files.example.com/doc
World
test_file

Key Points

•Both accept a tuple for checking multiple options
•More readable and efficient than slicing for prefix/suffix checks
•Optional start/end parameters for checking substrings
•Python 3.9+ adds removeprefix() and removesuffix()
•Commonly used for file type and URL protocol checks

Gotchas

•The argument must be a tuple, not a list: endswith(['.py', '.js']) raises TypeError
•startswith/endswith are case-sensitive -- use lower() first if needed
•removeprefix/removesuffix (3.9+) are different from strip() -- strip removes characters, not substrings
•These methods do NOT use regex -- for pattern matching, use re.match/re.search

startswith(prefix) and endswith(suffix) check string beginnings/endings. Accept a tuple for multiple checks. Preferred over slicing for readability.

•Accept tuples for multiple checks
•More readable than slicing

print("file.py".endswith(".py"))                    # True
print("file.py".endswith((".py", ".js", ".ts")))    # True
print("https://x.com".startswith(("http", "https"))) # True

# Python 3.9+
print("HelloWorld".removeprefix("Hello"))  # 'World'

True
True
True
World

Argument must be a tuple, not a list

Question 12 / 15

How do translate() and maketrans() work for character-level replacements?

str.translate(table) replaces characters according to a translation table. str.maketrans() creates the translation table.

str.maketrans(x, y, z) has three calling patterns:

maketrans({'a': 'x', 'b': None}) -- dict mapping (None deletes chars)
maketrans('abc', 'xyz') -- 1-to-1 character mapping
maketrans('abc', 'xyz', 'del') -- map + delete chars

Why use translate?

Much faster than chained .replace() calls
Replaces all specified characters in a single pass
Can delete characters by mapping to None

Use cases:

Remove punctuation
Caesar cipher / ROT13
Transliteration
Sanitizing input

Pseudo Code

table = str.maketrans('abc', 'xyz')  # a->x, b->y, c->z
result = 'abc'.translate(table)       # 'xyz'

table = str.maketrans('', '', 'aeiou')  # delete vowels
result = 'hello'.translate(table)        # 'hll'

table = str.maketrans({'a': 'x', 'b': None})  # a->x, delete b

Code

# Basic character mapping
table = str.maketrans('aeiou', '12345')
result = "hello world".translate(table)
print(result)  # 'h2ll4 w4rld'

# Delete characters (third argument)
table = str.maketrans('', '', 'aeiou')
result = "hello world".translate(table)
print(result)  # 'hll wrld' (vowels removed)

# Using dict for mapping
table = str.maketrans({'a': '@', 'e': '3', 'o': '0'})
result = "hello world".translate(table)
print(result)  # 'h3ll0 w0rld'

# Delete with dict (map to None)
table = str.maketrans({'.': None, ',': None, '!': None, '?': None})
result = "Hello, World! How are you?".translate(table)
print(result)  # 'Hello World How are you'

# Remove all punctuation
import string
table = str.maketrans('', '', string.punctuation)
text = "Hello, World! It's a test... right?"
clean = text.translate(table)
print(clean)  # 'Hello World Its a test right'

# ROT13 cipher
import string
rot13_table = str.maketrans(
    string.ascii_lowercase + string.ascii_uppercase,
    string.ascii_lowercase[13:] + string.ascii_lowercase[:13] +
    string.ascii_uppercase[13:] + string.ascii_uppercase[:13]
)

message = "Hello World"
encrypted = message.translate(rot13_table)
print(encrypted)  # 'Uryyb Jbeyq'

# Decrypt (ROT13 is its own inverse)
decrypted = encrypted.translate(rot13_table)
print(decrypted)  # 'Hello World'

# Performance: translate vs multiple replace
import timeit

text = "Hello, World! This is a test." * 1000

def with_replace():
    result = text
    for char in '.,!?':
        result = result.replace(char, '')
    return result

def with_translate():
    table = str.maketrans('', '', '.,!?')
    return text.translate(table)

replace_time = timeit.timeit(with_replace, number=1000)
translate_time = timeit.timeit(with_translate, number=1000)
print(f"replace:   {replace_time:.4f}s")
print(f"translate: {translate_time:.4f}s")  # significantly faster

h2ll4 w4rld
hll wrld
h3ll0 w0rld
Hello World How are you
Hello World Its a test right
Uryyb Jbeyq
Hello World
replace:   0.0524s
translate: 0.0240s

Key Points

•translate() replaces characters in a single pass (very fast)
•maketrans() creates the translation table
•Map to None to delete characters
•Much faster than chained replace() calls
•Useful for removing punctuation, ciphers, and sanitization

Gotchas

•maketrans('abc', 'xyz') requires both strings to be the same length
•translate() only works on single characters, not substrings
•Dict-based maketrans uses ordinals: {ord('a'): 'x'} also works
•translate() returns a new string (strings are immutable)

str.maketrans() creates a character mapping table, str.translate() applies it. Much faster than chained replace(). Map to None to delete characters.

•Single-pass character replacement
•Map to None to delete characters

# Remove vowels
table = str.maketrans('', '', 'aeiou')
print("hello world".translate(table))  # 'hll wrld'

# Character substitution
table = str.maketrans('aeo', '@30')
print("hello".translate(table))  # 'h3ll0'

hll wrld
h3ll0

Only works on single characters, not substrings

Question 13 / 15

How do you work with multiline strings in Python?

Python provides several ways to create multiline strings:

Triple quotes: '''...''' or """..."""
Implicit concatenation: adjacent string literals are joined
Explicit continuation: \ at end of line
Parentheses: strings inside () can span lines

Triple-quoted strings preserve all whitespace and newlines exactly as written, which can cause indentation issues.

The textwrap module helps manage indentation:

textwrap.dedent() removes common leading whitespace
textwrap.indent() adds indentation
textwrap.fill() wraps text to a specified width

Pseudo Code

Triple quotes: '''multi\nline''' or """multi\nline"""
Implicit concat: "hello " "world" -> "hello world"
Continuation: "hello " \
              "world"
Parentheses: ("hello "
              "world")
textwrap.dedent() removes common leading whitespace

Code

# Triple-quoted strings
text = """This is
a multi-line
string."""
print(text)
# This is
# a multi-line
# string.

# Triple quotes preserve indentation
def example():
    text = """This is
    indented
    oddly."""
    print(repr(text))
    # 'This is\n    indented\n    oddly.'

example()

# Fix with textwrap.dedent()
import textwrap

def better_example():
    text = textwrap.dedent("""\
        This is
        properly
        dedented.""")
    print(text)
    # This is
    # properly
    # dedented.

better_example()

# Implicit string concatenation
long_string = ("This is a very long string that "
               "spans multiple lines in the source "
               "but is one string at runtime.")
print(long_string)

# Line continuation with backslash
long_string = "This is a very long string that " \
              "spans multiple lines."
print(long_string)

# textwrap.fill for word wrapping
text = "Python is a powerful programming language that is easy to learn and fun to use."
print(textwrap.fill(text, width=40))
# Python is a powerful programming
# language that is easy to learn and
# fun to use.

# textwrap.indent
text = "Line 1\nLine 2\nLine 3"
print(textwrap.indent(text, "  > "))
#   > Line 1
#   > Line 2
#   > Line 3

# Joining lines from a list
lines = [
    "First line",
    "Second line",
    "Third line"
]
text = "\n".join(lines)
print(text)

# Multiline f-string
name = "Alice"
age = 30
card = f"""
{'='*30}
  Name: {name}
  Age:  {age}
{'='*30}
""".strip()
print(card)

This is
a multi-line
string.
'This is\n    indented\n    oddly.'
This is
properly
dedented.
This is a very long string that spans multiple lines in the source but is one string at runtime.
This is a very long string that spans multiple lines.
Python is a powerful programming
language that is easy to learn and fun
to use.
> Line 1
> Line 2
> Line 3
First line
Second line
Third line
==============================
Name: Alice
Age:  30
==============================

Key Points

•Triple quotes preserve all whitespace and newlines
•Use textwrap.dedent() to fix indentation in triple-quoted strings
•Implicit concatenation joins adjacent string literals at compile time
•Parentheses allow spanning lines without backslash
•textwrap.fill() wraps text to a specified width

Gotchas

•Triple-quoted strings include the first newline if it follows the quotes
•Use a backslash after opening triple quotes to suppress the first newline
•Indentation inside functions makes triple-quoted strings awkward without dedent
•Implicit concatenation only works with literals, not variables: 'a' 'b' works, a b doesn't

Triple quotes (''' or """) for multiline strings. Use textwrap.dedent() to fix indentation. Parentheses () allow spanning lines. Implicit concatenation joins adjacent literals.

•Triple quotes preserve whitespace and newlines
•Use textwrap.dedent() for clean indentation

import textwrap
text = textwrap.dedent("""\
    Hello
    World""")
print(text)  # 'Hello\nWorld'

# Implicit concatenation
s = ("hello "
     "world")  # 'hello world'

Hello
World

Triple-quoted strings include leading newline without backslash escape

Question 14 / 15

What are common string interview coding problems and their solutions?

Here are classic string coding problems frequently asked in interviews:

Reverse a string -- use slicing s[::-1]
Check palindrome -- compare with reverse
Count character frequency -- use collections.Counter
Find first non-repeating character -- use Counter + iteration
Check anagram -- compare sorted or Counter
Remove duplicates preserving order -- use dict.fromkeys()

Python's built-in string methods and standard library make many of these problems much simpler than in other languages.

Pseudo Code

Reverse: s[::-1]
Palindrome: s == s[::-1]
Anagram: sorted(a) == sorted(b) or Counter(a) == Counter(b)
Frequency: Counter(s)
First unique: Counter + iterate to find count == 1
Remove dupes: ''.join(dict.fromkeys(s))

Code

from collections import Counter

# 1. Reverse a string
def reverse_string(s):
    return s[::-1]

print(reverse_string("hello"))  # 'olleh'

# 2. Check palindrome
def is_palindrome(s):
    s = s.lower().replace(" ", "")
    return s == s[::-1]

print(is_palindrome("racecar"))   # True
print(is_palindrome("A man a plan a canal Panama".replace(" ", "")))  # True

# 3. Character frequency
def char_frequency(s):
    return dict(Counter(s))

print(char_frequency("hello"))  # {'h': 1, 'e': 1, 'l': 2, 'o': 1}

# 4. First non-repeating character
def first_unique(s):
    counts = Counter(s)
    for char in s:
        if counts[char] == 1:
            return char
    return None

print(first_unique("aabbcdd"))  # 'c'
print(first_unique("aabb"))     # None

# 5. Check if two strings are anagrams
def is_anagram(a, b):
    return Counter(a.lower()) == Counter(b.lower())

print(is_anagram("listen", "silent"))  # True
print(is_anagram("hello", "world"))   # False

# 6. Remove duplicate characters preserving order
def remove_duplicates(s):
    return ''.join(dict.fromkeys(s))

print(remove_duplicates("abracadabra"))  # 'abrcd'

# 7. Count vowels and consonants
def count_vowels_consonants(s):
    s = s.lower()
    vowels = sum(1 for c in s if c in 'aeiou')
    consonants = sum(1 for c in s if c.isalpha() and c not in 'aeiou')
    return vowels, consonants

print(count_vowels_consonants("Hello World"))  # (3, 7)

# 8. Check if string has all unique characters
def all_unique(s):
    return len(s) == len(set(s))

print(all_unique("abcdef"))  # True
print(all_unique("aabcde"))  # False

# 9. Longest common prefix
def longest_common_prefix(strs):
    if not strs:
        return ""
    prefix = strs[0]
    for s in strs[1:]:
        while not s.startswith(prefix):
            prefix = prefix[:-1]
            if not prefix:
                return ""
    return prefix

print(longest_common_prefix(["flower", "flow", "flight"]))  # 'fl'

# 10. Compress a string (run-length encoding)
def compress(s):
    if not s:
        return ""
    result = []
    count = 1
    for i in range(1, len(s)):
        if s[i] == s[i-1]:
            count += 1
        else:
            result.append(f"{s[i-1]}{count}" if count > 1 else s[i-1])
            count = 1
    result.append(f"{s[-1]}{count}" if count > 1 else s[-1])
    return ''.join(result)

print(compress("aabbbcccc"))  # 'a2b3c4'

olleh
True
True
{'h': 1, 'e': 1, 'l': 2, 'o': 1}
c
None
True
False
abrcd
(3, 7)
True
False
fl
a2b3c4

Key Points

•s[::-1] is the Pythonic way to reverse a string
•Counter() makes frequency counting trivial
•sorted() or Counter comparison for anagram check
•dict.fromkeys() preserves order and removes duplicates
•set(s) for unique character check

Gotchas

•Palindrome checks should normalize case and remove spaces first
•Counter comparison is O(n), sorted comparison is O(n log n)
•dict.fromkeys() preserves first occurrence order
•Always clarify with interviewer: case-sensitive? spaces? unicode?

Common patterns: reverse (s[::-1]), palindrome (s == s[::-1]), anagram (Counter(a) == Counter(b)), frequency (Counter(s)), unique chars (len(s) == len(set(s))).

•Use Python built-ins: slicing, Counter, set
•These patterns cover most string interview questions

from collections import Counter

print("hello"[::-1])                          # 'olleh'
print(Counter("listen") == Counter("silent"))  # True
print(len("abc") == len(set("abc")))           # True (unique)

# First non-repeating character
counts = Counter("aabbcdd")
first = next(c for c in "aabbcdd" if counts[c] == 1)
print(first)  # 'c'

olleh
True
True
c

Always normalize case and whitespace before comparing

Question 15 / 15

How do you check if a string contains only digits, letters, or whitespace?

Python provides several str.is*() methods for character type testing:

Method	Returns True when
`isdigit()`	All chars are digits (0-9, superscripts, etc.)
`isdecimal()`	All chars are decimal digits (0-9 only)
`isnumeric()`	All chars are numeric (includes fractions, etc.)
`isalpha()`	All chars are alphabetic
`isalnum()`	All chars are alphanumeric
`isspace()`	All chars are whitespace
`isupper()`	All cased chars are uppercase
`islower()`	All cased chars are lowercase
`istitle()`	String follows title case
`isascii()`	All chars are ASCII (Python 3.7+)
`isprintable()`	All chars are printable
`isidentifier()`	Valid Python identifier

Important: All is*() methods return False for empty strings.

Pseudo Code

isdigit(): '123' -> True, '12.3' -> False
isdecimal(): stricter than isdigit (only 0-9)
isnumeric(): broadest (includes fractions, superscripts)
isalpha(): 'hello' -> True, 'hi5' -> False
isalnum(): 'hello5' -> True, 'hi!' -> False
isspace(): '   ' -> True, ' hi' -> False

All return False for empty strings

Code

# isdigit, isdecimal, isnumeric differences
print("123".isdigit())      # True
print("123".isdecimal())    # True
print("123".isnumeric())    # True

print("12.3".isdigit())     # False (dot is not a digit)
print("-42".isdigit())      # False (minus is not a digit)

# Unicode differences
print("\u00b2".isdigit())    # True (superscript 2)
print("\u00b2".isdecimal())  # False (not a decimal digit)
print("\u00b2".isnumeric())  # True

print("\u00bd".isnumeric())  # True (fraction 1/2)
print("\u00bd".isdigit())    # False

# isalpha
print("hello".isalpha())     # True
print("hello5".isalpha())    # False
print("helLO".isalpha())     # True (any case)
print("caf\u00e9".isalpha()) # True (accented chars are alpha)

# isalnum
print("hello123".isalnum())  # True
print("hello 123".isalnum()) # False (space)
print("hello!".isalnum())    # False (punctuation)

# isspace
print("   ".isspace())       # True
print(" \t\n".isspace())     # True (tabs and newlines are whitespace)
print("  hi".isspace())      # False

# isupper / islower
print("HELLO".isupper())     # True
print("Hello".isupper())     # False
print("hello".islower())     # True
print("hello123".islower())  # True (no uppercase chars)

# Empty string edge case
print("".isdigit())    # False
print("".isalpha())    # False
print("".isspace())    # False

# Practical: input validation
def validate_username(username):
    if not username:
        return "Username cannot be empty"
    if not username[0].isalpha():
        return "Username must start with a letter"
    if not username.isalnum():
        return "Username can only contain letters and numbers"
    if len(username) < 3 or len(username) > 20:
        return "Username must be 3-20 characters"
    return "Valid"

print(validate_username("alice123"))  # Valid
print(validate_username("123abc"))   # Must start with a letter
print(validate_username("al ice"))   # Only letters and numbers

# isidentifier -- valid Python variable name
print("my_var".isidentifier())   # True
print("2ndvar".isidentifier())   # False (starts with digit)
print("class".isidentifier())    # True (but it's a keyword!)

import keyword
name = "class"
print(name.isidentifier() and not keyword.iskeyword(name))  # False

True
True
True
False
False
True
False
True
True
False
True
False
True
True
True
False
False
True
True
False
True
False
True
True
False
False
False
Valid
Username must start with a letter
Username can only contain letters and numbers
True
False
True
False

Key Points

•isdigit() for digit check, isalpha() for letters, isalnum() for both
•isdecimal() < isdigit() < isnumeric() in strictness
•All is*() methods return False for empty strings
•These methods are Unicode-aware
•isidentifier() checks valid Python names but not keywords

Gotchas

•isdigit() returns False for negative numbers ('-42') and floats ('3.14')
•isdigit() returns True for Unicode superscripts -- use isdecimal() for strict 0-9 only
•All methods return False for empty strings
•isupper()/islower() only consider cased characters -- '123'.islower() returns False, not True

isdigit() checks digits, isalpha() checks letters, isalnum() checks both, isspace() checks whitespace. All return False for empty strings. isdecimal() is stricter than isdigit() for Unicode.

•isdigit for digits, isalpha for letters, isalnum for both
•All return False for empty strings

print("123".isdigit())      # True
print("hello".isalpha())    # True
print("hello123".isalnum()) # True
print("   ".isspace())      # True
print("".isdigit())         # False (empty!)
print("-42".isdigit())      # False (minus sign)

True
True
True
True
False
False

isdigit() returns False for negative numbers and floats

Built by onllm.dev

Home GitHub Support awesomePrep