# Cleaning and normalizing
s = "  Ada Lovelace  "
s.strip()           # "Ada Lovelace"    remove leading/trailing whitespace
s.lstrip()          # "Ada Lovelace  "  left only
s.rstrip()          # "  Ada Lovelace"  right only
s.strip().lower()   # "ada lovelace"    chain methods freely

# Splitting and joining
"a,b,c".split(",")          # ["a", "b", "c"]
"  a  b  c  ".split()       # ["a", "b", "c"]  no arg: split on ANY whitespace
"-".join(["2026", "06", "27"])   # "2026-06-27"
"\n".join(["line1", "line2"])    # "line1\nline2"

# Searching and checking
"hello world".find("world")   # 6      (-1 if not found)
"hello world".index("world")  # 6      (raises ValueError if not found)
"hello world".count("l")      # 3
"report.pdf".endswith(".pdf")  # True
"config.yaml".startswith("con")  # True
"hello world".replace("l", "L")  # "heLLo worLd"

# Testing string content
"abc123".isalpha()    # False  (has digits)
"abc".isalpha()       # True
"123".isdigit()       # True
"abc123".isalnum()    # True
"  ".isspace()        # True

# Case manipulation
"ada lovelace".title()   # "Ada Lovelace"
"Ada".upper()            # "ADA"
"ADA".lower()            # "ada"
"Ada".swapcase()         # "aDA"

# Padding and alignment
"42".zfill(5)                 # "00042"   zero-pad on left
"left".ljust(10)              # "left      "
"right".rjust(10)             # "     right"
"center".center(12, "-")      # "---center---"

name  = "Ada"
qty   = 3
price = 19.5
score = 0.9234

# Basic expression embedding — any valid Python expression
f"Hello, {name}!"                      # "Hello, Ada!"
f"{qty} × {price} = {qty * price}"     # "3 × 19.5 = 58.5"
f"{name.upper()!r}"                    # "'ADA'"  (!r adds repr())
f"{name!s} {name!a}"                   # str() and ascii() conversion

# Number formatting — the format spec after :
f"{price:.2f}"           # "19.50"   2 decimal places
f"{price:08.2f}"         # "00019.50"  width 8, zero-padded
f"{score:.1%}"           # "92.3%"   percentage
f"{1_000_000:,}"         # "1,000,000"  thousands separator
f"{255:#010x}"           # "0x000000ff"  hex with prefix, padded

# Alignment
f"{'left':<10}|"         # "left      |"   left-align in width 10
f"{'right':>10}|"        # "     right|"   right-align
f"{'center':^10}|"       # "  center  |"   center
f"{'fill':*^10}|"        # "**fill****|"   fill with *

# Debug form (Python 3.8+): variable=value
f"{price=}"              # "price=19.5"
f"{qty * price = :.2f}"  # "qty * price = 58.50"

# Multi-line f-string
report = (
    f"Customer: {name}\n"
    f"  Items:  {qty}\n"
    f"  Total:  ${qty * price:.2f}\n"
)

# Conditional expression inside f-string
f"Status: {'active' if score > 0.9 else 'inactive'}"
# "Status: active"

# str (text) vs bytes (binary)
text  = "Hello, 世界"           # str: Unicode, abstract characters
raw   = text.encode("utf-8")    # bytes: b'Hello, \xe4\xb8\x96\xe7\x95\x8c'
back  = raw.decode("utf-8")     # str again: "Hello, 世界"

len(text)   # 9  characters
len(raw)    # 13  bytes (CJK characters take 3 bytes each in UTF-8)

# ALWAYS specify encoding when opening files
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("Hello, 世界\n")

with open("data.txt", encoding="utf-8") as f:
    content = f.read()

# Common encoding pitfall: platform default != utf-8 on Windows
# open("file.txt") on Windows might use cp1252 — always be explicit

# Practical: check and normalize encoding in a data pipeline
def safe_decode(data: bytes, fallback="replace") -> str:
    """Try UTF-8 first, fall back gracefully."""
    try:
        return data.decode("utf-8")
    except UnicodeDecodeError:
        return data.decode("latin-1", errors=fallback)

import timeit

# SLOW: O(n²) — each += copies the whole string built so far
def slow_concat(n):
    result = ""
    for i in range(n):
        result += str(i) + ","
    return result

# FAST: O(n) — collect, then join once
def fast_concat(n):
    parts = []
    for i in range(n):
        parts.append(str(i))
    return ",".join(parts)

# FASTEST: generator expression into join
def fastest_concat(n):
    return ",".join(str(i) for i in range(n))

n = 10_000
slow = timeit.timeit(lambda: slow_concat(n), number=100)
fast = timeit.timeit(lambda: fast_concat(n), number=100)

print(f"slow: {slow:.3f}s   fast: {fast:.3f}s   speedup: {slow/fast:.1f}x")
# typical: slow: 1.8s   fast: 0.12s   speedup: 15x

import re

log_line = "2026-06-27 14:32:01 ERROR user_id=1042 msg='Payment failed'"

# re.search: find first match anywhere in string
match = re.search(r"\d{4}-\d{2}-\d{2}", log_line)
if match:
    print(match.group())    # "2026-06-27"

# re.findall: return all non-overlapping matches as list
re.findall(r"\d+", log_line)    # ["2026", "06", "27", "14", "32", "01", "1042"]

# Named groups: extract structured data
pattern = re.compile(
    r"(?P<date>\d{4}-\d{2}-\d{2}) "
    r"(?P<time>\d{2}:\d{2}:\d{2}) "
    r"(?P<level>\w+) "
    r"user_id=(?P<uid>\d+)"
)
m = pattern.search(log_line)
m.group("date")     # "2026-06-27"
m.group("level")    # "ERROR"
m.group("uid")      # "1042"
m.groupdict()       # {'date': '2026-06-27', 'time': '14:32:01', 'level': 'ERROR', 'uid': '1042'}

# re.sub: replace with regex
cleaned = re.sub(r"\s+", " ", "  too   many   spaces  ").strip()
# "too many spaces"

# Compile patterns you reuse — avoids recompiling on every call
EMAIL_RE = re.compile(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}")
emails = EMAIL_RE.findall("contact ada@x.io or bob@y.com for help")
# ['ada@x.io', 'bob@y.com']