Glossary

SELECT age, AVG(grade) AS avg_grade, COUNT(*) AS n
FROM students
GROUP BY age
HAVING COUNT(*) > 1;

def is_prime(n):
    return n > 1 and all(n % d for d in range(2, int(n ** 0.5) + 1))

print([n for n in range(20) if is_prime(n)])

import json, urllib.request

with urllib.request.urlopen("https://api.example.com/books/1") as r:
    book = json.load(r)   # the API answers with JSON
print(book["title"])

def greet(name, greeting="Hello"):   # parameters
    return f"{greeting}, {name}!"

greet("Ada", greeting="Hi")           # arguments

scores = [90, 85, 77]      # a Python list
scores.append(100)
print(scores[0], len(scores))

const double = n => n * 2
const add = (a, b) => a + b
[1, 2, 3].map(n => n * n)

def split_bill(total, people):
    assert people > 0, "need at least one person"
    return total / people

import asyncio

async def fetch(name, delay):
    await asyncio.sleep(delay)
    return name

async def main():
    print(await asyncio.gather(fetch("a", 0.2), fetch("b", 0.1)))

asyncio.run(main())

# O(n): one pass
total = sum(numbers)

# O(n^2): a pass inside a pass
pairs = [(a, b) for a in numbers for b in numbers]

# O(log n): halving each step
import bisect
i = bisect.bisect_left(sorted_numbers, 42)

is_open = 9 <= hour < 17
print(type(is_open), is_open and not holiday)

git switch -c feature/search
# ...work, commit...
git switch main
git merge feature/search

for n in range(10):
    if n == 7:
        break        # stop the whole loop
    if n % 2:
        continue     # skip odd numbers
    print(n)         # 0 2 4 6

from functools import cache

@cache
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(90))   # instant: each n computed once

button.addEventListener('click', () => {
  console.log('clicked')   // this arrow function is the callback
})
setTimeout(() => console.log('later'), 500)

class Account:
    def __init__(self, owner):
        self.owner = owner
        self.balance = 0

    def deposit(self, amount):
        self.balance += amount

acct = Account("Ada")   # an instance
acct.deposit(50)

def make_counter():
    count = 0
    def bump():
        nonlocal count
        count += 1
        return count
    return bump

c = make_counter()
print(c(), c())   # 1 2 — count lives on inside bump

git add .
git commit -m "Add the search page"
git log --oneline

squares = [n * n for n in range(10) if n % 2 == 0]
lengths = {w: len(w) for w in ["apple", "banana"]}

const limit = 10      // cannot be reassigned
let count = 0         // can
count += 1

.card { padding: 1rem; border-radius: 8px; }
.card h1 { color: darkred; font-family: Georgia, serif; }

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

print(Point(1, 2) == Point(1, 2))   # True, for free

import functools

def shout(func):
    @functools.wraps(func)
    def wrapper(*a, **kw):
        return func(*a, **kw).upper()
    return wrapper

@shout
def greet(name):
    return f"hello {name}"

print(greet("sam"))   # HELLO SAM

def hypotenuse(a, b):
    return (a ** 2 + b ** 2) ** 0.5

const { host, port = 8080, ...rest } = config
const [first, ...others] = list

ages = {"Sam": 32, "Maya": 28}
ages["Leo"] = 41
print(ages.get("Ada", "unknown"), list(ages))

def area(r):
    """Return the area of a circle of radius r."""
    return 3.14159 * r * r

print(area.__doc__)

const h1 = document.querySelector('h1')
h1.textContent = 'Changed by JavaScript'
document.body.append(document.createElement('p'))

def total_length(items):
    return sum(len(x) for x in items)   # anything with len() works

print(total_length(["hello", [1, 2], {"a": 1}]))

for i, name in enumerate(["Ada", "Sam"], start=1):
    print(i, name)

echo $HOME
export EDITOR=nano
env | grep EDITOR

