Code you will read every day

Ask a chatbot to analyse a portfolio, and the answer will look like the script on the left: data inside data, loops squeezed into one line, a function with no name.

Nothing on the left is new in principle: dicts, lists, loops and functions from sessions 3 and 4. What is new is how compactly they are written.

Today's goal is not to write this style fluently. It is to read it, calmly, piece by piece.

Today: three scripts, one ledger

1. Nested data: data inside data
2. Comprehensions: loops in one line
3. lambda and other one-line tricks
4. numpy, properly: grids of numbers
5. pandas, properly: tables with names

Parts 1–3 use the script on the left. numpy and pandas each get a script of their own. All three value the same ledger.

Read it cold

Two minutes, on your own.

• Line 7 has three pairs of square brackets. What does each one pick?
• Lines 10 and 11 contain the word for, but no indented block. What might they do?
• Guess what line 16 prints.

What it prints

You do not need to run anything now. Bottom left is the output of one run.

Seven lines. Session 3's numbers are all here: NESN at 102.3, the values 1905.0, 409.2 and 1024.0, and their total, 3338.2.

The same ledger, written the way experienced programmers, and AI assistants, write it.

Data inside data

Lines 2–6 build one value: a dict whose values are dicts, one of which holds a list.

Read it as a tree. Each level is a collection you already know, with its own way of looking things up.

Reading a chain of look-ups

Read from left to right. Each [ ] is applied to what the previous one returned:

At every step, ask: what type do I have now? The type decides what the next bracket may contain.

Slicing at the end of a chain

A chain can end in a slice instead of an index. Line 8 takes AAPL's prices from day 1 onwards: [188.2, 190.5].

Everything from session 3 works at the end of a chain: [-1], [1:], [::-1], len(...), sum(...).

sum(ledger["VOO"]["prices"]) adds VOO's three prices; len(ledger["AAPL"]["prices"]) is 3.

A wrong key, deep inside

Line 7 now asks for "price": the key is "prices". The traceback's carets point at which bracket failed: the second one.

KeyError: 'price' names the key that is missing. With nested data, check each level: print(ledger.keys()), then print(ledger["NESN"].keys()).

Looping over nested data

.items() (session 3) gives each key with its value. Here each value is itself a dict:

Inside the loop, d["prices"][-1] is one position's last price. Line 10 does this for every position, in one line: Part 2.

The accumulator pattern, squeezed

Session 3's "collect" pattern, and line 11, do the same thing:

Same loop (blue), same value for each item (gold). The comprehension drops values = [] and .append: the square brackets are the new list.

Prove it: the loop version on the left

Lines 11–13 now build values the long way, with a loop and .append. Output line 4 is unchanged, and line 16 confirms it: True.

Any comprehension can be rewritten as a loop, and back. When a comprehension confuses you, rewrite it as a loop in your head, or on paper.

How to read a comprehension

1. Find for. Read from for to the end: "for each ticker t and inner dict d in the ledger…"
2. Go back to the start: "…keep d["shares"] * last[t]."
3. Look at the brackets: [ ] makes a list.

Say it in one sentence: "the value of each position, as a list."

A comprehension with a filter

An if at the end keeps only the items that pass. Sentence: "the tickers whose last price is above their first."

NESN went from 104.1 to 102.3, so it is left out. The comprehension also runs over two lines: inside brackets, that is allowed (session 3).

A dict comprehension

Curly brackets and a key: value pair make a dict. Sentence: "each ticker, with its last price."

A nested ledger in, a flat dict out: the most common job of a comprehension in data code.

Three kinds of comprehension

The brackets tell you what comes out, before you read anything else.

sum(x * 2 for x in shares), with no brackets of its own, feeds the values straight into sum. You will see this often; read it like a list comprehension.

lambda: a function in one expression

lambda p: … is a small function: parameters before the colon, one expression after it, returned automatically. No def, no name, no return.

Line 21 gives it a name anyway, change, and line 22 calls it like any function: each position's change from first to last price.

Same function, written with def

Line 21 now uses def. Output line 7 is unchanged.

A lambda can only hold one expression: no loops, no if blocks, no several lines. Anything bigger needs def.

