conda create -n mec python=3.12 numpy scipy pandas matplotlib seaborn jupyterlab
conda activate mec

print("Hello, class.")

Hello, class.

import sys

print("Python", sys.version.split()[0])
assert sys.version_info >= (3, 10), "This series assumes Python 3.10+ — please upgrade."
print("Kernel is alive.")

Python 3.12.3
Kernel is alive.

from importlib.metadata import version, PackageNotFoundError

# (what we call it, distribution names to try, first lecture of this series that needs it)
needed = [
    ("numpy",      ("numpy",),                                        "fd04"),
    ("scipy",      ("scipy",),                                        "fd09"),
    ("tensorflow", ("tensorflow", "tensorflow-cpu", "tensorflow-intel"), "fd10"),
    ("sklearn",    ("scikit-learn",),                                 "fd11"),
    ("pandas",     ("pandas",),                                       "fd06"),
    ("matplotlib", ("matplotlib",),                                   "fd06"),
    ("seaborn",    ("seaborn",),                                      "fd06"),
    ("requests",   ("requests",),                                     "fd07"),
    ("bs4",        ("beautifulsoup4",),                               "fd07"),
    ("numba",      ("numba",),                                        "fd04"),
    ("pytest",     ("pytest",),                                       "fd04"),
]

def installed_version(candidates):
    # return the version of the first distribution that is installed, else None
    for name in candidates:
        try:
            return version(name)
        except PackageNotFoundError:
            continue
    return None

missing = []
print(f"{'package':14s}{'version':14s}first needed by")
print("-" * 46)
for name, candidates, first in needed:
    found = installed_version(candidates)
    if found is None:
        missing.append(candidates[0])
        print(f"{name:14s}{'MISSING':14s}{first}   <- install before this lecture")
    else:
        print(f"{name:14s}{found:14s}{first}")

print("-" * 46)
print(f"{len(needed) - len(missing)} of {len(needed)} present." +
      (f"  To install: conda install {' '.join(missing)}" if missing else ""))

package       version       first needed by
----------------------------------------------
numpy         1.26.4        fd04
scipy         1.16.0        fd09
tensorflow    2.19.0        fd10
sklearn       1.5.1         fd11
pandas        2.2.3         fd06
matplotlib    3.9.2         fd06
seaborn       0.13.2        fd06
requests      2.32.5        fd07
bs4           4.12.3        fd07
numba         0.60.0        fd04
pytest        8.4.2         fd04
----------------------------------------------
11 of 11 present.

2 + 3, 7 - 4, 6 * 9, 2 ** 10

(5, 3, 54, 1024)

7 / 2, 7 // 2, 7 % 2

(3.5, 3, 1)

2 ** 100

1267650600228229401496703205376

0.1 + 0.2

0.30000000000000004

import math

math.isclose(0.1 + 0.2, 0.3)

True

x = 42
print(type(x))
x = "forty-two"
print(type(x))

<class 'int'>
<class 'str'>

int("3"), float("3.14"), str(42), bool(0), bool(1), bool("")

(3, 3.14, '42', False, True, False)

interest_rate = 0.05
horizon = 30
final_value = 1000 * (1 + interest_rate) ** horizon
print(f"After {horizon} years at {interest_rate:.0%}, $1000 grows to ${final_value:,.2f}.")

After 30 years at 5%, $1000 grows to $4,321.94.

1 < 2, 2 == 2.0, 2 == "2", "abc" < "abd"

(True, True, False, True)

(2 < 3) and (3 < 4), (1 == 2) or (3 < 4), not (1 == 1)

(True, True, False)

bool(0), bool(0.0), bool(""), bool([]), bool("False"), bool([0])

(False, False, False, False, True, True)

def tax(income):
    # Toy progressive tax with three brackets.
    if income <= 10_000:
        return 0.0
    elif income <= 50_000:
        return 0.15 * (income - 10_000)
    else:
        return 0.15 * 40_000 + 0.30 * (income - 50_000)

for y in [5_000, 25_000, 80_000]:
    print(f"income = ${y:>6,}  ->  tax = ${tax(y):>8,.2f}")

income = $ 5,000  ->  tax = $    0.00
income = $25,000  ->  tax = $2,250.00
income = $80,000  ->  tax = $15,000.00

