Strings — Creation, Indexing, Slicing, Methods

name = "Maria"
quote = 'She said "hello" to me'    # double quotes inside single quotes — no escaping needed
apostrophe = "It's a nice day"       # single quote inside double quotes — no escaping needed

# Triple-quoted strings span multiple lines
bio = """Maria is a software engineer
based in Austin, Texas.
She specialises in backend systems."""

name = "maria"
name.upper()
print(name)          # "maria" — UNCHANGED. .upper() returned a new string, and we discarded it.

name = name.upper()  # you must reassign to keep the result
print(name)          # "MARIA"

name[0] = "M"
# TypeError: 'str' object does not support item assignment — strings cannot be edited in place

word = "Python"
#        P  y  t  h  o  n
#        0  1  2  3  4  5
#       -6 -5 -4 -3 -2 -1

word[0]     # "P"   — first character
word[5]     # "n"   — last character
word[-1]    # "n"   — last character, the easier way
word[-6]    # "P"   — first character, counting from the end
word[10]    # IndexError: string index out of range

word = "Python"

word[0:3]     # "Pyt"   — indices 0, 1, 2 (index 3 is EXCLUDED)
word[2:]      # "thon"  — from index 2 to the end
word[:3]      # "Pyt"   — from the start up to (not including) index 3
word[:]       # "Python" — the whole string (a full copy)
word[-3:]     # "hon"   — the last three characters
word[::2]     # "Pto"   — every second character, from the start
word[::-1]    # "nohtyP" — the entire string, reversed

word = "Python"
word[2:100]   # "thon" — no error, just returns what's available
word[100]     # IndexError: string index out of range

word = "Python"
len(word)              # 6
word[len(word) - 1]     # "n" — the last character, the long way
word[-1]                  # "n" — the same thing, idiomatically

"  hello world  ".strip()     # "hello world"    — remove leading/trailing whitespace
"  hello  ".lstrip()           # "hello  "         — remove leading whitespace only
"  hello  ".rstrip()            # "  hello"          — remove trailing whitespace only
"Hello".upper()                  # "HELLO"
"Hello".lower()                   # "hello"
"hello world".title()              # "Hello World"   — capitalise each word
"hello".capitalize()                # "Hello"          — capitalise only the first character
"Hello World".swapcase()             # "hELLO wORLD"    — flip every character's case

"hello world".find("world")      # 6    — index where it starts, or -1 if not found
"hello world".index("world")     # 6    — same, but raises ValueError if not found
"hello world".rfind("o")          # 7    — like find(), but searches from the RIGHT
"hello world".count("o")           # 2    — how many times a substring appears
"hello world".startswith("hello")   # True
"hello world".endswith(".com")       # False
"world" in "hello world"               # True — the "in" operator for substring checks

"hello".isdigit()      # False
"12345".isdigit()       # True
"hello".isalpha()        # True
"hello123".isalnum()      # True  — letters AND digits, no other characters
"   ".isspace()            # True
"Hello World".istitle()     # True — every word starts with a capital

"a,b,c".split(",")              # ['a', 'b', 'c']
"hello world foo".split()        # ['hello', 'world', 'foo']  — splits on any whitespace by default
"a,b,,c".split(",")                # ['a', 'b', '', 'c']       — empty strings are kept
"a.b.c".split(".", 1)               # ['a', 'b.c']              — maxsplit limits how many splits happen
",".join(["a", "b", "c"])             # "a,b,c"
" ".join(["hello", "world"])           # "hello world"
"".join(["h", "e", "l", "l", "o"])      # "hello" — joining with an empty separator concatenates directly

"hello world".replace("world", "Python")   # "hello Python"
"aaa".replace("a", "b", 2)                    # "bba" — the count argument limits how many replacements
"line1\nline2\nline3".splitlines()            # ['line1', 'line2', 'line3']

name = "Maria"
age = 25
print(f"{name} is {age} years old.")     # "Maria is 25 years old."
print(f"Next year, {name} will be {age + 1}.")  # expressions work directly inside {}
print(f"{name.upper()} works here.")       # method calls work too

price = 1234.5678

f"{price:.2f}"      # "1234.57"     — round to 2 decimal places
f"{price:,.2f}"      # "1,234.57"    — thousands separator + 2 decimal places
f"{price:10.2f}"      # "   1234.57"  — right-aligned in a field 10 characters wide
f"{price:<10.2f}"      # "1234.57   " — left-aligned in a field 10 characters wide
f"{price:^12.2f}"        # "  1234.57   " — centre-aligned in a field 12 characters wide
f"{42:05d}"                # "00042"       — zero-padded to 5 digits
f"{0.856:.1%}"               # "85.6%"       — format as a percentage
f"{255:x}"                     # "ff"          — format as hexadecimal
f"{255:b}"                      # "11111111"    — format as binary

"{} is {} years old".format(name, age)          # positional
"{n} is {a} years old".format(n=name, a=age)      # named
"{0} is {1}, {0} again".format(name, age)          # indices can repeat

"%s is %d years old" % (name, age)

text = "café"
encoded = text.encode("utf-8")
print(encoded)                # b'caf\xc3\xa9' — the bytes object representing "café" in UTF-8

decoded = encoded.decode("utf-8")
print(decoded)                  # "café" — back to a normal string
print(decoded == text)           # True

# Slow — creates a brand new string object on every single iteration,
# because strings are immutable and += must build a new string each time:
result = ""
for word in ["a", "b", "c", "d"]:
    result += word + " "

# Fast — join() builds the final string once, from a list, in one pass:
result = " ".join(["a", "b", "c", "d"])

"Line one\nLine two"      # \n — newline
"Column1\tColumn2"         # \t — tab
"She said \"hi\""            # \" — an escaped double quote inside a double-quoted string
"C:\\Users\\Maria"           # \\ — a single literal backslash

path = r"C:\Users\Maria\Documents"   # readable — no need to double every backslash
pattern = r"\d+"                          # a regex pattern meaning "one or more digits"

An engineer builds a customer-import script that reads a CSV file of new sign-ups and loads them into the database. It works perfectly in testing with sample data like "John Smith" and "Jane Doe." In production, the import crashes on a real customer named José García.

What the investigation finds

The script opened the file with open("customers.csv") — no encoding specified. On the engineer's development machine (macOS), the default encoding happens to be UTF-8, so it worked in every test. The production server runs a different default locale, and the same code, run there, tries to decode the file's UTF-8 bytes using a different assumed encoding, producing a UnicodeDecodeError the moment it hits the accented character in "José."

The fix

# Before — relies on the operating system's default encoding, which varies by machine:
with open("customers.csv") as f:
    ...

# After — explicit, and correct on every machine, every time:
with open("customers.csv", encoding="utf-8") as f:
    ...

This exact bug — code that works flawlessly in development and fails in production because of an unstated encoding assumption — is common enough that it has a name among experienced engineers: "works on my machine." Real-world names, addresses, and product descriptions contain non-ASCII characters constantly. This is exactly why Part 07 of this module treated Unicode and encoding as a first-class topic rather than a footnote — it is one of the most common real production bugs in text-processing code, and it is entirely preventable by always specifying an encoding explicitly.