Algorithmic thinking and the core of Python
You will work in Google Colab for all the workshops. Log in with your @tec.mx account and create a new Colab notebook for each workshop. Rename your notebook (click on the default name, “Untitled.ipynb”) as:
W1-Algorithms-YourFirstName-YourLastName
Share your notebook with cdorante@tec.mx with Edit privileges.
Read each section and re-type and run the code yourself. Do not only copy and paste: when you type the code, you notice what each line does. Add your own notes in text cells, as if this notebook were your personal study guide for the Evidence (in-class exam).
In this course we follow a simple learning cycle for every piece of code:
You are allowed, and encouraged, to use an LLM to help you write code. However, the goal of this course is that you understand Python well enough to read and check any code, including code generated by an LLM. Then, for every challenge:
assert statement. Code that runs without errors is not necessarily correct!Your workshop grade has two parts:
| Part | Weight | What is evaluated |
|---|---|---|
| Notebook (Colab link submitted in Canvas) | 60% | Completeness: all code replicated, all challenges attempted, your algorithms (pseudocode), your notes and your own explanations |
| Canvas Quiz W1 | 40% | Automatically graded: you enter key results from your notebook and answer short code-reading questions |
The Canvas Quiz W1 is due on the same date as the workshop. You have 2 attempts; Canvas keeps your highest score. Numeric answers accept a small tolerance, so round as indicated in each question.
For the notebook part:
Before submitting, run all the cells from top to bottom (in Colab: Runtime → Run all, or Ctrl+F9) to make sure that your notebook runs without errors.
An algorithm is a finite sequence of clear, unambiguous steps that transforms some inputs into a desired output. A cooking recipe is an algorithm: the ingredients are the inputs, the instructions are the steps, and the dish is the output.
In Finance, we use algorithms all the time, even if we do not call them that way. When you build an amortization table in Excel, you are executing an algorithm: for each month, calculate the interest, subtract the payment, and move to the next month.
We will follow a 5-step design recipe for every problem in this course:
1. Problem. I invest $100 at 10% annual interest. How many years do I need to wait until my balance is at least twice my initial investment?
2. Inputs. Initial investment ($100), annual interest rate (10%), target multiple (2).
3. Output. The number of years (an integer), and the balance at that year.
4. General approach. Start with the initial investment. Grow the balance one year at a time. Stop when the balance reaches the target.
5. Pseudocode.
SET balance = initial investment
SET year = 0
REPEAT WHILE balance < multiple × initial investment:
year = year + 1
balance = balance × (1 + rate)
END REPEAT
DISPLAY year and balanceNotice that the pseudocode is not written in any programming language. It uses plain words, but it is precise: there is only one way to interpret each line. Anybody (or any LLM) can translate this pseudocode into Python, R or Excel.
The same algorithm in Python:
initial_investment = 100
rate = 0.10
multiple = 2
balance = initial_investment
year = 0
while balance < multiple * initial_investment:
year = year + 1
balance = balance * (1 + rate)
print(f"You need {year} years. Your balance will be ${balance:,.2f}")You need 8 years. Your balance will be $214.36Compare the pseudocode and the Python code line by line. They are almost the same! This is the main idea of this course: if you can write a clear algorithm, you can write (or check) the code.
LLMs are very good at translating a clear algorithm into code, and very good at explaining code line by line. They are much less reliable when the prompt is vague. Some good practices:
A programming language is a set of instructions that the computer executes to automate tasks. In Economics and Finance we use programming languages mainly to:
Python and R are free, open-source languages, and they are the two most popular languages for Data Science in the world. In this course we use Python.
Any programming language has the following building blocks:
We now review each one.
A variable is a name that refers to a value stored in memory. We create a variable with the assignment operator =:
loan = 3000000 # an integer (int)
apr = 0.11 # a decimal number (float)
bank = "Banorte" # text (str, string)
approved = True # a logical value (bool): True or False
print(type(loan), type(apr), type(bank), type(approved))<class 'int'> <class 'float'> <class 'str'> <class 'bool'>Important: the = sign does not mean equality as in mathematics. It means “compute the right-hand side, and store the result in the name on the left”. Then, this is perfectly valid:
balance = 100
balance = balance * 1.10 # take the current balance, multiply it, and store it again
print(balance)110.00000000000001Arithmetic operators: +, -, *, /, ** (power), // (integer division) and % (remainder):
print(2 ** 3) # power
print(17 // 5) # integer division
print(17 % 5) # remainder8
3
2We display results with f-strings: a string that starts with f and contains variables inside curly braces {}. After a colon we can specify the format:
payment = 40000.456
print(f"The payment is {payment}")
print(f"The payment is ${payment:,.2f}") # thousands separator and 2 decimals
print(f"The rate is {apr:.2%}") # as a percentage with 2 decimalsThe payment is 40000.456
The payment is $40,000.46
The rate is 11.00%A conditional executes a block of code only if a condition is True. Comparison operators are: == (equal), != (different), <, <=, >, >=. We combine conditions with and, or, not.
Indentation matters in Python. The lines that belong to an if block must be indented (4 spaces). Python uses indentation, not braces or END statements, to know where a block ends.
Example: a bond is traded at a premium if its price is higher than its face value, at par if it is equal, and at a discount if it is lower:
price = 1050
face_value = 1000
if price > face_value:
status = "premium"
elif price == face_value:
status = "par"
else:
status = "discount"
print(f"The bond trades at a {status}")The bond trades at a premium= vs ==
= assigns a value to a variable; == compares two values. Writing if price = face_value: produces a SyntaxError.
A loop repeats a block of code. Python has two types of loops:
for loops repeat a block a known number of times, or once for each element of a collection.while loops repeat a block while a condition is True. We use them when we do not know in advance how many iterations we need (as in the “double my investment” example).The function range(start, stop) generates integers from start up to stop - 1:
for month in range(1, 4):
print("Month", month)Month 1
Month 2
Month 3Many financial calculations follow the accumulator pattern: start a variable at zero (or at an initial value) before the loop, and update it inside the loop.
Example: I save $1,000 at the end of each month in an account that pays 12% annual interest compounded monthly. What is my balance after 6 months?
monthly_rate = 0.12 / 12
deposit = 1000
balance = 0 # accumulator starts at 0
for month in range(1, 7):
balance = balance * (1 + monthly_rate) + deposit
print(f"Month {month}: balance = {balance:,.2f}")Month 1: balance = 1,000.00
Month 2: balance = 2,010.00
Month 3: balance = 3,030.10
Month 4: balance = 4,060.40
Month 5: balance = 5,101.01
Month 6: balance = 6,152.02A trace table is a table where you write the value of each variable after each iteration. It is the best tool to understand (and debug) a loop. Here is the trace table for the first 3 iterations of the previous loop:
| month | balance before | interest (1%) | deposit | balance after |
|---|---|---|---|---|
| 1 | 0.00 | 0.00 | 1,000 | 1,000.00 |
| 2 | 1,000.00 | 10.00 | 1,000 | 2,010.00 |
| 3 | 2,010.00 | 20.10 | 1,000 | 3,030.10 |
You will build trace tables in some challenges and in the quizzes. Get used to them!
A list is an ordered collection of values, written with square brackets. Lists are very useful to store cash flows, prices or names:
cash_flows = [-100, 30, 40, 50, 20] # year 0 to year 4
print(len(cash_flows)) # number of elements
print(cash_flows[0]) # first element: Python starts counting at 0!
print(cash_flows[-1]) # last element
print(cash_flows[1:3]) # a slice: elements 1 and 2 (the stop is NOT included)5
-100
20
[30, 40]The first element of a list is cash_flows[0], not cash_flows[1]. A slice [1:3] includes position 1 but excludes position 3. This is the most common source of “off-by-one” errors.
We can add elements with the append method, and we can loop over the elements of a list directly:
prices = [] # an empty list
prices.append(10.5)
prices.append(11.2)
prices.append(10.9)
for p in prices:
print(p)10.5
11.2
10.9When we need both the position and the value, we use enumerate. Example: the Net Present Value (NPV) of the previous cash flows at a 10% discount rate:
NPV=\sum_{t=0}^{T}\frac{CF_{t}}{(1+r)^{t}}
rate = 0.10
npv = 0
for t, cf in enumerate(cash_flows): # t = 0, 1, 2, ...; cf = the cash flow
npv = npv + cf / (1 + rate) ** t
print(f"NPV = {npv:.4f}")NPV = 11.5566A list comprehension builds a new list from another list in one line. It is a compact version of a for loop that appends values:
# Present value of each cash flow, in one line:
pv_flows = [cf / (1 + rate) ** t for t, cf in enumerate(cash_flows)]
print(pv_flows)
print(f"NPV = {sum(pv_flows):.4f}")[-100.0, 27.27272727272727, 33.05785123966942, 37.565740045078876, 13.66026910730141]
NPV = 11.5566Read it as: “for each t, cf in enumerate(cash_flows), compute cf / (1+rate)**t, and collect the results in a list”. You will see list comprehensions very often in advanced Finance courses, so learn to read them now.
A dictionary stores key: value pairs, written with curly braces. It is ideal to store the characteristics of an object, such as a bond or a loan:
bond = {"face_value": 1000, "coupon_rate": 0.06, "years": 10, "frequency": 2}
print(bond["coupon_rate"]) # access a value by its key
bond["issuer"] = "CEMEX" # add a new key
for key, value in bond.items():
print(key, "->", value)0.06
face_value -> 1000
coupon_rate -> 0.06
years -> 10
frequency -> 2
issuer -> CEMEXA list of dictionaries is a very natural way to store a table: each dictionary is a row, and the keys are the column names. The pandas library converts it into a data frame (a table) in one line:
import pandas as pd
rows = []
for year in range(1, 4):
rows.append({"year": year, "balance": 100 * 1.10 ** year})
table = pd.DataFrame(rows)
table| year | balance | |
|---|---|---|
| 0 | 1 | 110.0 |
| 1 | 2 | 121.0 |
| 2 | 3 | 133.1 |
We will use this pattern to build an amortization table in Challenge 3.
If we need to run the same algorithm many times with different inputs, we write a function. A function receives parameters (inputs), executes its steps, and returns an output.
def npv(rate, cash_flows):
"""Net present value of a list of cash flows.
cash_flows[0] happens today (t=0), cash_flows[1] at t=1, and so on."""
total = 0
for t, cf in enumerate(cash_flows):
total = total + cf / (1 + rate) ** t
return total
print(npv(0.10, [-100, 30, 40, 50, 20]))
print(npv(0.15, [-100, 30, 40, 50, 20]))11.55658766477697
0.6435797470706639Some important details:
""" is the docstring: it documents what the function does. Always write one.total) only exist inside the function.return sends the result back. A function without return returns None.Parameters can have default values, so the user only needs to specify them when they are different from the default. A function can also return several values (Python packs them in a tuple), and we can unpack them into several variables:
def future_value(pv, rate, years, frequency=1):
"""Future value of pv invested at an annual rate compounded `frequency` times a year.
Returns the future value and the total interest earned."""
fv = pv * (1 + rate / frequency) ** (years * frequency)
interest = fv - pv
return fv, interest
fv1, int1 = future_value(1000, 0.12, 5) # annual compounding (default)
fv12, int12 = future_value(1000, 0.12, 5, frequency=12) # monthly compounding
print(f"Annual: {fv1:,.2f} (interest {int1:,.2f}); monthly: {fv12:,.2f} (interest {int12:,.2f})")Annual: 1,762.34 (interest 762.34); monthly: 1,816.70 (interest 816.70)Why is this important? In advanced courses (for example, Hedge Funds), most of the code is organized as small functions with default values, docstrings and multiple outputs, like this one:
def style_analysis(fund, X=X_style):
"""Sharpe (1992) constrained style analysis ..."""
...
return w, 1 - e.var() / fund.var(), e
w_qai, r2_qai, e_qai = style_analysis(Rs["QAI"])You do not need to understand what this function does yet, but you can already read its structure: one required parameter, one parameter with a default value, a docstring, and 3 outputs unpacked into 3 variables.
In Python, everything is an object: a number, a list, a data frame. An object contains data and methods, which are functions that belong to the object. We call a method with a dot:
name = "grupo bimbo"
print(name.upper()) # a method of strings
flows = [30, 40]
flows.append(50) # a method of lists
print(flows)
print(table.head(2)) # a method of data framesGRUPO BIMBO
[30, 40, 50]
year balance
0 1 110.0
1 2 121.0When you see something.method(), read it as “apply method to something”. This is all you need to know about Object-Oriented Programming for now.
Errors are normal. Read the last line of the error message first: it tells you the type of error and usually the line where it happened. The most common errors are:
| Error | Typical cause |
|---|---|
NameError: name 'x' is not defined |
You used a variable before creating it, or misspelled it (Python is case-sensitive: Rate ≠ rate) |
SyntaxError |
Missing colon : after if, for, while or def; missing parenthesis; = instead of == |
IndentationError |
The lines of a block are not aligned |
TypeError |
You combined incompatible types, for example "100" + 5 |
IndexError: list index out of range |
You asked for position n in a list of length n (remember: the last position is n-1) |
ZeroDivisionError |
A division by zero, for example a rate of 0 in an annuity formula |
A while loop whose condition never becomes False will run forever. If a cell does not finish, stop it (the stop button in Colab) and check the loop condition.
You have to write an algorithm and the corresponding Python code to calculate the number of months needed to pay off a mortgage loan:
Assume that each month the balance first grows with the monthly interest (APR/12), and then the payment is made at the end of the month. In the last month, you only pay what is left (balance plus that month’s interest), which is less than the fixed payment.
Your program must report: (a) the number of months needed to pay off the loan, (b) the amount of the last payment, and (c) the total amount of interest paid over the life of the loan. Your program must work for any change in the values of the inputs.
Do the following:
N=\frac{-\ln\left(1-\frac{PV\times r}{PMT}\right)}{\ln(1+r)}
where r is the monthly rate. Your number of months must be the next integer above N.
Hint: if you are familiar with Excel, you can start solving the problem in Excel, and then write your logical steps as pseudocode.
1. Design recipe
SET monthly_rate = APR / 12
SET balance = loan, month = 0, total_interest = 0
REPEAT WHILE balance > 0:
month = month + 1
interest = balance × monthly_rate
total_interest = total_interest + interest
balance = balance + interest
IF balance <= payment THEN
last_payment = balance
balance = 0
ELSE
balance = balance − payment
END IF
END REPEAT
DISPLAY month, last_payment, total_interestNotice the decision inside the loop: before paying, we check whether the remaining balance (including this month’s interest) is smaller than the fixed payment. If it is, this is the last month, we pay only what is left, and the balance becomes zero, which ends the loop.
2. Trace table (monthly rate = 0.11/12 = 0.0091667):
| month | balance before | interest | balance + interest | payment | balance after |
|---|---|---|---|---|---|
| 1 | 3,000,000.00 | 27,500.00 | 3,027,500.00 | 40,000 | 2,987,500.00 |
| 2 | 2,987,500.00 | 27,385.42 | 3,014,885.42 | 40,000 | 2,974,885.42 |
| 3 | 2,974,885.42 | 27,269.78 | 3,002,155.19 | 40,000 | 2,962,155.19 |
Each month only about 12,500 pesos of the 40,000 reduce the capital; the rest pays interest. That is why the loan takes so long.
3. Python code
def mortgage_payoff(loan, apr, payment, verbose=False):
"""Simulates the monthly payments of a loan.
Returns: number of months, last payment and total interest paid."""
monthly_rate = apr / 12
balance = loan
month = 0
total_interest = 0
# Safety check: if the payment does not cover the first month's interest,
# the balance will grow forever and the while loop would never end.
if payment <= loan * monthly_rate:
print("The payment does not cover the interest: the loan can never be paid off.")
return None, None, None
while balance > 0:
month = month + 1
interest = balance * monthly_rate
total_interest = total_interest + interest
balance = balance + interest
if balance <= payment: # last month: pay only what is left
last_payment = balance
balance = 0
else: # regular month
balance = balance - payment
if verbose and month <= 3: # print the first 3 months to compare with the trace table
print(f"Month {month}: interest = {interest:,.2f}, balance after payment = {balance:,.2f}")
return month, last_payment, total_interest
months, last_payment, total_interest = mortgage_payoff(3_000_000, 0.11, 40_000, verbose=True)
print(f"Months needed: {months}")
print(f"Last payment: ${last_payment:,.2f}")
print(f"Total interest paid: ${total_interest:,.2f}")Month 1: interest = 27,500.00, balance after payment = 2,987,500.00
Month 2: interest = 27,385.42, balance after payment = 2,974,885.42
Month 3: interest = 27,269.78, balance after payment = 2,962,155.20
Months needed: 128
Last payment: $18,840.27
Total interest paid: $2,098,840.27Line-by-line explanation of the key parts:
def mortgage_payoff(loan, apr, payment, verbose=False): defines a function with 3 required inputs and one optional input (verbose) that, when True, prints the first 3 months.if payment <= loan * monthly_rate: block protects us from an infinite loop; we explain it in question 5.while balance > 0: repeats the monthly process until the loan is paid. We do not know in advance how many months we need, so a while loop is the right choice.if / else implements the decision of the last month.return month, last_payment, total_interest returns 3 values that we unpack in 3 variables.Note: we wrote 3_000_000 instead of 3000000. Python ignores underscores inside numbers; they only make large numbers easier to read.
4. Verification with the closed-form formula
import math
r = 0.11 / 12
N = -math.log(1 - 3_000_000 * r / 40_000) / math.log(1 + r)
print(f"N = {N:.4f} months")
print(f"Next integer = {math.ceil(N)}")
assert math.ceil(N) == months # if this line does not raise an error, both methods agreeN = 127.4699 months
Next integer = 128The formula gives N=127.47 months: 127 full payments and a partial payment in month 128. Our loop gives 128 months, so both methods agree. The total amount paid is 127\times40{,}000+18{,}840.27=5{,}098{,}840.27, and the total interest is this amount minus the loan: $2,098,840.27. We pay about 70% of the loan amount in interest!
The assert statement is a very useful verification tool: assert condition does nothing if the condition is True, and stops the program with an error if it is False.
5. What if the payment is $25,000?
mortgage_payoff(3_000_000, 0.11, 25_000)The payment does not cover the interest: the loan can never be paid off.(None, None, None)The interest of the first month is 3{,}000{,}000\times0.11/12=27{,}500 pesos. A payment of 25,000 does not even cover the interest, so the balance grows every month and the loan can never be paid. Without the safety check, the while balance > 0 condition would always be True and the loop would run forever (an infinite loop). The general lesson: whenever you write a while loop, ask yourself “am I sure that the condition will eventually become False?”
The company ABC issued a bond to finance a new technological project, with the following characteristics:
The price of a bond is the present value of its coupons plus the present value of its face value:
Price=\sum_{t=1}^{N}\frac{C}{(1+i)^{t}}+\frac{FV}{(1+i)^{N}}
where C is the periodic coupon, i is the periodic interest rate (the annual rate divided by the number of payments per year), and N is the total number of periods.
bond_price that receives the annual market interest rate, the years to maturity, the frequency of payments, the annual coupon rate and the face value, and returns the price of the bond. Use default values for the frequency (2) and the face value (1,000).[0.08, 0.11, 0.13] and a for loop, calculate the price of the ABC bond for each rate. For each rate, use a conditional to display whether the bond trades at a premium, at par or at a discount.Design recipe
periodic_rate = annual_rate / frequency
N = years × frequency
coupon = coupon_rate × face_value / frequency
price = 0
FOR t = 1 TO N:
price = price + coupon / (1 + periodic_rate)^t
price = price + face_value / (1 + periodic_rate)^N
RETURN pricePython code
def bond_price(annual_rate, years, coupon_rate, frequency=2, face_value=1000):
"""Price of a fixed-coupon bond.
annual_rate: annual market rate (yield), as a decimal
years: years to maturity
coupon_rate: annual coupon rate, as a decimal
frequency: number of coupon payments per year (default 2 = semiannual)
face_value: principal paid at maturity (default 1,000)"""
periodic_rate = annual_rate / frequency
n_periods = years * frequency
coupon = coupon_rate * face_value / frequency
price = 0
for t in range(1, n_periods + 1): # t = 1, 2, ..., N (range excludes the stop)
price = price + coupon / (1 + periodic_rate) ** t
price = price + face_value / (1 + periodic_rate) ** n_periods
return price
market_rates = [0.08, 0.11, 0.13]
FACE = 3_000_000
for rate in market_rates:
p = bond_price(rate, years=20, coupon_rate=0.11, face_value=FACE)
if round(p, 2) > FACE:
status = "premium"
elif round(p, 2) == FACE:
status = "par"
else:
status = "discount"
print(f"Market rate {rate:.0%}: price = ${p:,.2f} -> trades at a {status}")Market rate 8%: price = $3,890,674.82 -> trades at a premium
Market rate 11%: price = $3,000,000.00 -> trades at a par
Market rate 13%: price = $2,575,634.19 -> trades at a discountExplanation:
range(1, n_periods + 1) generates 1, 2, …, 40. We need + 1 because range excludes its stop value. This is a classic off-by-one trap: with range(1, n_periods) we would miss the last coupon.years=20, coupon_rate=0.11, face_value=FACE). This makes the call easy to read, and the order does not matter. We did not specify frequency, so it takes its default value of 2.round(p, 2) with the face value, not p. Computers store decimal numbers with tiny rounding errors (for example, 0.1 + 0.2 is 0.30000000000000004), so the price at 11% could be 2,999,999.9999999995 instead of exactly 3,000,000. Rounding to cents avoids classifying it wrongly as a discount.Verification with the annuity formula
i = 0.08 / 2
N = 20 * 2
C = 0.11 * FACE / 2
price_formula = C * (1 - (1 + i) ** (-N)) / i + FACE / (1 + i) ** N
print(f"Annuity formula at 8%: ${price_formula:,.2f}")
assert abs(price_formula - bond_price(0.08, 20, 0.11, face_value=FACE)) < 0.01Annuity formula at 8%: $3,890,674.82Both methods give $3,890,674.82 at 8%.
Why does the price go down when the market rate goes up? The bond promises fixed cash flows (the coupons and the principal). When market rates go up, investors can get a higher return in other investments, so they are willing to pay less for these fixed cash flows. Mathematically, a higher rate means a larger denominator for every discounted cash flow. When the market rate equals the coupon rate (11%), the bond trades exactly at par; below it, at a premium ($3,890,674.82 at 8%), and above it, at a discount ($2,575,634.19 at 13%).
Using the mortgage of Challenge 1 ($3,000,000, APR = 11%, payment = $40,000):
month, beginning_balance, interest, payment, principal (the part of the payment that reduces the balance) and ending_balance..head() and .tail()).table["interest"].sum()), and check with assert that it matches the total interest of Challenge 1 (allow a difference smaller than 0.01), and that the last ending balance is zero.table[table["principal"] > table["interest"]], and look at the first row.The algorithm is the same as in Challenge 1, but instead of only keeping the final numbers, each month we save a row (a dictionary) in a list.
import pandas as pd
def amortization_table(loan, apr, payment):
"""Amortization table of a loan with a fixed monthly payment, as a data frame."""
monthly_rate = apr / 12
balance = loan
month = 0
rows = [] # the list that will contain one dictionary per month
while balance > 0:
month = month + 1
interest = balance * monthly_rate
pay = min(payment, balance + interest) # in the last month we pay only what is left
principal = pay - interest
# principal is the amount by which the balance is reduced each period
ending = balance - principal # principal reduces the balance of the loan each period
rows.append({"month": month,
"beginning_balance": balance,
"interest": interest,
"payment": pay,
"principal": principal,
"ending_balance": ending})
balance = ending
return pd.DataFrame(rows)
table = amortization_table(3_000_000, 0.11, 40_000)
table.head()| month | beginning_balance | interest | payment | principal | ending_balance | |
|---|---|---|---|---|---|---|
| 0 | 1 | 3.000000e+06 | 27500.000000 | 40000.0 | 12500.000000 | 2.987500e+06 |
| 1 | 2 | 2.987500e+06 | 27385.416667 | 40000.0 | 12614.583333 | 2.974885e+06 |
| 2 | 3 | 2.974885e+06 | 27269.782986 | 40000.0 | 12730.217014 | 2.962155e+06 |
| 3 | 4 | 2.962155e+06 | 27153.089330 | 40000.0 | 12846.910670 | 2.949308e+06 |
| 4 | 5 | 2.949308e+06 | 27035.325982 | 40000.0 | 12964.674018 | 2.936344e+06 |
table.tail()| month | beginning_balance | interest | payment | principal | ending_balance | |
|---|---|---|---|---|---|---|
| 123 | 124 | 174399.498690 | 1598.662071 | 40000.000000 | 38401.337929 | 135998.160761 |
| 124 | 125 | 135998.160761 | 1246.649807 | 40000.000000 | 38753.350193 | 97244.810568 |
| 125 | 126 | 97244.810568 | 891.410764 | 40000.000000 | 39108.589236 | 58136.221332 |
| 126 | 127 | 58136.221332 | 532.915362 | 40000.000000 | 39467.084638 | 18669.136694 |
| 127 | 128 | 18669.136694 | 171.133753 | 18840.270447 | 18669.136694 | 0.000000 |
Explanation:
min(payment, balance + interest) is an elegant way to implement the decision of the last month without an if: we pay the fixed payment, unless what we owe is smaller.rows.append({...}) adds one dictionary (one row) per month. At the end, pd.DataFrame(rows) converts the list of dictionaries into a table: the keys become the column names.Checks
total_interest_table = table["interest"].sum()
print(f"Total interest (table): ${total_interest_table:,.2f}")
assert abs(total_interest_table - total_interest) < 0.01 # same as Challenge 1
assert abs(table["ending_balance"].iloc[-1]) < 0.01 # the loan is fully paid
print("All checks passed")Total interest (table): $2,098,840.27
All checks passedtable["interest"] selects one column, and .sum() adds all its values. .iloc[-1] selects the last element by position (we will study .iloc in Workshop 2).
When does the principal become larger than the interest?
crossing = table[table["principal"] > table["interest"]]
print(crossing.head(1))
print(f"First month: {crossing['month'].iloc[0]}") month beginning_balance interest payment principal \
52 53 2.171996e+06 19909.966452 40000.0 20090.033548
ending_balance
52 2.151906e+06
First month: 53table["principal"] > table["interest"] creates a column of True/False values, and table[...] keeps only the rows where the condition is True. The first of those rows is month 53. During the first 52 months (more than 4 years!), most of each payment goes to the bank as interest. This is typical of long mortgages.
In Challenge 2 we calculated the price of a bond for a given market rate. In practice, we often have the opposite problem: we observe the price in the market, and we want to know the yield to maturity (YTM), the market rate that makes the price formula equal to the observed price. There is no closed formula for the YTM, so we need an algorithm.
The bisection method is a classic search algorithm. The idea: the bond price goes down when the rate goes up. If we know a rate that is too low (the price is above the observed price) and a rate that is too high (the price is below the observed price), the YTM must be between them. We try the midpoint, and we keep the half where the YTM must be. We repeat until the interval is very small.
SET low = 0.0001, high = 1.0
REPEAT WHILE (high − low) > tolerance:
mid = (low + high) / 2
IF bond_price(mid) > observed_price THEN
low = mid (the rate is too low: the YTM is in the upper half)
ELSE
high = mid (the rate is too high: the YTM is in the lower half)
END IF
END REPEAT
RETURN midytm_bisection(observed_price, years, coupon_rate, frequency=2, face_value=1000, tolerance=1e-8) that implements this algorithm and uses your bond_price function inside it.bond_price and check that you get the observed price.def ytm_bisection(observed_price, years, coupon_rate, frequency=2, face_value=1000,
tolerance=1e-8):
"""Yield to maturity (annual rate) of a bond, found with the bisection method.
Returns the YTM and the number of iterations."""
low, high = 0.0001, 1.0
iterations = 0
while (high - low) > tolerance:
iterations = iterations + 1
mid = (low + high) / 2
price_mid = bond_price(mid, years, coupon_rate, frequency, face_value)
if price_mid > observed_price:
low = mid # the price is too high, so the rate is too low
else:
high = mid # the price is too low, so the rate is too high
return mid, iterations
ytm, n_iter = ytm_bisection(2_600_000, years=20, coupon_rate=0.11, face_value=3_000_000)
print(f"YTM = {ytm:.4%} found in {n_iter} iterations")YTM = 12.8704% found in 27 iterationsVerification
check_price = bond_price(ytm, 20, 0.11, face_value=3_000_000)
print(f"Price at the YTM: ${check_price:,.2f}")
assert abs(check_price - 2_600_000) < 1 # less than 1 peso of differencePrice at the YTM: $2,599,999.89The YTM is 12.8704%. It makes sense: the price (2,600,000) is between the price at 11% (3,000,000) and the price at 13% (2,575,634), and closer to the latter, so the YTM must be between 11% and 13%, close to 13%.
Why does it always work, and why is it fast? It always works because the price is a decreasing, continuous function of the rate: if the YTM is between low and high at the beginning, it stays inside the interval after each step, because we always keep the half that contains it. It is fast because each iteration cuts the interval in half. After k iterations, the width is 1/2^{k} of the original. Starting with a width of about 1, we need k such that 1/2^{k}<10^{-8}, which gives k=27 iterations. With 40 iterations, the precision would be about 10^{-12}.
This idea (improve a guess step by step until it is good enough) is the basis of the numerical optimization algorithms used in portfolio optimization and in the estimation of Machine Learning models, which you will see in Workshop 4 and in advanced courses.
Without running the code, predict what each piece of code prints. Write your prediction in a text cell. Then run it and explain any difference.
5.1
total = 0
for i in range(1, 5):
total = total + i * 10
print(total)5.2
flows = [100, 200, 300, 400, 500]
print(flows[1], flows[-2], flows[2:4], len(flows[1:]))5.3 The following code should calculate the future value of $1,000 invested for 3 years at 10% annually, but it prints the wrong result. Find the bug and fix it.
balance = 1000
for year in range(1, 3):
balance = balance * 1.10
print(balance)5.4
def fee(amount, rate=0.02, minimum=50):
f = amount * rate
if f < minimum:
f = minimum
return f
print(fee(1000), fee(10000), fee(10000, rate=0.01))5.1 The loop runs for i = 1, 2, 3, 4 (the stop value 5 is excluded). The accumulator adds 10, 20, 30, 40, so it prints 100.
5.2 flows[1] is the second element, 200. flows[-2] is the second-to-last element, 400. flows[2:4] includes positions 2 and 3, [300, 400]. flows[1:] has 4 elements, so the length is 4. It prints 200 400 [300, 400] 4.
5.3 range(1, 3) generates only 1 and 2, so the loop runs twice, not 3 times. It prints 1,210 instead of 1,331. The fix is range(1, 4) or, more clearly, range(3) (which generates 0, 1, 2: three iterations).
balance = 1000
for year in range(3):
balance = balance * 1.10
print(f"{balance:.2f}")1331.005.4 fee(1000): 1000 × 0.02 = 20, less than the minimum, so it returns 50. fee(10000): 10000 × 0.02 = 200.0. fee(10000, rate=0.01): 10000 × 0.01 = 100.0. It prints 50 200.0 100.0. Notice that the first result is an integer (50), because the function returns the default minimum, which is an integer.