# A while loop: the smallest n such that 2**n > 1_000_000
n = 0
while 2 ** n <= 1_000_000:
    n += 1
print(n, 2 ** n)

20 1048576

# A for loop over range(start, stop, step)
total = 0
for k in range(1, 11):
    total += k
print(total)

55

for i in range(1, 16):
    if i % 15 == 0:        # multiple of both 3 and 5 — must be tested first
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

# 5-year bond: 10% coupon on $1000 of face value, principal repaid at maturity
c_t = [100, 100, 100, 100, 100 + 1000]
nbt = len(c_t)
r = 0.05

pv_loop = 0.0
for t, c in enumerate(c_t, start=1):
    pv_loop += c / (1 + r) ** t

print(f"nbt = {nbt} dates, discount rate r = {r:.2%}")
print(f"PV via loop     = ${pv_loop:.6f}")

nbt = 5 dates, discount rate r = 5.00%
PV via loop     = $1216.473834

c, F, T = 100, 1000, nbt
pv_formula = c * (1 - (1 + r) ** -T) / r + F / (1 + r) ** T

print(f"PV via formula  = ${pv_formula:.6f}")

gap = abs(pv_loop - pv_formula)
tol = 1e-10
print(f"|loop - formula| = {gap:.2e}   (tolerance {tol:.0e})")
assert gap < tol, "the two routes disagree — one of them is wrong"
print("check passed.")

PV via formula  = $1216.473834
|loop - formula| = 2.27e-13   (tolerance 1e-10)
check passed.

# The price vector: p_t[i] is the price today of one dollar delivered at date i+1
p_t = [(1 + r) ** -(t + 1) for t in range(nbt)]

pv_prices = sum(p * c for p, c in zip(p_t, c_t))

print(f"{'date t':>7}{'price p_t':>13}{'cash flow c_t':>16}{'value p_t c_t':>16}")
print("-" * 52)
for t in range(nbt):
    print(f"{t + 1:>7}{p_t[t]:>13.6f}{c_t[t]:>16.2f}{p_t[t] * c_t[t]:>16.6f}")

print("-" * 52)
print(f"PV via prices   = ${pv_prices:.6f}")

gap = max(abs(pv_prices - pv_loop), abs(pv_prices - pv_formula))
tol = 1e-10
print(f"max gap across the three routes = {gap:.2e}   (tolerance {tol:.0e})")
assert gap < tol
print("check passed: three routes, one number.")

 date t    price p_t   cash flow c_t   value p_t c_t
----------------------------------------------------
      1     0.952381          100.00       95.238095
      2     0.907029          100.00       90.702948
      3     0.863838          100.00       86.383760
      4     0.822702          100.00       82.270247
      5     0.783526         1100.00      861.878783
----------------------------------------------------
PV via prices   = $1216.473834
max gap across the three routes = 2.27e-13   (tolerance 1e-10)
check passed: three routes, one number.

x = 1.0
history = [x]
for k in range(6):
    x = 0.5 * (x + 2 / x)
    history.append(x)
    print(f"k = {k}:  x = {x:.16f}   x^2 - 2 = {x ** 2 - 2:+.2e}")

k = 0:  x = 1.5000000000000000   x^2 - 2 = +2.50e-01
k = 1:  x = 1.4166666666666665   x^2 - 2 = +6.94e-03
k = 2:  x = 1.4142156862745097   x^2 - 2 = +6.01e-06
k = 3:  x = 1.4142135623746899   x^2 - 2 = +4.51e-12
k = 4:  x = 1.4142135623730949   x^2 - 2 = -4.44e-16
k = 5:  x = 1.4142135623730949   x^2 - 2 = -4.44e-16

root = math.sqrt(2)
eps = sys.float_info.epsilon

print(f"{'k':>3}{'e_k':>12}{'e_(k+1)/e_k^2':>17}{'1/(2 x_k)':>13}{'gap':>11}{'noise floor':>14}   ok")
print("-" * 75)
for k in range(len(history) - 1):
    e_k = history[k] - root
    floor = 2 * eps * root / e_k ** 2       # (12.3): precision of the measured ratio
    if floor > 1e-3:                        # below this error, the ratio is no longer measurable
        break
    ratio = (history[k + 1] - root) / e_k ** 2
    predicted = 1 / (2 * history[k])
    gap = abs(ratio - predicted)
    ok = gap <= floor
    print(f"{k:>3}{e_k:>12.2e}{ratio:>17.9f}{predicted:>13.9f}{gap:>11.1e}{floor:>14.1e}   {ok}")
    assert ok, f"at k={k} the observed rate departs from theory by more than rounding explains"