Style guides (PEP 8, session 2) prefer def when you give the function a name, as here. Lambdas are for the place where they shine: the next slide.

Sorting the ledger: alphabetically

We want to put our positions in order. The simplest order needs nothing extra: line 18, sorted(ledger), sorts the keys, the tickers, as text: A, N, V.

sorted knows how to compare text and numbers by itself. But "alphabetical" is rarely the order we care about. We would rather sort by shares, or by value.

For that, sorted needs to be told how to turn each ticker into something to compare. It asks us for a function.

By number of shares: a function as input

Line 17 defines a small function: given a ticker, it returns its number of shares. Line 18 hands that function to sorted: key=n_shares.

Some functions take other functions as input. key=n_shares has no parentheses: we pass the function itself (session 4), and sorted calls it, once per ticker.

By value: define how to compute it

Now the order we really want: by the value of each position. That number is not stored anywhere, so we define how to find it (line 17), then pass that function to sorted (line 18):

Same sorted, a different function, a different order. sorted does the sorting; we decide what it sorts by.

The same, with a lambda

value is used once, and it is one short expression. Writing a def, and a name, for it is clumsy. The original lines 18–19 write the function right where it is passed:

key=value                                      the named function
key=lambda t: ledger[t]["shares"] * last[t]    the same function, inline

This is what lambdas are for: a short function passed as an argument. Longer, or used in several places: write a def and pass its name.

Where lambdas appear: max and min

max and min take the same key= as sorted: a function saying what to compare.

• max(ledger) alone would compare the tickers as text: "VOO".
• max(ledger, key=lambda t: last[t]) compares their last prices: VOO, at 512.0. min gives NESN.

Read the lambda as "for one ticker t: its last price", and the call as "the ticker with the highest one".

Where lambdas appear: sorting pairs

last.items() gives (ticker, price) pairs (session 3). Sorted as they are, pairs compare by their first part, the ticker.

key=lambda kv: kv[1] says: compare by the second part, the price. kv is just a name for one pair ("key, value"). You will see lambda x: x[1] constantly in AI-generated code: it almost always means "by the second element".

Where lambdas appear: filter

filter(f, items) keeps the items for which f returns True. Here the function is a lambda that asks one question per ticker: is its last price above 150?

filter gives back its results one by one; list(...) collects them into a list.

It does the same as a comprehension with an if (Part 2): [t for t in ledger if last[t] > 150], usually easier to read.

Once the prices are a numpy array or a pandas column, there is a nicer way still: a boolean mask, prices[prices > 150]. We will see it later today (Parts 4–5). A plain dict has no masks.

Where lambdas appear: pandas (a preview)

A glimpse ahead: in pandas (Part 5), .apply takes a function and calls it on every value of a column. Lines 15–16 pass it a lambda.

Ignore the pandas details for now; read only the lambda: "for one value v: "large" if above 1500, otherwise "small"." Part 5 shows what .apply does with it.

Everywhere, the pattern is the same: a function that expects a function, and a short lambda written right there.

if … else inside an expression

Line 21 now returns "up" or "down". The decision sits inside one expression:

This is a conditional expression. It gives a value, so it fits where if blocks cannot: in a lambda, a comprehension, a function argument. Read it middle first: the condition, then which side wins.

Reading compact code: a checklist

Say each line in one English sentence before you move on. If you cannot, slow down: rewrite it as a loop, or as a def.

What numpy adds to Python

In short: numpy turns Python into a language for computing with large amounts of numbers. Almost every scientific and data library, pandas included, is built on top of it.

An array with rows and columns

A new script on the left. Lines 4–6 turn a list of lists into a two-dimensional array: one row per position, one column per day.

• shape is (3, 3): 3 rows, 3 columns.
• dtype is float64: every element has the same type (session 3).
• ndim is 2: two directions to index in.

What shape means

shape lists how many elements lie along each direction. One number per direction, in a tuple:

Same three numbers, three different shapes. (3,) has no rows and no columns, just one direction; the comma only marks it as a tuple. (3, 1) is a real column: shares[:, None] adds the second direction.

Shapes decide how arrays combine (broadcasting, later). When numpy surprises you, print the .shape first.