len("hello")            # 5

"HeLLo".lower()         # "hello"

"hello world".title()   # "Hello World"
"hELLO".swapcase()      # "Hello"

"  hi  ".strip()        # "hi"
"xxhixx".strip("x")     # "hi"

"a b  c".split()        # ['a', 'b', 'c']
"a,b,c".split(",")      # ['a', 'b', 'c']
"a-b-c".split("-", 1)   # ['a', 'b-c']   (maxsplit)

"".join(['e','h','o'])     # "eho"
", ".join(['a','b'])       # "a, b"
"-".join(str(n) for n in [1,2])  # "1-2"

"a-b-c".replace("-", "")   # "abc"
"aaa".replace("a", "b", 2) # "bba"

"hello".find("z")       # -1
"hello".find("l")       # 2

"ell" in "hello"        # True
3 in [1, 2, 3]          # True

"banana".count("a")     # 3

"hello.py".endswith((".py", ".txt"))   # True

"abc".isalpha()         # True
"a1".isalpha()          # False
"42".isdigit()          # True
[c for c in s if c.isalnum()]   # the classic cleaning filter

"HI!".isupper()         # True

"7".zfill(3)            # "007"
"7".rjust(3, "*")       # "**7"

n = 3.14159
f"pi is {n:.2f}"        # "pi is 3.14"
f"{5:03d}"              # "005"

ord('a')                # 97
chr(97)                 # 'a'
chr((ord(c) - 97 + 1) % 26 + 97)   # shift a lowercase letter by 1, wrapping

tbl = str.maketrans("abc", "xyz")
"cab".translate(tbl)               # "zxy"
"hello".translate(str.maketrans("", "", "aeiou"))  # "hll"  (delete vowels)

s = "abcdef"
s[1:4]      # "bcd"
s[:3]       # "abc"     (from start)
s[3:]       # "def"     (to end)
s[-1]       # "f"       (last char)
s[-2:]      # "ef"      (last two)
s[:-1]      # "abcde"   (drop last)
s[::2]      # "ace"     (every 2nd)
s[::-1]     # "fedcba"  (REVERSE — memorize this one)

lst = [1,2,3,4]
lst[1:3] = [9]      # [1, 9, 4]      (replace 2 items with 1)
lst[1:1] = [7, 8]   # [1, 7, 8, 9, 4] (insert without removing)
del lst[0:2]        # [8, 9, 4]      (delete)

a = [1,2]
a.append([3,4])     # [1, 2, [3, 4]]   <- gotcha
b = [1,2]
b.extend([3,4])     # [1, 2, 3, 4]
[1,2] + [3,4]       # [1, 2, 3, 4]

lst = [1,2,3]
lst.pop()           # returns 3 -> lst = [1, 2]
lst.pop(0)          # returns 1 -> lst = [2]
lst.remove(2)       # lst = []   (by value, raises if absent)

sorted("cba")                    # ['a', 'b', 'c']
sorted([3,1,2], reverse=True)    # [3, 2, 1]
"".join(sorted("cba"))           # "abc"    (the anagram pattern)
lst.sort()                       # in place, returns None

sorted(words, key=len)                        # by length
sorted(words, key=str.lower)                  # case-insensitive
sorted(pairs, key=lambda p: p[1])             # by 2nd element of each tuple
sorted(d.items(), key=lambda kv: -kv[1])      # dict by value, descending

[1,2,3][::-1]           # [3, 2, 1]
list(reversed([1,2,3])) # [3, 2, 1]

[1,2,2].index(2)        # 1
[1,2,2].count(2)        # 2

list("abc")             # ['a', 'b', 'c']
tuple([1,2])            # (1, 2)

d = {"a": 1}
d["b"] = 2              # add / overwrite
d["a"]                  # 1  (KeyError if missing)

d.get("z", 0)                       # 0
counts[c] = counts.get(c, 0) + 1    # count occurrences — memorize this

for k, v in d.items():
    ...
list(d.keys())          # ['a', 'b']
sum(d.values())         # 3

groups.setdefault(key, []).append(item)   # group-by in one line
d.update({"c": 3})
{**d1, **d2}                              # merge into a new dict

max(counts, key=counts.get)