print("-" * 75)
print(f"check passed: e_(k+1) = e_k^2 / (2 x_k) holds to the rounding floor at every measurable step.")
print(f"limit of 1/(2 x_k) is 1/(2*sqrt(2)) = {1 / (2 * root):.9f}")

  k         e_k    e_(k+1)/e_k^2    1/(2 x_k)        gap   noise floor   ok
---------------------------------------------------------------------------
  0   -4.14e-01      0.500000000  0.500000000    8.3e-16       3.7e-15   True
  1    8.58e-02      0.333333333  0.333333333    3.2e-14       8.5e-14   True
  2    2.45e-03      0.352941176  0.352941176    3.9e-11       1.0e-10   True
  3    2.12e-06      0.353522385  0.353552860    3.0e-05       1.4e-04   True
---------------------------------------------------------------------------
check passed: e_(k+1) = e_k^2 / (2 x_k) holds to the rounding floor at every measurable step.
limit of 1/(2 x_k) is 1/(2*sqrt(2)) = 0.353553391

# your answer here

# your answer here

# your answer here

# your answer here

# your answer here

r_ex1, T_ex1 = 0.04, 25
continuous = math.exp(r_ex1 * T_ex1)
predicted_constant = 0.5 * r_ex1 ** 2 * T_ex1 * continuous

print(f"continuous limit e^(rT) = {continuous:.10f}")
print(f"predicted limit of n x error = r^2 T e^(rT) / 2 = {predicted_constant:.6f}\n")

print(f"{'n':>8}{'(1+r/n)^(nT)':>18}{'error':>12}{'n x error':>13}")
print("-" * 51)
for n in (1, 12, 365, 10_000):
    discrete = (1 + r_ex1 / n) ** (n * T_ex1)
    error = continuous - discrete
    print(f"{n:>8}{discrete:>18.10f}{error:>12.2e}{n * error:>13.6f}")
    last = n * error

rel_gap, tol = abs(last / predicted_constant - 1), 1e-3
print("-" * 51)
print(f"at n = 10000, |n x error / predicted - 1| = {rel_gap:.2e}   (tolerance {tol:.0e})")
assert rel_gap < tol, "the error does not decay at the predicted 1/n rate"
print("check passed: the error is O(1/n), with the predicted constant.")

continuous limit e^(rT) = 2.7182818285
predicted limit of n x error = r^2 T e^(rT) / 2 = 0.054366

       n      (1+r/n)^(nT)       error    n x error
---------------------------------------------------
       1      2.6658363315    5.24e-02     0.052445
      12      2.7137651579    4.52e-03     0.054200
     365      2.7181328965    1.49e-04     0.054360
   10000      2.7182763918    5.44e-06     0.054366
---------------------------------------------------
at n = 10000, |n x error / predicted - 1| = 9.71e-06   (tolerance 1e-03)
check passed: the error is O(1/n), with the predicted constant.

def annuity_loop(rate, horizon):
    # sum_{t=1}^{horizon} (1+rate)^{-t}, term by term
    total = 0.0
    for t in range(1, horizon + 1):
        total += (1 + rate) ** -t
    return total

def annuity_closed(rate, horizon):
    return (1 - (1 + rate) ** -horizon) / rate

print(f"{'r':>6}{'T':>6}{'loop':>16}{'closed form':>16}{'rel. gap':>12}")
print("-" * 56)
worst = 0.0
for r_ in (0.01, 0.05, 0.20):
    for T_ in (1, 5, 30, 200):
        a_loop, a_closed = annuity_loop(r_, T_), annuity_closed(r_, T_)
        rel = abs(a_loop - a_closed) / abs(a_closed)
        worst = max(worst, rel)
        print(f"{r_:>6.2f}{T_:>6}{a_loop:>16.10f}{a_closed:>16.10f}{rel:>12.1e}")

