Lists, tuples, dictionaries, sets and comprehensions.

Collections: many pieces of data under one name

So far each variable held one piece of data: a price, a quantity, a ticker (lessons 0.3.1 and 0.3.2). A trading program almost always works with many: the closes of a month, the assets being watched, the positions of a portfolio, the components of an index. Python has four built-in collections to hold them, and each one meets a different need:

Lists: series and watchlists

A list is an ordered sequence of values between square brackets. It is indexed and sliced exactly like a string (lesson 0.3.2): the first element is [0], the last [-1], and [inicio:fin] returns a new list with that stretch. SINT's closes for the second half of December 2025 (from the file sint_diario.csv, link in “Resources”) are a list of floats:

cierres = [146.36, 145.13, 144.22, 143.66, 139.91, 139.43,
           139.36, 139.32, 139.23, 139.56, 139.98, 142.22]
print(len(cierres), cierres[0], cierres[-1])
print(cierres[-3:])
print(max(cierres), min(cierres))
print(sum(cierres) / len(cierres))

12 146.36 142.22
[139.56, 139.98, 142.22]
146.36 139.23
141.53166666666667

len, max, min and sum work with any collection of numbers. cierres[-3:] are the last three closes, and the last line is the mean of the series. Along the same lines, cierres[-20:] would give the last twenty sessions of a longer series: that is how the computation of a moving average starts.

Unlike strings, lists are modifiable. Their methods change the list itself and return nothing (they return None). A watchlist, the list of assets being watched, is the natural example:

watchlist = ["SINT", "RVAR", "ORO"]
watchlist.append("TECH")      # appends at the end
watchlist.insert(0, "RFIJ")   # inserts at a position
watchlist.remove("ORO")       # removes by value
ultimo = watchlist.pop()      # removes and returns the last one
print(watchlist, ultimo)

watchlist.sort()
print(watchlist, "SINT" in watchlist, watchlist.index("SINT"))
print(sorted(cierres)[:3])

['RFIJ', 'SINT', 'RVAR'] TECH
['RFIJ', 'RVAR', 'SINT'] True 2
[139.23, 139.32, 139.36]

sort() sorts the list in place; sorted() returns a new sorted list and leaves the original as it was. The difference matters with a price series: sorting the closes in place destroys the time order, and with it any return calculation that comes after. For a time series, sorted, never sort.

The most common trap with lists is this one: assigning a list to another name does not copy it. Both names point to the same list, and whatever is done through one is seen in the other.

pendientes = ["SINT", "ORO"]
para_enviar = pendientes          # the same object
para_enviar.append("TECH")
print(pendientes)

copia = pendientes.copy()         # a new object
copia.clear()
print(pendientes, copia)
print(para_enviar is pendientes, copia is pendientes)

['SINT', 'ORO', 'TECH']
['SINT', 'ORO', 'TECH'] []
True False

The is operator asks whether two names point to the same object. In an order system, this error has consequences: a script that “empties the copy” of the pending order list after sending them may be emptying the original. The same trap shows up again with the default arguments of functions (lesson 0.3.5).

Tuples: an OHLC bar

A tuple is a sequence like a list, but immutable: once created, it cannot be changed. It is written between parentheses, or simply with commas. It is the right structure for a record with a fixed number of fields that must not change, such as a price bar: open, high, low and close (OHLC).

barra = ("2025-12-31", 140.01, 143.40, 139.67, 142.22)
fecha, apertura, maximo, minimo, cierre = barra
print(fecha, cierre)
print(f"Range: {maximo - minimo:.2f}  Body: {cierre - apertura:+.2f}")
print(barra[1:])

2025-12-31 142.22
Range: 3.73  Body: +2.21
(140.01, 143.4, 139.67, 142.22)

The second line is unpacking: a tuple (or any sequence) is distributed over as many variables as it has elements. It is what base, cotizada = "EUR", "USD" did in lesson 0.3.2: on the right there was a tuple without parentheses. If the number of variables does not match the number of elements, Python raises an error.

Immutability is a guarantee: a historical bar should not change, and a tuple does not let it (barra[4] = 150.0 raises an error). A bar that could be modified by accident would be falsified historical data in the middle of a backtest.

Dictionaries: portfolio and prices by ticker