console.log('one')
setTimeout(() => console.log('three'), 0)
console.log('two')   // the timeout waits for the loop to come round

try:
    n = int("forty")
except ValueError as e:
    print("bad number:", e)
finally:
    print("always runs")

ls /nope
echo $?          # 2
make && ./run    # run only if make succeeded

name, price = "notebook", 24.5
print(f"{name:<10}{price:>8.2f}")
print(f"{name=}")

def area(width, height=1):
    """Return the area of a rectangle."""
    return width * height

print(area(3, 4), area(5))

def countdown(n):
    while n > 0:
        yield n
        n -= 1

print(list(countdown(3)))   # [3, 2, 1]

function firstOr<T>(items: T[], fallback: T): T {
  return items.length ? items[0] : fallback
}
firstOr([1, 2], 0)          // T is number
firstOr([], 'none')         // T is string

def make_counter():
    count = 0
    def bump():
        nonlocal count
        count += 1
        return count
    return bump

greet()                // works: function declarations are hoisted
function greet() { console.log('hi') }

console.log(x)         // undefined, not an error, because of var hoisting
var x = 1

<article>
  <h1>Hello, world</h1>
  <p>Read the <a href="/about">about page</a>.</p>
</article>

GET /books/1 HTTP/1.1
Host: api.example.com

HTTP/1.1 200 OK
Content-Type: application/json

{"title": "The Hobbit"}

s = "hello"
t = s.upper()      # a new string; s is unchanged
point = (3, 4)
# point[0] = 5  -> TypeError: tuples cannot be changed

if hour < 12:
    print("good")        # inside the if
    print("morning")
print("always")          # outside

names = ["Ada", "Sam"]
print(names[0], names[-1])   # positions count from 0

-- SQL: CREATE INDEX idx_email ON users(email);

interface Person {
  name: string
  age: number
  skills?: string[]
}
const ada: Person = { name: 'Ada', age: 36 }

it = iter(["red", "blue"])
print(next(it))   # red
print(next(it))   # blue
# next(it) -> StopIteration

SELECT s.name, c.name AS course, e.score
FROM enrollments e
JOIN students s ON s.id = e.student_id
JOIN courses  c ON c.id = e.course_id;

import json
text = '{"name": "Maya", "books": 3, "member": true}'
data = json.loads(text)
print(data["books"], json.dumps(data, indent=2))

def order(item, qty=1, gift_wrap=False):
    ...

order("candles", gift_wrap=True)   # qty keeps its default

people = [("Sam", 41), ("Maya", 28)]
people.sort(key=lambda p: p[1])
print(people)

scores = [23, 51, 100]
scores.append(150)
print(scores[0], scores[-1], scores[1:3])

for word in ["one", "two", "three"]:
    print(word)

n = 3
while n > 0:
    n -= 1

class Dog:
    def bark(self, times=1):
        return "woof " * times

print(Dog().bark(3))   # Dog().bark is a method

import math
from datetime import date

print(math.sqrt(2), date.today().year)

a = [1, 2]
b = a           # same list, two names
b.append(3)
print(a)        # [1, 2, 3] — a changed too

import math
import statistics

math.sqrt(9)          # sqrt lives in the math namespace
statistics.mean([1, 2])

function describe(v: string | number) {
  if (typeof v === 'string') return v.toUpperCase()   // v is string here
  return v.toFixed(2)                                  // v is number here
}

result = None
if result is None:
    print("nothing yet")

# JavaScript: let x = null; let y;  // y is undefined

SELECT name FROM students WHERE email IS NULL;
SELECT COALESCE(email, 'no email') FROM students;

pip install requests
pip freeze > requirements.txt

npm install express
npm ci   # exact versions from package-lock.json

class Placeholder:
    pass

def todo():
    pass

cat data/team.csv | cut -d , -f 2 | sort | uniq -c