tol = 1e-12
print("-" * 56)
print(f"worst relative gap = {worst:.1e}   (tolerance {tol:.0e})")
assert worst < tol, "the closed form does not reproduce the summed series"
print("check passed.")

     r     T            loop     closed form    rel. gap
--------------------------------------------------------
  0.01     1    0.9900990099    0.9900990099     9.0e-16
  0.01     5    4.8534312393    4.8534312393     5.5e-16
  0.01    30   25.8077082213   25.8077082213     9.6e-16
  0.01   200   86.3313619478   86.3313619478     3.3e-16
  0.05     1    0.9523809524    0.9523809524     1.2e-15
  0.05     5    4.3294766706    4.3294766706     8.2e-16
  0.05    30   15.3724510269   15.3724510269     8.1e-16
  0.05   200   19.9988434346   19.9988434346     1.6e-15
  0.20     1    0.8333333333    0.8333333333     2.7e-16
  0.20     5    2.9906121399    2.9906121399     3.0e-16
  0.20    30    4.9789363988    4.9789363988     7.1e-16
  0.20   200    5.0000000000    5.0000000000     7.1e-16
--------------------------------------------------------
worst relative gap = 1.6e-15   (tolerance 1e-12)
check passed.

# The perpetuity limit
print(f"{'r':>6}{'A(r, 200)':>14}{'1/r':>14}{'gap':>10}")
print("-" * 44)
for r_ in (0.01, 0.05, 0.20):
    print(f"{r_:>6.2f}{annuity_closed(r_, 200):>14.6f}{1 / r_:>14.6f}"
          f"{abs(annuity_closed(r_, 200) - 1 / r_):>10.1e}")

     r     A(r, 200)           1/r       gap
--------------------------------------------
  0.01     86.331362    100.000000   1.4e+01
  0.05     19.998843     20.000000   1.2e-03
  0.20      5.000000      5.000000   8.9e-16

# The degenerate case r -> 0, where A(0, T) = T: which route survives?
print(f"{'r':>10}{'loop':>16}{'closed form':>16}{'error of closed':>18}")
print("-" * 60)
for r_ in (1e-4, 1e-8, 1e-12, 1e-15):
    a_loop, a_closed = annuity_loop(r_, 30), annuity_closed(r_, 30)
    print(f"{r_:>10.0e}{a_loop:>16.8f}{a_closed:>16.8f}{abs(a_closed - a_loop):>18.2e}")

print("-" * 60)
print("the loop degrades gracefully to A(0, 30) = 30; the closed form does not.")

         r            loop     closed form   error of closed
------------------------------------------------------------
     1e-04     29.95354956     29.95354956          3.69e-12
     1e-08     29.99999535     29.99999517          1.84e-07
     1e-12     30.00000000     30.00266702          2.67e-03
     1e-15     30.00000000     33.30669074          3.31e+00
------------------------------------------------------------
the loop degrades gracefully to A(0, 30) = 30; the closed form does not.

c_t = [-1000, 200, 300, 400, 500]

def g(rate):
    return sum(c / (1 + rate) ** t for t, c in enumerate(c_t))

def g_prime(rate):
    return sum(-t * c / (1 + rate) ** (t + 1) for t, c in enumerate(c_t))

# --- route 1: Newton
r_newton = 0.05
for iteration in range(100):
    step = g(r_newton) / g_prime(r_newton)
    r_newton -= step
    if abs(step) < 1e-14:
        break
print(f"Newton:    IRR = {r_newton:.12f}   after {iteration + 1} iterations")

# --- route 2: bisection on a bracket, derivative-free
lo, hi = 0.0, 1.0
assert g(lo) > 0 > g(hi), "the bracket does not contain a sign change"
for _ in range(200):
    mid = 0.5 * (lo + hi)
    if g(mid) > 0:
        lo = mid
    else:
        hi = mid
r_bisect = 0.5 * (lo + hi)
print(f"bisection: IRR = {r_bisect:.12f}")

gap, tol = abs(r_newton - r_bisect), 1e-12
print(f"\n|Newton - bisection| = {gap:.2e}   (tolerance {tol:.0e})")
assert gap < tol, "two independent methods disagree on the root"
print(f"residual |g(IRR)|    = {abs(g(r_newton)):.2e}   (machine rounding on a PV of order 1e3)")
print(f"check passed: IRR = {100 * r_newton:.4f}% per period.")