A dictionary maps keys to values. It is written between braces with clave: valor pairs, and it is looked up by key, not by position. A portfolio is a dictionary of ticker → shares; prices, another of ticker → last close (those of SINT and of the assets in cartera_sint.csv on December 31, 2025):

cartera = {"SINT": 100, "ORO": 20, "RFIJ": 150}
precios = {"SINT": 142.22, "ORO": 171.44, "RFIJ": 102.29,
           "TECH": 77.82}

print(cartera["SINT"], len(cartera), "TECH" in cartera)
cartera["TECH"] = 30          # open a position
cartera["ORO"] += 10          # increase a position
del cartera["RFIJ"]           # close a position
print(cartera)
print(list(cartera.keys()), list(cartera.values()))

100 3 False
{'SINT': 100, 'ORO': 30, 'TECH': 30}
['SINT', 'ORO', 'TECH'] [100, 30, 30]

Assigning to a key that does not exist creates it; assigning to one that exists replaces its value. in asks about the keys, not the values. Since Python 3.7, dictionaries preserve the order in which the keys were inserted.

To value the portfolio you have to go through it. items() gives the key-value pairs, and the for loop (lesson 0.3.4) processes them one by one:

valor_total = 0.0
for ticker, acciones in cartera.items():
    valor = acciones * precios[ticker]
    valor_total += valor
    print(f"{ticker:<5} {acciones:>4} x {precios[ticker]:>7.2f}"
          f" = {valor:>9,.2f}")
print(f"{'Total':<22}{valor_total:>9,.2f}")

SINT   100 x  142.22 = 14,222.00
ORO     30 x  171.44 =  5,143.20
TECH    30 x   77.82 =  2,334.60
Total                 21,699.80

Reading a key that does not exist with square brackets is an error (KeyError), and in trading it happens often: a ticker with no price that day, a misspelled symbol. If the absence is normal and has a reasonable value, get gives it without an error:

print(cartera.get("SINT", 0), cartera.get("BTC", 0))
print(precios.get("BTC"))

100 0
None

Without a second argument, get returns None. Be careful not to use it to cover up errors: a portfolio that holds no BTC holds 0 BTC, but a missing price is not a price of 0. Valuing a position at a price of 0 makes it disappear from the portfolio's value without any warning. When it is better to let the error happen and how to handle it is covered in lesson 0.3.6.

Sets: the universe of an index

A set is a collection of unique elements with no order, written between braces without pairs. It is used for two things: removing duplicates and doing set operations, which are exactly the questions asked about the universe of an index. The components of an index change over time: companies that have grown join, and those that have fallen, merged or gone bankrupt leave.

The example uses a fictional index with six components at two dates:

universo_2024 = {"ALFA", "BETA", "GAMMA", "DELTA", "SIGMA", "OMEGA"}
universo_2025 = {"ALFA", "BETA", "DELTA", "SIGMA", "KAPPA", "LAMBDA"}

altas = universo_2025 - universo_2024
bajas = universo_2024 - universo_2025
siguen = universo_2024 & universo_2025
alguna_vez = universo_2024 | universo_2025
print("Additions:", sorted(altas))
print("Deletions:", sorted(bajas))
print("Remain:", len(siguen), " Ever:", len(alguna_vez))
print("Changes:", sorted(universo_2024 ^ universo_2025))

Additions: ['KAPPA', 'LAMBDA']
Deletions: ['GAMMA', 'OMEGA']
Remain: 4  Ever: 8
Changes: ['GAMMA', 'KAPPA', 'LAMBDA', 'OMEGA']

Sets have no order, so print would show them in any order; sorted turns them into a sorted list so that the output is always the same.

The deletions line is the one that matters most in trading. If a backtest of the last ten years uses only today's components, it never buys GAMMA or OMEGA: the companies that left, often after falling, are not on the list. The backtest only sees the survivors and comes out better than it really would have been. This is survivorship bias, and the only remedy is to use the universe that existed at each date, alguna_vez included:

The other use of sets is removing duplicates. The symbols traded in a trade log repeat; set keeps each one once:

simbolos_operados = ["ORO", "SINT", "SINT", "SINT", "ORO", "TECH"]
unicos = set(simbolos_operados)
print(sorted(unicos), len(unicos))

['ORO', 'SINT', 'TECH'] 3

Comprehensions: returns in one line

A comprehension builds a collection from another one in a single expression: [expression for element in collection]. It reads almost like a sentence: “the expression, for each element of the collection”. It is the idiomatic way to transform a series.

