Strings

s = "hello"
len(s)  # 5, counts code points
"ell" in s  # True, substring test
s * 2  # 'hellohello'
s < "help"  # True, compares code points
ord("A"), chr(65)  # (65, 'A')
str(42), repr("x")  # ('42', "'x'")
", ".join(["a", "b", "c"])  # 'a, b, c'
", ".join(map(str, [1, 2]))  # join needs str items

from datetime import UTC, datetime
 
name, n, price = "Ada", 3, 1234.5
user = {"name": "ann"}
now = datetime(2026, 9, 25, 14, 30, tzinfo=UTC)
 
print(f"{name} has {n} item{'s' if n != 1 else ''}")
print(f"{user["name"]}")  # same quotes (3.12+)
print(f"{'\n'.join(['a', 'b'])}")  # backslash (3.12+)
print(f"{price:,.2f}")  # 1,234.50
print(f"{now:%Y-%m-%d %H:%M}")  # 2026-09-25 14:30
print(f"{name!r}")  # 'Ada': repr()
print(f"{n=}")  # n=3: self-documenting
print(f"{price = :.1f}")  # price = 1234.5
print(f"{{literal braces}}")  # {literal braces}
width = 8
print(f"[{name:>{width}}]")  # nested spec: [     Ada]
print(f"""{
    n * price  # comments allowed inside
}""")

from html import escape
from string.templatelib import (
    Interpolation,
    Template,
    convert,
)
 
 
def html(t: Template) -> str:
    out: list[str] = []
    for item in t:
        match item:
            case str() as text:
                out.append(text)  # trusted literal
            case Interpolation(value, _, conv, spec):
                v = format(convert(value, conv), spec)
                out.append(escape(v))  # untrusted value
    return "".join(out)
 
 
def sql(t: Template) -> tuple[str, list[object]]:
    query = "?".join(t.strings)
    return query, list(t.values)
 
 
evil = "<script>alert(1)</script>"
print(html(t"<p>Hi {evil}!</p>"))
# <p>Hi &lt;script&gt;alert(1)&lt;/script&gt;!</p>
print(sql(t"SELECT * FROM users WHERE id = {42}"))
# ('SELECT * FROM users WHERE id = ?', [42])

import logging
 
log = logging.getLogger(__name__)
user_id = 7
log.info("user %s logged in", user_id)  # lazy: args
# are only formatted if the record is emitted

data = "héllo €".encode("utf-8")
# b'h\xc3\xa9llo \xe2\x82\xac'
text = data.decode("utf-8")
len("€"), len("€".encode())  # (1, 3)
 
b"\xff".decode("utf-8", errors="replace")  # '�'
"é".encode("ascii", errors="ignore")  # b''
"é".encode("ascii", errors="backslashreplace")  # b'\\xe9'
 
b"ab"[0], list(b"ab")  # (97, [97, 98]): ints
bytes.fromhex("dead").hex(":")  # 'de:ad'
bytearray(b"abc").upper()  # mutable variant
 
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write(text)

import re
 
LINE = re.compile(
    r"""
    (?P<ts>\d{4}-\d{2}-\d{2}T[\d:]+Z) \s+  # timestamp
    (?P<level>INFO|WARN|ERROR) \s+       # level
    (?P<msg>.*)                          # message
    """,
    re.VERBOSE,
)
 
if m := LINE.match("2026-09-25T10:00:00Z ERROR disk full"):
    print(m["level"], m.group("msg"))  # ERROR disk full
    print(m.groupdict()["ts"], m.span("msg"))
 
print(re.findall(r"(\w)=(\d)", "a=1 b=2"))
# [('a', '1'), ('b', '2')]: tuples of groups
print(re.split(r"[,;]\s*", "a, b;c"))  # ['a', 'b', 'c']
print(re.sub(r"(?P<user>\w+)@", r"\g<user> at ", "bob@x"))
 
prices = "apple 1.50, pear 2.25"
doubled = re.sub(
    r"\d+\.\d+",
    lambda m: f"{float(m[0]) * 2:.2f}",  # fn replacement
    prices,
    flags=re.ASCII,  # count/flags: keyword only
)

import textwrap
 
sql = textwrap.dedent("""\
    SELECT id
      FROM users
""")  # 'SELECT id\n  FROM users\n'
short = textwrap.shorten(
    "The quick brown fox", 15, placeholder="…"
)  # 'The quick…'

import re
import unicodedata
 
 
def slugify(text: str, sep: str = "-") -> str:
    norm = unicodedata.normalize("NFKD", text)
    ascii_only = norm.encode("ascii", "ignore").decode()
    words = re.findall(r"[a-z0-9]+", ascii_only.lower())
    return sep.join(words)
 
 
print(slugify("Crème Brûlée: 10 Tips!"))
# creme-brulee-10-tips

def truncate(s: str, limit: int, tail: str = "…") -> str:
    if len(s) <= limit:
        return s
    cut = s[: limit - len(tail) + 1]  # peek 1 char
    head = cut.rsplit(" ", 1)[0] if " " in cut else cut[:-1]
    return head.rstrip(" ,.;:") + tail
 
 
print(truncate("The quick brown fox jumps", 16))
# The quick brown…

def parse_kv(text: str) -> dict[str, str]:
    out: dict[str, str] = {}
    for raw in text.splitlines():
        line = raw.strip()
        if not line or line.startswith("#"):
            continue
        key, sep, value = line.partition("=")
        if not sep:
            raise ValueError(f"no '=' in {raw!r}")
        out[key.strip()] = value.strip().strip("\"'")
    return out
 
 
print(parse_kv('# db\nHOST = localhost\nNAME="app"\n'))
# {'HOST': 'localhost', 'NAME': 'app'}

import re
 
_WORDS = re.compile(r"[A-Z]?[a-z0-9]+|[A-Z]+(?![a-z])")
 
 
def words(s: str) -> list[str]:
    return [w.lower() for w in _WORDS.findall(s)]
 
 
def snake(s: str) -> str:
    return "_".join(words(s))
 
 
def kebab(s: str) -> str:
    return "-".join(words(s))
 
 
def camel(s: str) -> str:
    first, *rest = words(s) or [""]
    return first + "".join(w.capitalize() for w in rest)
 
 
print(snake("parseHTTPResponse2"), kebab("user_id"))
# parse_http_response2 user-id
print(camel("created-at_utc"))  # createdAtUtc

import unicodedata
 
 
def strip_accents(s: str) -> str:
    decomposed = unicodedata.normalize("NFD", s)
    return "".join(
        ch
        for ch in decomposed
        if unicodedata.category(ch) != "Mn"
    )
 
 
print(strip_accents("Ångström café Zürich"))
# Angstrom cafe Zurich

rows = [("apple", 3, 1.5), ("kiwi", 12, 0.25)]
head = ("item", "qty", "price")
w = max(len(r[0]) for r in [*rows, head])
 
print(f"{head[0]:<{w}}  {head[1]:>4}  {head[2]:>7}")
print(f"{'':-<{w}}  {'':->4}  {'':->7}")
for name, qty, price in rows:
    print(f"{name:<{w}}  {qty:>4}  {price:>7,.2f}")

item    qty    price
-----  ----  -------
apple     3     1.50
kiwi     12     0.25