Newton:    IRR = 0.128257269002   after 6 iterations
bisection: IRR = 0.128257269002

|Newton - bisection| = 1.67e-16   (tolerance 1e-12)
residual |g(IRR)|    = 8.53e-14   (machine rounding on a PV of order 1e3)
check passed: IRR = 12.8257% per period.

c_t = [100, 100, 100, 100, 100 + 1000]
nbt = len(c_t)
r = 0.05

def pv(rate):
    return sum(c / (1 + rate) ** (t + 1) for t, c in enumerate(c_t))

p_t = [(1 + r) ** -(t + 1) for t in range(nbt)]
PV = pv(r)
duration = sum((t + 1) * p_t[t] * c_t[t] for t in range(nbt)) / PV

print(f"PV       = ${PV:.6f}")
print(f"duration = {duration:.6f} years   (maturity is {nbt} years)\n")

print(f"{'date t':>7}{'p_t c_t':>13}{'share of PV':>14}")
print("-" * 34)
for t in range(nbt):
    print(f"{t + 1:>7}{p_t[t] * c_t[t]:>13.4f}{p_t[t] * c_t[t] / PV:>14.2%}")

PV       = $1216.473834
duration = 4.253499 years   (maturity is 5 years)

 date t      p_t c_t   share of PV
----------------------------------
      1      95.2381         7.83%
      2      90.7029         7.46%
      3      86.3838         7.10%
      4      82.2702         6.76%
      5     861.8788        70.85%

# verify dPV/dr = -D PV / (1+r) against a central difference
h = 1e-5
fd = (pv(r + h) - pv(r - h)) / (2 * h)
analytic = -duration * PV / (1 + r)

rel_gap, tol = abs(fd - analytic) / abs(analytic), 1e-6
print(f"central difference (h = {h:.0e}) = {fd:.6f}")
print(f"-D PV / (1+r)                  = {analytic:.6f}")
print(f"relative gap = {rel_gap:.2e}   (tolerance {tol:.0e})")
assert rel_gap < tol, "the duration relation does not reproduce the numerical derivative"
print("check passed.")

central difference (h = 1e-05) = -4927.876361
-D PV / (1+r)                  = -4927.876358
relative gap = 5.88e-10   (tolerance 1e-06)
check passed.

print(f"{'N':>10}{'estimate of pi':>18}{'error':>12}{'N x error':>12}")
print("-" * 52)
for N in (10, 10 ** 3, 10 ** 5, 10 ** 7):
    s = 0.0
    for k in range(N):
        s += (-1) ** k / (2 * k + 1)
    pi_est = 4 * s
    error = abs(math.pi - pi_est)
    print(f"{N:>10}{pi_est:>18.10f}{error:>12.2e}{N * error:>12.6f}")
    last_product = N * error

gap, tol = abs(last_product - 1.0), 1e-3
print("-" * 52)
print(f"|N x error - 1| = {gap:.2e} at N = 1e7   (tolerance {tol:.0e})")
assert gap < tol, "the error does not decay at the predicted 1/N rate"
print("check passed: the error is asymptotically 1/N.")

         N    estimate of pi       error   N x error
----------------------------------------------------
        10      3.0418396189    9.98e-02    0.997530
      1000      3.1405926538    1.00e-03    1.000000
    100000      3.1415826536    1.00e-05    1.000000

  10000000      3.1415925536    1.00e-07    1.000000
----------------------------------------------------
|N x error - 1| = 1.61e-08 at N = 1e7   (tolerance 1e-03)
check passed: the error is asymptotically 1/N.

# how many terms for ten correct digits?
target = 0.5e-10                      # error below half a unit in the tenth decimal
terms = 1 / target
rate = 1e7                            # terms per second, roughly, in pure Python
print(f"error ~ 1/N, so ten correct digits needs N ~ {terms:.0e} terms.")
print(f"at roughly {rate:.0e} terms per second that is about {terms / rate / 60:.0f} minutes of arithmetic,")
print("for a constant already known to more than 1e5 digits by better methods.")

error ~ 1/N, so ten correct digits needs N ~ 2e+10 terms.
at roughly 1e+07 terms per second that is about 33 minutes of arithmetic,
for a constant already known to more than 1e5 digits by better methods.