set([1,1,2])            # {1, 2}
list(set(lst))          # dedupe (loses order)
len(set(s)) == len(s)   # all characters unique?

a & b       # in both
a | b       # in either
a - b       # in a, not in b
a ^ b       # in exactly one
set("aeiou") & set(word)    # which vowels appear

from collections import Counter
c = Counter("hello")        # Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
c.most_common(1)            # [('l', 2)]
c["l"]                      # 2  (missing keys give 0, not an error)
Counter(a) == Counter(b)    # anagram check

from collections import defaultdict
g = defaultdict(list)
g["x"].append(1)        # no KeyError; {'x': [1]}

int("42")               # 42
int("42") + 1           # 43   ("42" + 1 would TypeError
str(42) + "!"           # "42!"
int(3.9)                # 3    (truncates toward zero, no rounding)

7 // 2                  # 3
7 % 2                   # 1
n % 2 == 0              # is even
2 ** 10                 # 1024
divmod(7, 2)            # (3, 1)

abs(-4)                 # 4
round(3.14159, 2)       # 3.14
max([1,5,2])            # 5
max(3, 7)               # 7
sum([1,2,3])            # 6
sum(1 for c in s if c in "aeiou")   # count with a condition

import math
math.sqrt(16)           # 4.0
math.floor(2.7)         # 2
math.ceil(2.1)          # 3
math.gcd(12, 18)        # 6
math.factorial(5)       # 120
math.inf                # sentinel for "worse than any real value"

if not s:  ...          # empty string
x = val or "default"    # fallback when val is falsy

for i in range(5):        ...   # 0,1,2,3,4
for i in range(1, n + 1): ...   # 1..n
for i in range(len(s)-1, -1, -1): ...  # backwards

for c in "hello": ...
for item in lst:  ...

for i, c in enumerate("abc"):
    ...                 # (0,'a'), (1,'b'), (2,'c')
for i, x in enumerate(lst, 1):  ...  # 1-based

for x, y in zip([1,2], "ab"):  ...   # (1,'a'), (2,'b')
dict(zip(keys, values))              # build a dict from two lists
list(zip(*matrix))                   # transpose rows <-> columns

for x in lst:
    if bad(x): break
else:
    print("none were bad")

result = 1
for i in range(1, n + 1):
    result = result * i     # factorial

[x * 2 for x in [1,2,3]]                 # [2, 4, 6]
[c for c in s if c.isalpha()]            # keep letters only
"".join(c for c in s if c.isalnum())     # clean string, one line
[x for x in a if x in b]                 # common elements

["even" if n % 2 == 0 else "odd" for n in nums]

{k: v for k, v in pairs}
{c: s.count(c) for c in set(s)}     # frequency map
{x for x in lst if x > 0}           # unique positives

[c for word in words for c in word]     # flatten
[[row[i] for row in m] for i in range(len(m[0]))]   # transpose

any(c.isdigit() for c in s)     # contains a digit?
all(c.isalpha() for c in s)     # letters only?

list(map(int, "1 2 3".split()))     # [1, 2, 3]
nums = [int(x) for x in input().split()]   # same thing, preferred
sorted(lst, key=lambda x: x[1])

\d  digit      \w  letter/digit/_    \s  whitespace
\D  non-digit  \W  non-word          \S  non-space
+   1 or more  *   0 or more         ?   optional
^   start      $   end               .   any char
[abc] any of   [^abc] none of        [a-z] range

re.findall(r"\d+", "a1b22")     # ['1', '22']
re.findall(r"[a-zA-Z]+", s)     # all words

re.sub(r"[^a-z0-9]", "", s.lower())    # strip everything but alnum
re.sub(r"\s+", " ", s).strip()         # collapse whitespace

m = re.search(r"\d+", s)
if m: m.group()

re.split(r"[,;]\s*", "a, b;c")     # ['a', 'b', 'c']

s = s.strip().lower()
s = "".join(c for c in s if c.isalnum())
words = s.split()

n = int(input())
nums = [int(x) for x in input().split(",")]

list(dict.fromkeys([3,1,3,2]))     # [3, 1, 2]

[x for sub in nested for x in sub]

groups = {}
for item in items:
    groups.setdefault(key(item), []).append(item)