CREATE TABLE students (
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL
);
CREATE TABLE enrollments (
  student_id INTEGER REFERENCES students(id)
);

const wait = ms => new Promise(resolve => setTimeout(resolve, ms))

async function main() {
  await wait(100)
  console.log('done')
}
main()

class Circle:
    def __init__(self, r):
        self.r = r

    @property
    def area(self):
        return 3.14159 * self.r ** 2

print(Circle(2).area)   # no parentheses

class Dog { bark() { return 'woof' } }
const d = new Dog()
console.log(Object.getPrototypeOf(d) === Dog.prototype)   // true

def factorial(n):
    if n <= 1:          # base case
        return 1
    return n * factorial(n - 1)

print(factorial(5))

ls -l > files.txt
echo "done" >> files.txt
cat missing 2> errors.log
sort < names.txt

import re
print(re.findall(r"\d{4}-\d{2}-\d{2}", "joined 2024-01-15, left 2026-05-26"))

def sign(n):
    if n < 0:
        return "negative"
    return "non-negative"   # unreachable when n < 0

total = 0            # module scope

def add(n):
    result = total + n   # result is local to add
    return result

print(add(5))
# print(result) -> NameError: only exists inside add

class Person:
    def __init__(self, name):
        self.name = name         # store on this instance

    def greet(self):
        return f"Hi, {self.name}"

Person("Ada").greet()   # Python passes the instance as self

design = {"Ada", "Maya", "Leo"}
support = {"Maya", "Sam"}
print(design & support, design | support, "Ada" in design)

ls -l | grep ".txt" | wc -l
echo "$HOME"
cat missing.txt 2> errors.log

s = "programming"
print(s[0:7], s[-3:], s[::2], s[::-1])

const merged = { ...defaults, ...overrides }   // spread
function sum(...nums) {                          // rest
  return nums.reduce((t, n) => t + n, 0)
}

SELECT name, grade
FROM students
WHERE age = 17
ORDER BY grade DESC
LIMIT 3;

stack = []
stack.append("a")   # push
stack.append("b")
print(stack.pop())    # b — last in, first out

import json, re, datetime, pathlib, collections, itertools, statistics
print(statistics.median([3, 1, 2]))

console.log(0 == '', 0 === '')       // true false
console.log(null == undefined, null === undefined)   // true false

name = "Maya"
print(name.upper(), name[0], len(name), f"{name} from Leeds")

WITH big AS (
  SELECT customer_id FROM orders WHERE total > 500
)
SELECT name FROM customers WHERE id IN (SELECT customer_id FROM big);

const name = 'Maya'
console.log(`${name} has ${2 + 3} books`)

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
# run with: pytest

const timer = {
  ticks: 0,
  start() { setTimeout(() => this.ticks++, 10) }   // arrow keeps this
}

BEGIN TRANSACTION;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;

point = (3, 4)
x, y = point                 # unpacking
def min_max(xs):
    return min(xs), max(xs)  # returns a tuple

print(type(42), type("42"), type([]))

def double(n: int) -> int:   # a type hint
    return n * 2

def total(prices: list[float], tax: float = 0.0) -> float:
    return sum(prices) * (1 + tax)

type Payment =
  | { kind: 'card'; last4: string }
  | { kind: 'cash' }

function label(p: Payment) {
  return p.kind === 'card' ? `Card ${p.last4}` : 'Cash'
}

pages = 12
pages = pages + 3     # rebind the name to a new value
name, age = "Maya", 28   # two at once

python3 -m venv .venv
source .venv/bin/activate    # Windows: .venv\Scripts\activate
pip install requests
pip freeze > requirements.txt

SELECT name, department, salary,
       RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank
FROM employees;

with open("notes.txt") as f:
    text = f.read()
# f is closed here, even if read() raised

def evens():
    n = 0
    while True:
        yield n
        n += 2

g = evens()
print(next(g), next(g), next(g))