Path	Best for	Setup cost	Notes
A. Google Colab	getting going briefly, Chromebooks, no admin rights	none	notebooks run on Google's servers; needs a Google account and a network
B. Local (Miniforge)	doing real work, running offline, reproducibility	~10 min once	the environment you will actually use for research
C. VS Code + Jupyter	people who like an editor and integrated Git	~15 min once	uses a local Python (Path B) underneath

Symptom	Likely cause	Fix
`ModuleNotFoundError: No module named 'numpy'`	wrong or empty environment selected	activate `mec` (Path B), or pick the `mec` kernel in VS Code; on Colab, `!pip install numpy`
Notebook "runs" but the values look wrong	out-of-order execution	Restart & Run All
`jupyter: command not found`	environment not activated	`conda activate mec`, then `jupyter lab`
Kernel keeps dying on a large cell	out of memory (often on Colab)	restart the kernel; reduce sample sizes; use a local machine for heavy notebooks
A cell needs a package you do not have	later lectures add dependencies	install per §2.2 and §4; each notebook lists what it needs at the top

Type	Examples	Notes
`int`	`42`, `-1`, `0`, `2**100`	arbitrary precision
`float`	`3.14`, `1e-9`, `math.inf`	IEEE 754 double
`str`	`"hello"`, `'mec'`, `f"x={x}"`	immutable, Unicode
`bool`	`True`, `False`	technically a subclass of `int`
`NoneType`	`None`	the unique sentinel

Python setup and fundamentals¶

Alfred Galichon (NYU)¶

'math+econ+code' masterclass series: fundamentals of research in python¶

With python code examples¶

Learning objectives¶

References¶

1. Motivation and scope¶

2. Three ways to run these notebooks¶

2.1 Path A: Google Colab (fastest start)¶

2.2 Path B: Local install with Miniforge (recommended)¶

2.3 Path C: VS Code + the Jupyter extension¶

2.4 Getting the notebooks¶

3. A brief overview of cells and kernels¶

4. Verifying your environment¶

5. Numbers and expressions¶

6. Types and variables¶

7. Booleans, comparisons, and truthiness¶

8. Control flow: `if` / `elif` / `else`¶

9. Control flow: `while` and `for`¶

10. Worked example: present value of a cash-flow stream¶

11. Discount factors are prices: the first dual object of the series¶

12. Worked example: Newton's method¶

13. Five common traps¶

14. Summary¶

15. Exercises¶

16. Further directions¶

17. Solutions to the exercises¶

Solution to Exercise 1: Compound interest and the continuous limit¶

Solution to Exercise 2: The annuity formula¶

Solution to Exercise 3: Internal rate of return¶

Solution to Exercise 4: Duration as a derivative of the valuation¶

Solution to Exercise 5: Leibniz's series for $\pi$¶

Python setup and fundamentals¶

Alfred Galichon (NYU)¶

'math+econ+code' masterclass series: fundamentals of research in python¶

With python code examples¶

Learning objectives¶

References¶

1. Motivation and scope¶

2. Three ways to run these notebooks¶

2.1 Path A: Google Colab (fastest start)¶

2.2 Path B: Local install with Miniforge (recommended)¶

2.3 Path C: VS Code + the Jupyter extension¶

2.4 Getting the notebooks¶

3. A brief overview of cells and kernels¶

4. Verifying your environment¶

5. Numbers and expressions¶

6. Types and variables¶

7. Booleans, comparisons, and truthiness¶

8. Control flow: if / elif / else¶

9. Control flow: while and for¶

10. Worked example: present value of a cash-flow stream¶

11. Discount factors are prices: the first dual object of the series¶

12. Worked example: Newton's method¶

13. Five common traps¶

14. Summary¶

15. Exercises¶

16. Further directions¶

17. Solutions to the exercises¶

Solution to Exercise 1: Compound interest and the continuous limit¶

Solution to Exercise 2: The annuity formula¶

Solution to Exercise 3: Internal rate of return¶

Solution to Exercise 4: Duration as a derivative of the valuation¶

Solution to Exercise 5: Leibniz's series for $\pi$¶

8. Control flow: `if` / `elif` / `else`¶

9. Control flow: `while` and `for`¶