A day's return is $r_t = P_t / P_{t-1} - 1$: it needs each close and the previous one. zip pairs the elements of two collections; if you pass it the series and the series shifted by one position (cierres[1:]), each pair is (previous close, close of the day):

rentabilidades = [c1 / c0 - 1
                  for c0, c1 in zip(cierres, cierres[1:])]
print(len(rentabilidades))
print(" ".join([f"{r:+.2%}" for r in rentabilidades]))

peor = min(rentabilidades)
print(f"Worst day: {peor:+.2%}, session {rentabilidades.index(peor) + 1}")

11
-0.84% -0.63% -0.39% -2.61% -0.34% -0.05% -0.03% -0.06% +0.24% +0.30% +1.60%
Worst day: -2.61%, session 4

Twelve closes give eleven returns: zip stops when the shorter list runs out. The second comprehension turns each return into a formatted text, and " ".join(…) joins those texts into one, separated by a space. The header figure plots those eleven returns; the worst one, on December 22, in amber.

A comprehension can filter with an if at the end, and there are versions for dictionaries and sets:

subidas = [r for r in rentabilidades if r > 0]
print(f"Up days: {len(subidas)} of {len(rentabilidades)}")

valores = {t: n * precios[t] for t, n in cartera.items()}
total = sum(valores.values())
pesos = {t: round(v / total, 3) for t, v in valores.items()}
print(pesos)

operaciones = [("SINT", 7.43), ("ORO", -3123.56),
               ("SINT", -31.50), ("TECH", 1426.71)]
con_perdidas = {s for s, pnl in operaciones if pnl < 0}
print(sorted(con_perdidas))

Up days: 3 of 11
{'SINT': 0.655, 'ORO': 0.237, 'TECH': 0.108}
['ORO', 'SINT']

Braces with clave: valor give a dictionary; without the colon, a set. The portfolio weights come out in two steps: first the value of each position and then its fraction of the total.

Comprehensions are convenient as long as they fit on one or two lines and can be read at a glance. If you need more than one if, or the expression takes up half a line, a normal for loop (lesson 0.3.4) is clearer.

Which collection to use

The decision comes from three questions, in this order:

flowchart TB
  Q1{Key and value?} -- yes --> D[dict]
  Q1 -- no --> Q2{Unique only?}
  Q2 -- yes --> S[set]
  Q2 -- no --> Q3{Will it change?}
  Q3 -- yes --> L[list]
  Q3 -- no --> T[tuple]

If each piece of data is looked up by a name (a ticker, a parameter), dictionary. If what matters is membership (it is in the index, it has been traded), set. If it is a sequence that grows or changes (a series that receives a new close every day, an order queue), list. If it is a fixed record (a bar, a closed trade), tuple.

Exercises

1. With the lesson's cierres list, compute the total return for the period (last close divided by the first, minus
   1. and the number of sessions in which the close fell relative to the previous one.

total_periodo = cierres[-1] / cierres[0] - 1
bajadas = [r for r in rentabilidades if r < 0]
print(f"Period return: {total_periodo:+.2%}")
print(f"Down sessions: {len(bajadas)}")

Period return: -2.83%
Down sessions: 8

2. The fictional index changes again in 2026: BETA and KAPPA leave and OMEGA and RHO join. Build universo_2026 from universo_2025 with set operations, and compute how many companies have been part of the index at some point in the three years.

universo_2026 = (universo_2025 - {"BETA", "KAPPA"}) | {"OMEGA", "RHO"}
print(sorted(universo_2026))
historico = universo_2024 | universo_2025 | universo_2026
print(len(historico), sorted(historico))

['ALFA', 'DELTA', 'LAMBDA', 'OMEGA', 'RHO', 'SIGMA']
9 ['ALFA', 'BETA', 'DELTA', 'GAMMA', 'KAPPA', 'LAMBDA', 'OMEGA', 'RHO', 'SIGMA']

3. With the lesson's precios dictionary, create a dictionary with the value of a portfolio holding 10 shares of each ticker, and say which ticker has the largest value.

diez = {t: round(10 * p, 2) for t, p in precios.items()}
print(diez)
mayor = max(diez, key=diez.get)
print(mayor, diez[mayor])

{'SINT': 1422.2, 'ORO': 1714.4, 'RFIJ': 1022.9, 'TECH': 778.2}
ORO 1714.4