from collections import Counter
Counter(items)
# or: counts[x] = counts.get(x, 0) + 1

{v: k for k, v in d.items()}

list(zip(*matrix))                  # list of tuples
[list(r) for r in zip(*matrix)]     # list of lists

[x for x in lst if x]               # drops "", 0, None, []
[x for x in lst if x is not None]   # drops only None

def to_int(x, default=None):
    try:
        return int(x)
    except (ValueError, TypeError):
        return default

a = np.array([1, 2, 3])
m = np.array([[1,2],[3,4]])
m.shape                 # (2, 2)

np.arange(0, 10, 2)     # [0 2 4 6 8]
np.linspace(0, 1, 5)    # [0. 0.25 0.5 0.75 1.]
np.zeros((2, 3))        # 2x3 of 0.0

a * 2                   # [2 4 6]
a + a                   # [2 4 6]
a ** 2                  # [1 4 9]
np.sqrt(a)

a[a > 1]                # [2 3]
mask = (a > 1) & (a < 3)    # use & | ~, NOT and/or/not
a[mask]                 # [2]

np.where(a > 1, "big", "small")     # ['small' 'big' 'big']
np.where(a > 1)                     # (array([1, 2]),)

m.sum()                 # everything
m.sum(axis=0)           # column totals
m.mean(axis=1)          # row means
a.min(), a.max(), a.std()
a.argmax()              # index of the max, not the value

np.arange(6).reshape(2, 3)
np.arange(6).reshape(-1, 2)     # infer rows
m.T
m.flatten()

np.unique(a, return_counts=True)
np.concatenate([a, a])
a[~np.isnan(a)]                 # drop NaNs

df = pd.read_csv("f.csv")
df.head()               # first 5 rows
df.shape                # (rows, cols)
df.info()               # dtypes + non-null counts (start here)
df.describe()           # numeric summary
df.columns              # column names

df["col"]               # one column -> Series
df[["a", "b"]]          # several -> DataFrame
df.loc[0, "col"]        # by label
df.iloc[0]              # first row by position
df.iloc[0:3, 1:]        # positional block

df[df["age"] > 30]
df[(df["age"] > 30) & (df["city"] == "NY")]
df[df["name"].isin(["a", "b"])]
df.query("age > 30 and city == 'NY'")   # string form

df.isna().sum()             # nulls per column
df.dropna()                 # drop rows with any NaN
df.dropna(subset=["a"])     # only where column a is null
df.fillna(0)
df["a"].fillna(df["a"].mean())

df.duplicated().sum()
df.drop_duplicates()
df.drop_duplicates(subset=["id"], keep="last")

df["a"] = df["a"].astype(int)
df["a"] = pd.to_numeric(df["a"], errors="coerce")
df["d"] = pd.to_datetime(df["d"], errors="coerce")

df["name"].str.strip().str.lower()
df["name"].str.contains("smith", case=False)
df["full"].str.split(" ", expand=True)     # -> multiple columns
df["s"].str.replace(r"\D", "", regex=True)

df.rename(columns={"old": "new"})
df.drop(columns=["a", "b"])
df["total"] = df["x"] + df["y"]         # vectorized, no loop
df["flag"] = df["x"].apply(lambda v: v > 0)
df["cat"] = df["code"].map({"A": "apple"})   # Series -> lookup swap

df["city"].value_counts()               # frequency table, sorted desc
df["city"].value_counts(normalize=True) # proportions
df["city"].nunique()
df["city"].unique()

df.sort_values("age", ascending=False)
df.sort_values(["city", "age"])
df.nlargest(3, "age")

df.groupby("city")["age"].mean()
df.groupby("city").agg({"age": "mean", "id": "count"})
df.groupby(["city", "job"]).size().reset_index(name="n")

pd.merge(a, b, on="id", how="left")     # how: inner/left/right/outer
pd.concat([df1, df2], ignore_index=True)   # stack rows

df.pivot_table(index="city", columns="job", values="pay", aggfunc="mean")
df.melt(id_vars="id", var_name="k", value_name="v")   # wide -> long
df.reset_index(drop=True)

df[df.a > 1]["b"] = 0          # BAD — may not stick
df.loc[df.a > 1, "b"] = 0      # GOOD