Python for Finance on Michael Brunger

Next Steps & Advanced Python Topics (Python for Finance, part 17)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 21 Aug 2025 00:00:00 +0000

Welcome to the final post in our Python beginner series! If you’ve made it this far, congratulations—you’ve built a solid foundation in Python programming. In this post, we’ll explore some advanced topics and provide guidance on where to go next in your Python journey, with a particular focus on financial applications.

Concurrency & Asynchronous Programming

As your Python programs grow more complex, especially when dealing with financial data processing or automation, you’ll need to understand how to make your code run faster and more efficiently.

Threading vs. Multiprocessing

Python offers several options for concurrent programming:

Threading (`threading` module)

import threading
import time

def download_financial_data(ticker):
 print(f"Downloading data for {ticker}...")
 time.sleep(2) # Simulating network delay
 print(f"Download complete for {ticker}")

# Create threads for different stock tickers
threads = []
for ticker in ["AAPL", "MSFT", "GOOGL", "AMZN"]:
 thread = threading.Thread(target=download_financial_data, args=(ticker,))
 threads.append(thread)
 thread.start()

# Wait for all threads to complete
for thread in threads:
 thread.join()

print("All financial data downloaded")

When to use threading:

I/O-bound tasks (waiting for network responses, file operations)
When you need to keep the UI responsive
For tasks that spend time waiting rather than computing

Limitations: Due to Python’s Global Interpreter Lock (GIL), threads can’t execute Python code in parallel, limiting CPU-bound performance gains.

Multiprocessing (`multiprocessing` module)

import multiprocessing
import time

def analyze_financial_data(ticker):
 print(f"Analyzing data for {ticker}...")
 # CPU-intensive calculations
 result = 0
 for i in range(10000000): # Simulate complex calculation
 result += i
 print(f"Analysis complete for {ticker}: {result}")
 return result

if __name__ == "__main__":
 # Create processes for different stock tickers
 pool = multiprocessing.Pool(processes=4) # Use 4 CPU cores
 tickers = ["AAPL", "MSFT", "GOOGL", "AMZN"]
 results = pool.map(analyze_financial_data, tickers)
 
 pool.close()
 pool.join()
 
 print(f"All analyses complete. Results: {results}")

When to use multiprocessing:

CPU-bound tasks (complex calculations, portfolio optimisations)
When you need true parallelism across CPU cores
For tasks that need to bypass the GIL

Considerations: Processes have more overhead than threads and don’t share memory by default.

Asynchronous Programming with `asyncio`

For modern Python concurrency, especially in financial applications handling many simultaneous connections to data providers:

import asyncio
import time

async def fetch_stock_price(ticker):
 print(f"Fetching {ticker}...")
 await asyncio.sleep(2) # Simulating API call
 # In reality, you might use aiohttp to fetch data
 price = {"AAPL": 182.63, "MSFT": 425.27, "GOOGL": 175.98}
 return {ticker: price.get(ticker, 0)}

async def main():
 start = time.time()
 
 # Run multiple API calls concurrently
 tasks = [
 fetch_stock_price("AAPL"),
 fetch_stock_price("MSFT"),
 fetch_stock_price("GOOGL")
 ]
 
 results = await asyncio.gather(*tasks)
 
 end = time.time()
 print(f"Results: {results}")
 print(f"Time taken: {end - start:.2f} seconds")

# Python 3.7+
asyncio.run(main())

Benefits for financial applications:

Handle thousands of concurrent connections with minimal resources
Perfect for real-time market data feeds and trading systems
More efficient than threading for I/O-bound operations

End-to-End Financial Mini Projects

Now let’s look at some project ideas that combine everything you’ve learned:

1. Personal Finance Dashboard

Build a web application that helps track personal finances:

Backend: Flask or Django for API endpoints
Database: SQLite or PostgreSQL to store transactions
Data Analysis: pandas for trend analysis and category breakdowns
Visualisation: Matplotlib or Plotly for spending charts
Frontend: Basic HTML/CSS with JavaScript or a simple Tkinter desktop app
Features:
- Transaction importing from CSV bank statements
- Budget tracking and alerts
- Monthly spending reports
- Investment performance tracking

2. Stock Portfolio Analyser

Create a tool to analyse investment portfolios:

Data Source: Yahoo Finance API or Alpha Vantage (use requests or aiohttp)
Analysis: Calculate risk metrics (beta, Sharpe ratio, etc.) with NumPy
Visualisation: Interactive charts with Plotly
Optimisation: Monte Carlo simulations for portfolio optimisation
Testing: Unit tests for financial calculations
Documentation: Proper docstrings and a user guide

# Sample snippet for a portfolio analyzer
import pandas as pd
import numpy as np
import yfinance as yf
import matplotlib.pyplot as plt

# Get historical data
tickers = ["AAPL", "MSFT", "GOOGL", "BRK-B", "JPM"]
start_date = "2020-01-01"
end_date = "2023-01-01"

# Download data
data = yf.download(tickers, start=start_date, end=end_date)['Adj Close']

# Calculate returns
returns = data.pct_change().dropna()

# Calculate portfolio metrics
mean_returns = returns.mean() * 252 # Annualized returns
cov_matrix = returns.cov() * 252 # Annualized covariance

# Generate random portfolio weights
num_portfolios = 10000
results = np.zeros((3, num_portfolios))
weights_record = []

for i in range(num_portfolios):
 weights = np.random.random(len(tickers))
 weights /= np.sum(weights)
 weights_record.append(weights)
 
 # Portfolio return
 portfolio_return = np.sum(weights * mean_returns)
 
 # Portfolio volatility
 portfolio_stddev = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
 
 # Sharpe ratio (assuming risk-free rate of 0 for simplicity)
 sharpe_ratio = portfolio_return / portfolio_stddev
 
 results[0,i] = portfolio_return
 results[1,i] = portfolio_stddev
 results[2,i] = sharpe_ratio

# Find the optimal portfolio
max_sharpe_idx = np.argmax(results[2])
optimal_weights = weights_record[max_sharpe_idx]

print("Optimal Portfolio Allocation:")
for ticker, weight in zip(tickers, optimal_weights):
 print(f"{ticker}: {weight*100:.2f}%")
print(f"Expected Annual Return: {results[0,max_sharpe_idx]*100:.2f}%")
print(f"Expected Volatility: {results[1,max_sharpe_idx]*100:.2f}%")
print(f"Sharpe Ratio: {results[2,max_sharpe_idx]:.2f}")

3. Financial Statement Analyser

Build a tool for analysing company financial statements:

Data Gathering: Web scraping SEC filings with BeautifulSoup
Data Storage: Structured storage in SQLite/pandas
Analysis: Ratio calculations and trend analysis
Reporting: Automated PDF reports with ReportLab
Future Enhancement: Sentiment analysis on earnings call transcripts

Learning Resources

Books

“Python for Finance” by Yves Hilpisch
- Advanced quantitative finance with Python
- Derivatives pricing, risk management, and algorithmic trading
“Fluent Python” by Luciano Ramalho
- Deep dive into Python’s internals
- Advanced language features and best practices
“Effective Python” by Brett Slatkin
- 90 specific ways to write better Python code
- Practical advice for clean, efficient coding

Online Courses

Coursera: “Python for Financial Analysis and Algorithmic Trading”
- Financial time series analysis
- Algorithmic trading strategies implementation
edX: “Introduction to Computational Finance and Financial Econometrics”
- Statistical models for financial analysis
- Risk assessment techniques
DataCamp: “Python for Finance” Track
- Importing and managing financial data
- Time series analysis and visualisation

Blogs and Websites

Towards Data Science (Medium)
- Regular articles on Python for finance and data science
PyCoders Weekly
- Newsletter with latest Python news and packages
Planet Python
- Aggregator of Python blogs
Real Python
- In-depth tutorials and articles

GitHub Repositories to Follow

pandas-dev/pandas
PyData ecosystem projects
quantopian/zipline (algorithmic trading library)
hudson-and-thames/mlfinlab (machine learning for finance)

Community Engagement

Getting involved in the Python community is one of the best ways to continue learning:

Attend PyCon or PyData conferences (many have financial tracks)
Join local Python meetup groups
Participate in open source projects
Share your knowledge through blogs or talks

Advanced Topics to Explore Next

As you continue your Python journey, consider exploring these advanced topics with financial applications:

1. Machine Learning for Finance

Scikit-learn for predictive models (default prediction, credit scoring)
TensorFlow/PyTorch for deep learning (market prediction, algorithmic trading)
Financial time series forecasting with ARIMA, GARCH, and RNNs

# Simple example of a credit risk classifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import pandas as pd

# Load credit data (you'd replace this with your own dataset)
credit_data = pd.read_csv('credit_data.csv')

# Features and target
X = credit_data.drop('default', axis=1)
y = credit_data['default']

# Split data
X_train, X_test, y_train, y_test = train_test_split(
 X, y, test_size=0.2, random_state=42
)

# Train model
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Evaluate
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

# Feature importance for interpretability
importances = model.feature_importances_
features = X.columns
for feature, importance in sorted(zip(features, importances), 
 key=lambda x: x[1], reverse=True):
 print(f"{feature}: {importance:.4f}")

2. Cloud Deployment

AWS Lambda for serverless financial calculations
Google Cloud Run for containerised financial applications
Azure Functions for event-driven financial processing

3. Big Data Processing

Apache Spark with PySpark for distributed financial data processing
Dask for parallel computing with pandas-like API
Handling and analysing terabytes of market data efficiently

4. Natural Language Processing for Finance

Sentiment analysis on financial news and earnings calls
Named entity recognition for financial document processing
Summarisation of lengthy financial reports

Conclusion

You’ve come a long way from your first “Hello, World!” program to understanding advanced Python concepts. Remember that programming is a journey of continuous learning—there’s always something new to discover and master.

The financial industry is increasingly embracing Python for everything from data analysis to algorithmic trading. The skills you’ve developed in this series provide a strong foundation, but the most valuable skill is knowing how to learn and adapt as both Python and finance evolve.

Keep building projects, participating in the community, and pushing your boundaries. The combination of finance expertise and Python programming skills is incredibly powerful and will serve you well throughout your career.

Happy coding, and I look forward to seeing what you build next!

Building Simple GUI Applications with Tkinter (Python for Finance, part 16)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 14 Aug 2025 00:00:00 +0000

Part 16 of my Learning Python in Public series

As a finance professional diving into programming, I’ve realised that data analysis is only half the battle. Sometimes you need to package your calculations into user-friendly applications that colleagues can use without knowing Python. That’s where GUI (Graphical User Interface) programming comes in, and Python makes this surprisingly accessible with Tkinter.

What is Tkinter?

Tkinter (pronounced “tee-kay-inter”) is Python’s standard GUI framework that comes bundled with your Python installation. No extra pip installs needed! It’s based on the Tk toolkit, which has been around since the 1990s. While not the most modern-looking framework, it’s:

Built-in and instantly available
Relatively easy to learn
Cross-platform (Windows, macOS, Linux)
Perfect for internal tools and prototypes

Setting Up Your First Tkinter Application

Let’s start with the absolute basics. Every Tkinter application follows a similar structure:

import tkinter as tk

# Create the main window
root = tk.Tk()
root.title("My First Tkinter App")
root.geometry("400x300") # Width x Height

# Add widgets here...

# Start the event loop
root.mainloop()

If you run this code, you’ll see a small, empty window appear. Let’s break down what’s happening:

We import tkinter and alias it as tk (standard practice)
We create a main window (called root by convention)
We set a title and dimensions
mainloop() starts the event loop that listens for user interactions

Nothing fancy yet, but you’ve already created your first GUI application!

Core Tkinter Widgets

Tkinter provides a set of basic widgets (UI elements) you can add to your application:

Label: Displays text or images
Button: Clickable element that triggers actions
Entry: Single-line text input field
Text: Multi-line text input area
Frame: Container for organising other widgets
Checkbutton: On/off toggle
Radiobutton: One-of-many selection
Listbox: List of selectable items
Combobox: Dropdown selection (from ttk submodule)

Let’s add a few of these to our window:

import tkinter as tk

root = tk.Tk()
root.title("Finance Calculator")
root.geometry("400x300")
root.configure(padx=20, pady=20) # Add some padding

# Create a label
header = tk.Label(root, text="Investment Calculator", font=("Arial", 16, "bold"))
header.pack(pady=10)

# Create an entry field with a label
amount_frame = tk.Frame(root)
amount_frame.pack(fill="x", pady=5)

amount_label = tk.Label(amount_frame, text="Initial Investment ($):", width=20, anchor="w")
amount_label.pack(side="left")

amount_entry = tk.Entry(amount_frame)
amount_entry.pack(side="left", expand=True, fill="x")
amount_entry.insert(0, "1000") # Default value

# Add a button
calculate_button = tk.Button(root, text="Calculate Returns")
calculate_button.pack(pady=10)

root.mainloop()

Now we’re getting somewhere! This code creates:

A header label with larger, bold text
A frame containing a label and entry field side-by-side
A button (which doesn’t do anything yet)

Layout Management

You may have noticed I used .pack() to position the widgets. This is one of three layout managers in Tkinter:

1. Pack

The simplest layout manager. It packs widgets one after another, either vertically (default) or horizontally.

widget.pack(side="top") # Options: "top", "bottom", "left", "right"

Useful options:

fill: Can be “x”, “y”, or “both” to make the widget expand
expand: Boolean that determines if the widget should claim extra space
padx, pady: Add external padding around the widget

2. Grid

More flexible, allows positioning in a table-like grid:

widget.grid(row=0, column=0)

Useful options:

rowspan, columnspan: Make a widget span multiple cells
sticky: Align widget within its cell (“n”, “s”, “e”, “w” or combinations)
padx, pady: Add padding around the widget

3. Place

Gives absolute positioning control:

widget.place(x=10, y=10, width=100, height=30)

Most Tkinter applications use either pack or grid. Let’s rewrite our example using grid:

import tkinter as tk

root = tk.Tk()
root.title("Finance Calculator")
root.geometry("500x400")
root.configure(padx=20, pady=20)

# Header
header = tk.Label(root, text="Investment Calculator", font=("Arial", 16, "bold"))
header.grid(row=0, column=0, columnspan=2, pady=10)

# Initial Investment
tk.Label(root, text="Initial Investment ($):").grid(row=1, column=0, sticky="w", pady=5)
initial_investment = tk.Entry(root)
initial_investment.grid(row=1, column=1, sticky="ew", pady=5)
initial_investment.insert(0, "1000")

# Annual Contribution
tk.Label(root, text="Annual Contribution ($):").grid(row=2, column=0, sticky="w", pady=5)
annual_contribution = tk.Entry(root)
annual_contribution.grid(row=2, column=1, sticky="ew", pady=5)
annual_contribution.insert(0, "0")

# Interest Rate
tk.Label(root, text="Expected Return (%):").grid(row=3, column=0, sticky="w", pady=5)
interest_rate = tk.Entry(root)
interest_rate.grid(row=3, column=1, sticky="ew", pady=5)
interest_rate.insert(0, "7")

# Time Period
tk.Label(root, text="Years:").grid(row=4, column=0, sticky="w", pady=5)
years = tk.Entry(root)
years.grid(row=4, column=1, sticky="ew", pady=5)
years.insert(0, "10")

# Calculate Button
calculate_button = tk.Button(root, text="Calculate Returns")
calculate_button.grid(row=5, column=0, columnspan=2, pady=15)

# Results Label
result_label = tk.Label(root, text="Future Value: $0.00", font=("Arial", 12))
result_label.grid(row=6, column=0, columnspan=2, pady=10)

# Configure grid columns to resize
root.grid_columnconfigure(1, weight=1)

root.mainloop()

This creates a more structured form with labels on the left and entry fields on the right.

Adding Functionality with Event Handlers

Now let’s make our calculator actually do something when you click the button. We’ll add an event handler:

import tkinter as tk
from tkinter import messagebox
import locale

# Set locale for currency formatting
locale.setlocale(locale.LC_ALL, '')

def calculate_investment():
 try:
 # Get values from entry fields
 initial = float(initial_investment.get())
 annual = float(annual_contribution.get())
 rate = float(interest_rate.get()) / 100 # Convert percentage to decimal
 time = int(years.get())
 
 # Calculate compound interest with annual additions
 future_value = initial * (1 + rate) ** time
 
 # Add effect of annual contributions
 if annual > 0 and rate > 0:
 future_value += annual * ((1 + rate) ** time - 1) / rate
 
 # Update result label with formatted currency
 formatted_value = locale.currency(future_value, grouping=True)
 result_label.config(text=f"Future Value: {formatted_value}")
 
 # Create detailed breakdown
 show_breakdown(initial, annual, rate, time, future_value)
 
 except ValueError:
 messagebox.showerror("Input Error", "Please enter valid numbers in all fields")

def show_breakdown(initial, annual, rate, time, final):
 # Create a new window for the breakdown
 breakdown = tk.Toplevel(root)
 breakdown.title("Investment Breakdown")
 breakdown.geometry("400x300")
 breakdown.configure(padx=20, pady=20)
 
 # Add a heading
 tk.Label(breakdown, text="Year-by-Year Breakdown", font=("Arial", 12, "bold")).pack(pady=10)
 
 # Create text widget for the breakdown
 text = tk.Text(breakdown, width=40, height=12)
 text.pack(expand=True, fill="both")
 
 # Add scrollbar
 scrollbar = tk.Scrollbar(text)
 scrollbar.pack(side="right", fill="y")
 text.config(yscrollcommand=scrollbar.set)
 scrollbar.config(command=text.yview)
 
 # Insert header
 text.insert("end", f"{'Year':<6}{'Balance':<15}{'Interest':<15}{'Total':<15}\n")
 text.insert("end", "-" * 50 + "\n")
 
 # Calculate and insert year-by-year breakdown
 current_value = initial
 for year in range(1, time + 1):
 interest = current_value * rate
 if year > 1: # Add annual contribution except for first year
 current_value += annual
 current_value += interest
 
 text.insert("end", f"{year:<6}{locale.currency(current_value - interest, grouping=True):<15}")
 text.insert("end", f"{locale.currency(interest, grouping=True):<15}{locale.currency(current_value, grouping=True):<15}\n")
 
 # Make text widget read-only
 text.config(state="disabled")

root = tk.Tk()
root.title("Investment Calculator")
root.geometry("500x400")
root.configure(padx=20, pady=20)

# Header
header = tk.Label(root, text="Investment Calculator", font=("Arial", 16, "bold"))
header.grid(row=0, column=0, columnspan=2, pady=10)

# Initial Investment
tk.Label(root, text="Initial Investment ($):").grid(row=1, column=0, sticky="w", pady=5)
initial_investment = tk.Entry(root)
initial_investment.grid(row=1, column=1, sticky="ew", pady=5)
initial_investment.insert(0, "1000")

# Annual Contribution
tk.Label(root, text="Annual Contribution ($):").grid(row=2, column=0, sticky="w", pady=5)
annual_contribution = tk.Entry(root)
annual_contribution.grid(row=2, column=1, sticky="ew", pady=5)
annual_contribution.insert(0, "0")

# Interest Rate
tk.Label(root, text="Expected Return (%):").grid(row=3, column=0, sticky="w", pady=5)
interest_rate = tk.Entry(root)
interest_rate.grid(row=3, column=1, sticky="ew", pady=5)
interest_rate.insert(0, "7")

# Time Period
tk.Label(root, text="Years:").grid(row=4, column=0, sticky="w", pady=5)
years = tk.Entry(root)
years.grid(row=4, column=1, sticky="ew", pady=5)
years.insert(0, "10")

# Calculate Button
calculate_button = tk.Button(root, text="Calculate Returns", command=calculate_investment)
calculate_button.grid(row=5, column=0, columnspan=2, pady=15)

# Results Label
result_label = tk.Label(root, text="Future Value: $0.00", font=("Arial", 12))
result_label.grid(row=6, column=0, columnspan=2, pady=10)

# Configure grid columns to resize
root.grid_columnconfigure(1, weight=1)

root.mainloop()

Now we’ve added:

A calculate_investment() function that runs when the button is clicked
Input validation with error handling
A detailed year-by-year breakdown in a separate window
Connected the button to the function using the command parameter

Styling and Polish

Tkinter’s default appearance is… functional, but not particularly attractive. Let’s add some styling:

import tkinter as tk
from tkinter import ttk, messagebox
import locale

# Set locale for currency formatting
locale.setlocale(locale.LC_ALL, '')

def calculate_investment():
 try:
 # Get values from entry fields
 initial = float(initial_investment.get())
 annual = float(annual_contribution.get())
 rate = float(interest_rate.get()) / 100 # Convert percentage to decimal
 time = int(years.get())
 
 # Calculate compound interest with annual additions
 future_value = initial * (1 + rate) ** time
 
 # Add effect of annual contributions
 if annual > 0 and rate > 0:
 future_value += annual * ((1 + rate) ** time - 1) / rate
 
 # Update result label with formatted currency
 formatted_value = locale.currency(future_value, grouping=True)
 result_label.config(text=f"Future Value: {formatted_value}")
 
 # Show breakdown button
 breakdown_button.grid(row=7, column=0, columnspan=2, pady=5)
 
 # Store values for breakdown
 global investment_data
 investment_data = {
 "initial": initial,
 "annual": annual,
 "rate": rate,
 "time": time,
 "final": future_value
 }
 
 except ValueError:
 messagebox.showerror("Input Error", "Please enter valid numbers in all fields")

def show_breakdown():
 # Create a new window for the breakdown
 breakdown = tk.Toplevel(root)
 breakdown.title("Investment Breakdown")
 breakdown.geometry("600x400")
 breakdown.configure(padx=20, pady=20)
 
 # Add a heading
 tk.Label(breakdown, text="Year-by-Year Breakdown", font=("Arial", 12, "bold")).pack(pady=10)
 
 # Create a frame for the table
 table_frame = ttk.Frame(breakdown)
 table_frame.pack(expand=True, fill="both")
 
 # Create treeview (table)
 columns = ("Year", "Starting Balance", "Interest Earned", "Contribution", "Ending Balance")
 table = ttk.Treeview(table_frame, columns=columns, show="headings")
 
 # Configure columns
 for col in columns:
 table.heading(col, text=col)
 table.column(col, width=100, anchor="center")
 
 # Add scrollbar
 scrollbar = ttk.Scrollbar(table_frame, orient="vertical", command=table.yview)
 scrollbar.pack(side="right", fill="y")
 table.configure(yscrollcommand=scrollbar.set)
 table.pack(expand=True, fill="both")
 
 # Extract values from stored data
 initial = investment_data["initial"]
 annual = investment_data["annual"]
 rate = investment_data["rate"]
 time = investment_data["time"]
 
 # Calculate and insert year-by-year breakdown
 current_value = initial
 for year in range(1, time + 1):
 starting_balance = current_value
 interest = current_value * rate
 contribution = annual if year < time else 0 # No contribution in final year calculation
 current_value = starting_balance + interest + contribution
 
 # Format values as currency
 formatted_starting = locale.currency(starting_balance, grouping=True)
 formatted_interest = locale.currency(interest, grouping=True)
 formatted_contribution = locale.currency(contribution, grouping=True)
 formatted_ending = locale.currency(current_value, grouping=True)
 
 # Add row to table
 table.insert("", "end", values=(year, formatted_starting, formatted_interest, 
 formatted_contribution, formatted_ending))
 
 # Add a button to generate a chart
 chart_button = ttk.Button(breakdown, text="Generate Chart", command=lambda: show_chart(time))
 chart_button.pack(pady=10)

def show_chart(years):
 # This would normally use matplotlib for charting
 # Since we can't include matplotlib in this basic example, we'll show a message
 messagebox.showinfo("Chart Generation", 
 "In a real application, this would generate a matplotlib chart showing growth over time.\n\n"
 "To implement this, you would:\n"
 "1. Install matplotlib (pip install matplotlib)\n"
 "2. Import matplotlib.pyplot as plt\n"
 "3. Create a Figure and embed it in a Tkinter window\n"
 "4. Plot the investment growth data\n\n"
 f"Your investment would grow over {years} years.")

# Create main application window
root = tk.Tk()
root.title("Financial Investment Calculator")
root.geometry("500x450")
root.configure(padx=20, pady=20)

# Use ttk theme for better looking widgets
style = ttk.Style()
style.theme_use("clam") # Options: 'clam', 'alt', 'default', 'classic'

# Header with a frame for visual separation
header_frame = ttk.Frame(root, padding=(0, 0, 0, 10))
header_frame.grid(row=0, column=0, columnspan=2, sticky="ew")
header_frame.grid_columnconfigure(0, weight=1)

header = ttk.Label(header_frame, text="Investment Calculator", font=("Arial", 16))
header.grid(row=0, column=0)

separator = ttk.Separator(root, orient="horizontal")
separator.grid(row=1, column=0, columnspan=2, sticky="ew", pady=5)

# Input form
form_frame = ttk.LabelFrame(root, text="Investment Parameters", padding=10)
form_frame.grid(row=2, column=0, columnspan=2, sticky="nsew", pady=10)
form_frame.grid_columnconfigure(1, weight=1)

# Initial Investment
ttk.Label(form_frame, text="Initial Investment ($):").grid(row=0, column=0, sticky="w", pady=5)
initial_investment = ttk.Entry(form_frame)
initial_investment.grid(row=0, column=1, sticky="ew", pady=5)
initial_investment.insert(0, "1000")

# Annual Contribution
ttk.Label(form_frame, text="Annual Contribution ($):").grid(row=1, column=0, sticky="w", pady=5)
annual_contribution = ttk.Entry(form_frame)
annual_contribution.grid(row=1, column=1, sticky="ew", pady=5)
annual_contribution.insert(0, "0")

# Interest Rate
ttk.Label(form_frame, text="Expected Return (%):").grid(row=2, column=0, sticky="w", pady=5)
interest_rate = ttk.Entry(form_frame)
interest_rate.grid(row=2, column=1, sticky="ew", pady=5)
interest_rate.insert(0, "7")

# Time Period
ttk.Label(form_frame, text="Years:").grid(row=3, column=0, sticky="w", pady=5)
years = ttk.Entry(form_frame)
years.grid(row=3, column=1, sticky="ew", pady=5)
years.insert(0, "10")

# Add some space
ttk.Separator(root, orient="horizontal").grid(row=3, column=0, columnspan=2, sticky="ew", pady=10)

# Calculate Button
calculate_button = ttk.Button(root, text="Calculate Returns", command=calculate_investment)
calculate_button.grid(row=4, column=0, columnspan=2, pady=10)

# Results Label
result_frame = ttk.Frame(root, padding=10)
result_frame.grid(row=5, column=0, columnspan=2, sticky="ew", pady=5)
result_frame.grid_columnconfigure(0, weight=1)

result_label = ttk.Label(result_frame, text="Future Value: $0.00", font=("Arial", 12))
result_label.grid(row=0, column=0)

# Breakdown button (initially hidden)
breakdown_button = ttk.Button(root, text="View Year-by-Year Breakdown", command=show_breakdown)
breakdown_button.grid(row=7, column=0, columnspan=2, pady=5)
breakdown_button.grid_remove() # Hide initially

# Global variable to store calculation results
investment_data = {}

# Configure grid expansion
root.grid_rowconfigure(2, weight=1)
root.grid_columnconfigure(0, weight=1)

root.mainloop()

In this enhanced version, we’ve used several more advanced features:

The ttk module that provides themed widgets (more modern look)
Organizational widgets like LabelFrame and Separator for better visual structure
A Treeview widget to display tabular data in the breakdown
A placeholder for charting (which would normally use matplotlib)

Packaging Your Application

Once your application is working as expected, you might want to distribute it to colleagues. Here’s how to convert it to a standalone executable (no Python installation required):

Install PyInstaller:

pip install pyinstaller

Create your executable:

pyinstaller --onefile --windowed investment_calculator.py

This will create a dist folder containing a single .exe file you can share.

Building a Simple Expense Tracker

Let’s create another finance-related application: a basic expense tracker. This will introduce a few new Tkinter concepts:

import tkinter as tk
from tkinter import ttk, messagebox
import json
import os
from datetime import datetime

class ExpenseTracker:
 def __init__(self, root):
 self.root = root
 self.root.title("Expense Tracker")
 self.root.geometry("800x600")
 self.root.configure(padx=20, pady=20)
 
 # Data storage
 self.expenses = []
 self.data_file = "expenses.json"
 self.load_data()
 
 # Create UI
 self.create_widgets()
 
 def create_widgets(self):
 # Main container
 main_frame = ttk.Frame(self.root)
 main_frame.pack(fill="both", expand=True)
 
 # Left panel - Add Expense
 left_panel = ttk.LabelFrame(main_frame, text="Add New Expense")
 left_panel.pack(side="left", fill="both", expand=True, padx=(0, 10), pady=10)
 
 # Date selector
 ttk.Label(left_panel, text="Date:").grid(row=0, column=0, sticky="w", pady=5, padx=10)
 self.date_entry = ttk.Entry(left_panel)
 self.date_entry.grid(row=0, column=1, sticky="ew", pady=5, padx=10)
 self.date_entry.insert(0, datetime.now().strftime("%Y-%m-%d"))
 
 # Amount entry
 ttk.Label(left_panel, text="Amount ($):").grid(row=1, column=0, sticky="w", pady=5, padx=10)
 self.amount_entry = ttk.Entry(left_panel)
 self.amount_entry.grid(row=1, column=1, sticky="ew", pady=5, padx=10)
 
 # Category dropdown
 ttk.Label(left_panel, text="Category:").grid(row=2, column=0, sticky="w", pady=5, padx=10)
 self.categories = ["Food", "Transportation", "Housing", "Entertainment", "Utilities", "Other"]
 self.category_var = tk.StringVar()
 self.category_dropdown = ttk.Combobox(left_panel, textvariable=self.category_var)
 self.category_dropdown['values'] = self.categories
 self.category_dropdown.grid(row=2, column=1, sticky="ew", pady=5, padx=10)
 self.category_dropdown.current(0)
 
 # Description entry
 ttk.Label(left_panel, text="Description:").grid(row=3, column=0, sticky="w", pady=5, padx=10)
 self.description_entry = ttk.Entry(left_panel)
 self.description_entry.grid(row=3, column=1, sticky="ew", pady=5, padx=10)
 
 # Add button
 add_button = ttk.Button(left_panel, text="Add Expense", command=self.add_expense)
 add_button.grid(row=4, column=0, columnspan=2, pady=15)
 
 # Reporting section
 report_frame = ttk.Frame(left_panel)
 report_frame.grid(row=5, column=0, columnspan=2, sticky="ew", pady=10)
 
 ttk.Label(report_frame, text="Total Expenses: ").pack(side="left")
 self.total_label = ttk.Label(report_frame, text="$0.00")
 self.total_label.pack(side="left")
 
 # Right panel - Expense List
 right_panel = ttk.LabelFrame(main_frame, text="Expense History")
 right_panel.pack(side="right", fill="both", expand=True, padx=(10, 0), pady=10)
 
 # Create treeview
 columns = ("Date", "Amount", "Category", "Description")
 self.expense_table = ttk.Treeview(right_panel, columns=columns, show="headings")
 
 # Configure columns
 for col in columns:
 self.expense_table.heading(col, text=col)
 width = 150 if col == "Description" else 100
 self.expense_table.column(col, width=width)
 
 # Add scrollbar
 scrollbar = ttk.Scrollbar(right_panel, orient="vertical", command=self.expense_table.yview)
 scrollbar.pack(side="right", fill="y")
 self.expense_table.configure(yscrollcommand=scrollbar.set)
 self.expense_table.pack(expand=True, fill="both", padx=5, pady=5)
 
 # Add right-click menu for deleting entries
 self.context_menu = tk.Menu(self.root, tearoff=0)
 self.context_menu.add_command(label="Delete", command=self.delete_expense)
 self.expense_table.bind("<Button-3>", self.show_context_menu)
 
 # Configure column weights
 left_panel.grid_columnconfigure(1, weight=1)
 
 # Populate table with saved data
 self.update_expense_table()
 
 def add_expense(self):
 try:
 date = self.date_entry.get()
 amount = float(self.amount_entry.get())
 category = self.category_var.get()
 description = self.description_entry.get()
 
 # Validate inputs
 if not date or not category or amount <= 0:
 messagebox.showerror("Input Error", "Please enter valid values for all fields.")
 return
 
 # Add to expenses list
 expense = {
 "date": date,
 "amount": amount,
 "category": category,
 "description": description
 }
 self.expenses.append(expense)
 
 # Save data
 self.save_data()
 
 # Update UI
 self.update_expense_table()
 
 # Clear inputs
 self.amount_entry.delete(0, tk.END)
 self.description_entry.delete(0, tk.END)
 self.date_entry.delete(0, tk.END)
 self.date_entry.insert(0, datetime.now().strftime("%Y-%m-%d"))
 
 except ValueError:
 messagebox.showerror("Input Error", "Please enter a valid amount.")
 
 def update_expense_table(self):
 # Clear existing entries
 for row in self.expense_table.get_children():
 self.expense_table.delete(row)
 
 # Sort expenses by date (newest first)
 sorted_expenses = sorted(self.expenses, key=lambda x: x["date"], reverse=True)
 
 # Add expenses to table
 for expense in sorted_expenses:
 self.expense_table.insert("", "end", values=(
 expense["date"],
 f"${expense['amount']:.2f}",
 expense["category"],
 expense["description"]
 ))
 
 # Update total
 total = sum(expense["amount"] for expense in self.expenses)
 self.total_label.config(text=f"${total:.2f}")
 
 def show_context_menu(self, event):
 # Get the item under cursor
 item = self.expense_table.identify_row(event.y)
 if item:
 self.expense_table.selection_set(item)
 self.context_menu.post(event.x_root, event.y_root)
 
 def delete_expense(self):
 # Get selected item
 selected = self.expense_table.selection()
 if not selected:
 return
 
 # Confirm deletion
 if messagebox.askyesno("Confirm Delete", "Are you sure you want to delete this expense?"):
 # Get the index from selection
 item_id = selected[0]
 item_index = self.expense_table.index(item_id)
 
 # Remove from data
 if 0 <= item_index < len(self.expenses):
 self.expenses.pop(item_index)
 self.save_data()
 self.update_expense_table()
 
 def load_data(self):
 try:
 if os.path.exists(self.data_file):
 with open(self.data_file, "r") as file:
 self.expenses = json.load(file)
 except Exception as e:
 messagebox.showerror("Data Error", f"Error loading data: {str(e)}")
 self.expenses = []
 
 def save_data(self):
 try:
 with open(self.data_file, "w") as file:
 json.dump(self.expenses, file, indent=4)
 except Exception as e:
 messagebox.showerror("Data Error", f"Error saving data: {str(e)}")

# Create and run the application
if __name__ == "__main__":
 root = tk.Tk()
 app = ExpenseTracker(root)
 root.mainloop()

This expense tracker application introduces several new concepts:

Object-Oriented Approach: Using a class to organise the application
Combobox Widget: For selecting from a predefined list
Context Menu: Right-click menu for actions like deletion
Data Persistence: Saving/loading data to/from a JSON file
Event Binding: Connecting events (like right-click) to handlers

Advanced Tkinter Topics

If you want to take your Tkinter applications further, here are some advanced topics worth exploring:

1. Custom Styling with Themes

The ttk module (themed Tkinter) supports customisation through themes. You can create a custom look for your application:

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Custom Styled App")

# Get the default style object
style = ttk.Style()

# Change the theme
style.theme_use('clam') # Options include: 'clam', 'alt', 'default', 'classic'

# Configure specific elements
style.configure('TButton', 
 foreground='navy',
 background='lightblue', 
 font=('Arial', 11, 'bold'),
 padding=10)

style.configure('TLabel',
 font=('Arial', 12),
 padding=5)

# Create a custom style for specific widgets
style.configure('Danger.TButton',
 foreground='white',
 background='red',
 font=('Arial', 11, 'bold'))

# Using the styles
normal_button = ttk.Button(root, text="Normal Button")
normal_button.pack(pady=10)

danger_button = ttk.Button(root, text="Delete", style='Danger.TButton')
danger_button.pack(pady=10)

root.mainloop()

This just scratches the surface. You can define custom styles for almost every widget property, though note that not all styling options work the same across different operating systems.

For more complex visualisations, the Canvas widget provides a drawing surface:

import tkinter as tk
import math

root = tk.Tk()
root.title("Financial Pie Chart")
root.geometry("400x400")

# Create a canvas
canvas = tk.Canvas(root, width=300, height=300, bg='white')
canvas.pack(pady=20)

# Sample data (expense categories and values)
expenses = {
 "Housing": 1200,
 "Food": 500,
 "Transportation": 300,
 "Entertainment": 200,
 "Utilities": 250,
 "Other": 150
}

# Calculate total
total = sum(expenses.values())

# Define colors
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#c2c2f0', '#ffb3e6']

# Draw pie chart
cx, cy, r = 150, 150, 100 # center x, center y, radius
start_angle = 0

for i, (category, value) in enumerate(expenses.items()):
 # Calculate angle for this segment
 angle = 360 * (value / total)
 
 # Convert to radians for math functions
 end_angle = start_angle + angle
 start_rad = math.radians(start_angle)
 end_rad = math.radians(end_angle)
 
 # Create the arc/slice
 canvas.create_arc(cx-r, cy-r, cx+r, cy+r, 
 start=start_angle, extent=angle,
 fill=colors[i % len(colors)], outline='white', width=2)
 
 # Calculate position for label
 mid_rad = math.radians(start_angle + angle/2)
 label_r = r * 0.7 # Place label at 70% of radius
 label_x = cx + label_r * math.cos(mid_rad)
 label_y = cy + label_r * math.sin(mid_rad)
 
 # Draw label
 canvas.create_text(label_x, label_y, text=f"{category}\n{value/total:.1%}", 
 font=("Arial", 8), fill="black")
 
 # Move to next segment
 start_angle = end_angle

# Add a title
canvas.create_text(cx, 30, text="Monthly Expenses", font=("Arial", 16, "bold"))

root.mainloop()

The Canvas widget can be used for all kinds of custom graphics, from charts and graphs to custom UI elements and even simple animations.

3. Multithreading for Long-Running Tasks

When performing calculations or operations that might take time, you should use threading to keep the UI responsive:

import tkinter as tk
from tkinter import ttk
import threading
import time

def long_running_task():
 # Simulate a complex calculation or API call
 for i in range(10):
 # Update progress from the worker thread
 # Note: we use root.after to schedule UI updates from the main thread
 progress_var = (i + 1) * 10
 root.after(0, progress_bar.config, {"value": progress_var})
 root.after(0, progress_label.config, {"text": f"Processing: {progress_var}%"})
 time.sleep(0.5) # Simulate work
 
 # Enable the button when done
 root.after(0, calculate_button.config, {"state": "normal"})
 root.after(0, progress_label.config, {"text": "Calculation complete!"})

def start_calculation():
 # Disable button during calculation
 calculate_button.config(state="disabled")
 progress_label.config(text="Starting calculation...")
 
 # Start the task in a separate thread
 thread = threading.Thread(target=long_running_task)
 thread.daemon = True # Thread will exit when main program exits
 thread.start()

root = tk.Tk()
root.title("Threaded Operations")
root.geometry("400x200")
root.configure(padx=20, pady=20)

# Create progress bar
progress_bar = ttk.Progressbar(root, orient="horizontal", length=300, mode="determinate")
progress_bar.pack(pady=20)

# Status label
progress_label = ttk.Label(root, text="Ready")
progress_label.pack(pady=10)

# Button to start calculation
calculate_button = ttk.Button(root, text="Run Financial Analysis", command=start_calculation)
calculate_button.pack(pady=10)

root.mainloop()

This pattern is very important for finance applications where you might be running complex calculations or API calls that would otherwise freeze the UI.

4. Creating a Portfolio Tracker with Multiple Windows

Let’s create a more complex application that demonstrates multiple windows, menus, and data visualisation:

import tkinter as tk
from tkinter import ttk, messagebox, simpledialog
import json
import os
from datetime import datetime
import random # For demo data; you'd use real APIs in production

class PortfolioTracker:
 def __init__(self, root):
 self.root = root
 self.root.title("Investment Portfolio Tracker")
 self.root.geometry("800x600")
 self.root.configure(padx=20, pady=20)
 
 # Data storage
 self.portfolio = {}
 self.data_file = "portfolio_data.json"
 self.load_data()
 
 # Create UI
 self.create_widgets()
 self.create_menu()
 
 def create_menu(self):
 menubar = tk.Menu(self.root)
 
 # File menu
 file_menu = tk.Menu(menubar, tearoff=0)
 file_menu.add_command(label="New Portfolio", command=self.new_portfolio)
 file_menu.add_command(label="Save", command=self.save_data)
 file_menu.add_separator()
 file_menu.add_command(label="Exit", command=self.root.quit)
 menubar.add_cascade(label="File", menu=file_menu)
 
 # Portfolio menu
 portfolio_menu = tk.Menu(menubar, tearoff=0)
 portfolio_menu.add_command(label="Add Investment", command=self.add_investment_dialog)
 portfolio_menu.add_command(label="Rebalance Portfolio", command=self.rebalance_portfolio)
 menubar.add_cascade(label="Portfolio", menu=portfolio_menu)
 
 # Analysis menu
 analysis_menu = tk.Menu(menubar, tearoff=0)
 analysis_menu.add_command(label="Risk Analysis", command=self.show_risk_analysis)
 analysis_menu.add_command(label="Performance Chart", command=self.show_performance_chart)
 menubar.add_cascade(label="Analysis", menu=analysis_menu)
 
 # Help menu
 help_menu = tk.Menu(menubar, tearoff=0)
 help_menu.add_command(label="About", command=self.show_about)
 menubar.add_cascade(label="Help", menu=help_menu)
 
 self.root.config(menu=menubar)
 
 def create_widgets(self):
 # Main container with notebook (tabbed interface)
 self.notebook = ttk.Notebook(self.root)
 self.notebook.pack(fill="both", expand=True)
 
 # Create tabs
 self.overview_tab = ttk.Frame(self.notebook)
 self.stocks_tab = ttk.Frame(self.notebook)
 self.bonds_tab = ttk.Frame(self.notebook)
 self.cash_tab = ttk.Frame(self.notebook)
 
 self.notebook.add(self.overview_tab, text="Portfolio Overview")
 self.notebook.add(self.stocks_tab, text="Stocks")
 self.notebook.add(self.bonds_tab, text="Bonds")
 self.notebook.add(self.cash_tab, text="Cash & Equivalents")
 
 # Set up the overview tab
 self.setup_overview_tab()
 
 # Set up asset-specific tabs
 self.setup_asset_tab(self.stocks_tab, "stock")
 self.setup_asset_tab(self.bonds_tab, "bond")
 self.setup_asset_tab(self.cash_tab, "cash")
 
 def setup_overview_tab(self):
 # Summary frame at top
 summary_frame = ttk.LabelFrame(self.overview_tab, text="Portfolio Summary")
 summary_frame.pack(fill="x", padx=10, pady=10)
 
 # Portfolio value display
 value_frame = ttk.Frame(summary_frame)
 value_frame.pack(fill="x", padx=10, pady=10)
 
 ttk.Label(value_frame, text="Total Portfolio Value:").grid(row=0, column=0, padx=5, pady=5)
 self.total_value_label = ttk.Label(value_frame, text="$0.00", font=("Arial", 12, "bold"))
 self.total_value_label.grid(row=0, column=1, padx=5, pady=5)
 
 # Asset allocation frame
 allocation_frame = ttk.LabelFrame(self.overview_tab, text="Asset Allocation")
 allocation_frame.pack(fill="both", expand=True, padx=10, pady=10)
 
 # Placeholder for chart - in a real app, use matplotlib or similar
 allocation_canvas = tk.Canvas(allocation_frame, bg="white", height=250)
 allocation_canvas.pack(fill="both", expand=True, padx=10, pady=10)
 
 # Placeholder text (replace with actual chart)
 allocation_canvas.create_text(
 allocation_canvas.winfo_reqwidth() // 2, 
 allocation_canvas.winfo_reqheight() // 2,
 text="[Asset Allocation Chart Would Be Here]",
 font=("Arial", 14)
 )
 
 # Recent performance
 performance_frame = ttk.LabelFrame(self.overview_tab, text="Recent Performance")
 performance_frame.pack(fill="x", padx=10, pady=10)
 
 # Basic stats in grid layout
 stats = [
 ("1 Day:", "+0.3%"),
 ("1 Week:", "-0.7%"),
 ("1 Month:", "+2.1%"),
 ("3 Months:", "+5.4%"),
 ("YTD:", "+12.3%"),
 ("1 Year:", "+15.8%")
 ]
 
 for i, (label, value) in enumerate(stats):
 row, col = i // 3, i % 3
 ttk.Label(performance_frame, text=label).grid(row=row, column=col*2, sticky="e", padx=5, pady=5)
 
 # Color based on positive/negative
 color = "green" if "+" in value else "red"
 value_label = ttk.Label(performance_frame, text=value)
 value_label.grid(row=row, column=col*2+1, sticky="w", padx=5, pady=5)
 # Note: ttk doesn't support direct text color, would need custom style
 
 # Update displays
 self.update_overview()
 
 def setup_asset_tab(self, tab, asset_type):
 # Create treeview for this asset type
 columns = ("Name", "Ticker", "Shares/Units", "Price", "Value", "Allocation")
 tree = ttk.Treeview(tab, columns=columns, show="headings")
 
 # Configure columns
 for col in columns:
 tree.heading(col, text=col)
 width = 150 if col == "Name" else 100
 tree.column(col, width=width)
 
 # Add scrollbar
 scrollbar = ttk.Scrollbar(tab, orient="vertical", command=tree.yview)
 scrollbar.pack(side="right", fill="y")
 tree.configure(yscrollcommand=scrollbar.set)
 tree.pack(expand=True, fill="both", padx=5, pady=5)
 
 # Store reference to this tree
 setattr(self, f"{asset_type}_tree", tree)
 
 # Add button frame
 button_frame = ttk.Frame(tab)
 button_frame.pack(fill="x", padx=5, pady=5)
 
 # Add buttons
 add_button = ttk.Button(
 button_frame, 
 text=f"Add {asset_type.title()}", 
 command=lambda: self.add_investment_dialog(asset_type)
 )
 add_button.pack(side="left", padx=5)
 
 remove_button = ttk.Button(
 button_frame, 
 text="Remove Selected", 
 command=lambda: self.remove_investment(asset_type, getattr(self, f"{asset_type}_tree"))
 )
 remove_button.pack(side="left", padx=5)
 
 # Bind double-click to edit
 tree.bind("<Double-1>", lambda event, at=asset_type: self.edit_investment(at, event))
 
 def add_investment_dialog(self, asset_type=None):
 if asset_type is None:
 # Let user select asset type if not specified
 options = ["stock", "bond", "cash"]
 asset_type = simpledialog.askstring(
 "Asset Type", 
 "Enter asset type (stock, bond, cash):",
 parent=self.root
 )
 if asset_type not in options:
 messagebox.showerror("Error", "Invalid asset type")
 return
 
 # Create dialog window
 dialog = tk.Toplevel(self.root)
 dialog.title(f"Add {asset_type.title()} Investment")
 dialog.geometry("400x300")
 dialog.configure(padx=20, pady=20)
 dialog.transient(self.root) # Set as transient to main window
 dialog.grab_set() # Modal dialog
 
 # Form fields
 ttk.Label(dialog, text="Name:").grid(row=0, column=0, sticky="w", pady=5)
 name_entry = ttk.Entry(dialog, width=30)
 name_entry.grid(row=0, column=1, sticky="ew", pady=5)
 
 ttk.Label(dialog, text="Ticker/Symbol:").grid(row=1, column=0, sticky="w", pady=5)
 ticker_entry = ttk.Entry(dialog, width=30)
 ticker_entry.grid(row=1, column=1, sticky="ew", pady=5)
 
 ttk.Label(dialog, text="Shares/Units:").grid(row=2, column=0, sticky="w", pady=5)
 shares_entry = ttk.Entry(dialog, width=30)
 shares_entry.grid(row=2, column=1, sticky="ew", pady=5)
 
 ttk.Label(dialog, text="Price per Share/Unit:").grid(row=3, column=0, sticky="w", pady=5)
 price_entry = ttk.Entry(dialog, width=30)
 price_entry.grid(row=3, column=1, sticky="ew", pady=5)
 
 ttk.Label(dialog, text="Purchase Date:").grid(row=4, column=0, sticky="w", pady=5)
 date_entry = ttk.Entry(dialog, width=30)
 date_entry.grid(row=4, column=1, sticky="ew", pady=5)
 date_entry.insert(0, datetime.now().strftime("%Y-%m-%d"))
 
 # Add Button
 def save_investment():
 try:
 name = name_entry.get().strip()
 ticker = ticker_entry.get().strip()
 shares = float(shares_entry.get())
 price = float(price_entry.get())
 date = date_entry.get()
 
 if not name or not ticker or shares <= 0 or price <= 0:
 messagebox.showerror("Input Error", "Please enter valid values for all fields.")
 return
 
 # Create unique ID
 investment_id = f"{asset_type}_{ticker}_{len(self.portfolio) + 1}"
 
 # Add to portfolio
 self.portfolio[investment_id] = {
 "id": investment_id,
 "name": name,
 "ticker": ticker,
 "shares": shares,
 "price": price,
 "purchase_date": date,
 "type": asset_type
 }
 
 # Update UI
 self.save_data()
 self.update_display()
 
 # Close dialog
 dialog.destroy()
 
 except ValueError:
 messagebox.showerror("Input Error", "Please enter valid numbers for shares and price.")
 
 save_button = ttk.Button(dialog, text="Save Investment", command=save_investment)
 save_button.grid(row=5, column=0, columnspan=2, pady=15)
 
 # Configure grid expansion
 dialog.grid_columnconfigure(1, weight=1)
 
 def edit_investment(self, asset_type, event):
 tree = getattr(self, f"{asset_type}_tree")
 item_id = tree.identify_row(event.y)
 if not item_id:
 return
 
 # Get the values displayed in the treeview
 values = tree.item(item_id, 'values')
 if not values:
 return
 
 # Find the investment in our data
 ticker = values[1] # Assuming ticker is in second column
 investment = None
 investment_id = None
 
 for id, inv in self.portfolio.items():
 if inv["ticker"] == ticker and inv["type"] == asset_type:
 investment = inv
 investment_id = id
 break
 
 if not investment:
 return
 
 # Create dialog window
 dialog = tk.Toplevel(self.root)
 dialog.title(f"Edit {investment['name']}")
 dialog.geometry("400x300")
 dialog.configure(padx=20, pady=20)
 dialog.transient(self.root)
 dialog.grab_set()
 
 # Form fields (pre-filled)
 ttk.Label(dialog, text="Name:").grid(row=0, column=0, sticky="w", pady=5)
 name_entry = ttk.Entry(dialog, width=30)
 name_entry.grid(row=0, column=1, sticky="ew", pady=5)
 name_entry.insert(0, investment["name"])
 
 ttk.Label(dialog, text="Ticker/Symbol:").grid(row=1, column=0, sticky="w", pady=5)
 ticker_entry = ttk.Entry(dialog, width=30)
 ticker_entry.grid(row=1, column=1, sticky="ew", pady=5)
 ticker_entry.insert(0, investment["ticker"])
 
 ttk.Label(dialog, text="Shares/Units:").grid(row=2, column=0, sticky="w", pady=5)
 shares_entry = ttk.Entry(dialog, width=30)
 shares_entry.grid(row=2, column=1, sticky="ew", pady=5)
 shares_entry.insert(0, str(investment["shares"]))
 
 ttk.Label(dialog, text="Price per Share/Unit:").grid(row=3, column=0, sticky="w", pady=5)
 price_entry = ttk.Entry(dialog, width=30)
 price_entry.grid(row=3, column=1, sticky="ew", pady=5)
 price_entry.insert(0, str(investment["price"]))
 
 # Update Button
 def update_investment():
 try:
 name = name_entry.get().strip()
 ticker = ticker_entry.get().strip()
 shares = float(shares_entry.get())
 price = float(price_entry.get())
 
 if not name or not ticker or shares <= 0 or price <= 0:
 messagebox.showerror("Input Error", "Please enter valid values for all fields.")
 return
 
 # Update portfolio
 self.portfolio[investment_id]["name"] = name
 self.portfolio[investment_id]["ticker"] = ticker
 self.portfolio[investment_id]["shares"] = shares
 self.portfolio[investment_id]["price"] = price
 
 # Update UI
 self.save_data()
 self.update_display()
 
 # Close dialog
 dialog.destroy()
 
 except ValueError:
 messagebox.showerror("Input Error", "Please enter valid numbers for shares and price.")
 
 update_button = ttk.Button(dialog, text="Update Investment", command=update_investment)
 update_button.grid(row=5, column=0, columnspan=2, pady=15)
 
 # Configure grid expansion
 dialog.grid_columnconfigure(1, weight=1)
 
 def remove_investment(self, asset_type, tree):
 selected = tree.selection()
 if not selected:
 messagebox.showinfo("Selection Required", "Please select an investment to remove.")
 return
 
 # Confirm deletion
 if not messagebox.askyesno("Confirm Removal", 
 "Are you sure you want to remove the selected investment(s)?"):
 return
 
 # Get the values from the selected items
 for item_id in selected:
 values = tree.item(item_id, 'values')
 ticker = values[1] # Assuming ticker is in second column
 
 # Find and remove the investment from our data
 to_remove = []
 for id, inv in self.portfolio.items():
 if inv["ticker"] == ticker and inv["type"] == asset_type:
 to_remove.append(id)
 
 for id in to_remove:
 del self.portfolio[id]
 
 # Update UI
 self.save_data()
 self.update_display()
 
 def update_display(self):
 # Update all asset type tabs
 self.update_asset_tab("stock")
 self.update_asset_tab("bond")
 self.update_asset_tab("cash")
 
 # Update overview tab
 self.update_overview()
 
 def update_asset_tab(self, asset_type):
 tree = getattr(self, f"{asset_type}_tree")
 
 # Clear existing entries
 for item in tree.get_children():
 tree.delete(item)
 
 # Calculate total portfolio value
 total_value = self.calculate_total_value()
 
 # Add investments to tree
 for id, investment in self.portfolio.items():
 if investment["type"] == asset_type:
 value = investment["shares"] * investment["price"]
 allocation = value / total_value * 100 if total_value > 0 else 0
 
 tree.insert("", "end", values=(
 investment["name"],
 investment["ticker"],
 f"{investment['shares']:.2f}",
 f"${investment['price']:.2f}",
 f"${value:.2f}",
 f"{allocation:.1f}%"
 ))
 
 def update_overview(self):
 # Calculate total value
 total_value = self.calculate_total_value()
 
 # Update value label
 self.total_value_label.config(text=f"${total_value:.2f}")
 
 # In a real app, update charts and other visualizations here
 
 def calculate_total_value(self):
 total = 0
 for id, investment in self.portfolio.items():
 total += investment["shares"] * investment["price"]
 return total
 
 def new_portfolio(self):
 if messagebox.askyesno("New Portfolio", 
 "Are you sure you want to create a new portfolio? This will delete all current data."):
 self.portfolio = {}
 self.save_data()
 self.update_display()
 
 def rebalance_portfolio(self):
 # In a real app, this would be a complex algorithm
 # For now, we'll just show a placeholder dialog
 messagebox.showinfo("Rebalance Portfolio", 
 "In a complete application, this would analyze your portfolio and suggest trades to reach your target allocation.")
 
 def show_risk_analysis(self):
 # Create a new window
 analysis = tk.Toplevel(self.root)
 analysis.title("Risk Analysis")
 analysis.geometry("600x400")
 analysis.configure(padx=20, pady=20)
 
 # Add some placeholder content
 ttk.Label(analysis, text="Portfolio Risk Analysis", font=("Arial", 16, "bold")).pack(pady=10)
 
 # Metrics frame
 metrics_frame = ttk.LabelFrame(analysis, text="Key Risk Metrics")
 metrics_frame.pack(fill="x", padx=10, pady=10)
 
 metrics = [
 ("Beta:", "0.85"),
 ("Sharpe Ratio:", "1.23"),
 ("Standard Deviation:", "12.4%"),
 ("Max Drawdown:", "-15.7%"),
 ("Value at Risk (95%):", "$3,245")
 ]
 
 for i, (label, value) in enumerate(metrics):
 ttk.Label(metrics_frame, text=label).grid(row=i, column=0, sticky="w", padx=5, pady=5)
 ttk.Label(metrics_frame, text=value).grid(row=i, column=1, sticky="w", padx=5, pady=5)
 
 ttk.Label(analysis, text="Note: In a complete application, this would provide detailed risk metrics based on historical data and correlations between your holdings.").pack(pady=10)
 
 def show_performance_chart(self):
 # Create a new window
 chart_window = tk.Toplevel(self.root)
 chart_window.title("Performance Chart")
 chart_window.geometry("800x500")
 chart_window.configure(padx=20, pady=20)
 
 ttk.Label(chart_window, text="Portfolio Performance", font=("Arial", 16, "bold")).pack(pady=10)
 
 # In a real app, you would use matplotlib or another charting library
 # For now, just show a canvas with placeholder text
 canvas = tk.Canvas(chart_window, bg="white", height=400)
 canvas.pack(fill="both", expand=True, padx=10, pady=10)
 
 canvas.create_text(
 canvas.winfo_reqwidth() // 2, 
 canvas.winfo_reqheight() // 2,
 text="[Performance Chart Would Be Here]\n\nIn a complete application, this would be a\ncharting library like Matplotlib showing\nyour portfolio's performance over time.",
 font=("Arial", 14)
 )
 
 def show_about(self):
 messagebox.showinfo("About", "Portfolio Tracker v1.0\n\nCreated with Python and Tkinter\n\nPart of the 'Learning Python in Public' series")
 
 def load_data(self):
 try:
 if os.path.exists(self.data_file):
 with open(self.data_file, "r") as file:
 self.portfolio = json.load(file)
 else:
 # Demo data for first-time users
 self.create_demo_data()
 except Exception as e:
 messagebox.showerror("Data Error", f"Error loading data: {str(e)}")
 self.portfolio = {}
 
 def save_data(self):
 try:
 with open(self.data_file, "w") as file:
 json.dump(self.portfolio, file, indent=4)
 except Exception as e:
 messagebox.showerror("Data Error", f"Error saving data: {str(e)}")
 
 def create_demo_data(self):
 # Create some sample investments
 self.portfolio = {
 "stock_AAPL_1": {
 "id": "stock_AAPL_1",
 "name": "Apple Inc.",
 "ticker": "AAPL",
 "shares": 10,
 "price": 175.50,
 "purchase_date": "2023-01-15",
 "type": "stock"
 },
 "stock_MSFT_2": {
 "id": "stock_MSFT_2",
 "name": "Microsoft Corporation",
 "ticker": "MSFT",
 "shares": 5,
 "price": 325.20,
 "purchase_date": "2023-02-20",
 "type": "stock"
 },
 "bond_TBILL_3": {
 "id": "bond_TBILL_3",
 "name": "US Treasury Bill",
 "ticker": "TBILL",
 "shares": 1,
 "price": 1000.00,
 "purchase_date": "2023-03-10",
 "type": "bond"
 },
 "cash_SAVINGS_4": {
 "id": "cash_SAVINGS_4",
 "name": "High Yield Savings",
 "ticker": "SAVINGS",
 "shares": 1,
 "price": 5000.00,
 "purchase_date": "2023-01-01",
 "type": "cash"
 }
 }

# Creating and running the application when this file is executed directly
if __name__ == "__main__":
 root = tk.Tk()
 app = PortfolioTracker(root)
 root.mainloop()

This portfolio tracker demonstrates several advanced concepts:

Multiple windows and dialogs
Menus and tabbed interfaces
Complex layout with frames and grids
Data persistence and management
Object-oriented design for maintainability

5. Best Practices for Tkinter Applications

As you develop more complex Tkinter applications, keep these best practices in mind:

**Separate UI from Logic: Keep your application logic (calculations, data processing) separate from your UI code (widget creation, layout). This makes your code easier to understand, test, and maintain. Using classes, as shown in the Expense Tracker and Portfolio Tracker examples, is a good way to achieve this. Your functions that perform calculations (calculate_investment) should ideally not directly manipulate widgets too much; instead, they can return values that another function then uses to update the UI.

Use an Object-Oriented Approach: For anything beyond a very simple script, structuring your Tkinter application as a class (or multiple classes) is highly beneficial. This helps in organising your code, managing state, and making your application more scalable. Notice how the ExpenseTracker and PortfolioTracker classes encapsulate all their widgets and methods.

Employ Layout Managers Effectively: Choose between pack, grid, and place wisely. grid is often the most versatile for structured layouts. pack is good for simpler, sequential layouts or side-by-side arrangements within frames. Avoid using place for most of your layout needs as it can make your UI less adaptable to window resizing or font changes, unless you require precise pixel control. Don’t mix grid and pack within the same master window or frame, as it can lead to unexpected behaviour.

Use ttk for a Modern Look: The tkinter.ttk module provides themed widgets that generally look better and more native than the classic Tkinter widgets. Always try to use ttk.Button, ttk.Label, etc., where available.

Keep the UI Responsive: For any tasks that might take more than a fraction of a second (e.g., complex financial calculations, network requests, file operations), run them in a separate thread to prevent the GUI from freezing. Use root.after() or queues to safely update the UI from these background threads, as demonstrated in the multithreading example.

Manage Widget References: When you need to interact with a widget after its creation (e.g., to get its value or update its text), store a reference to it, typically as an instance variable (e.g., self.my_entry = ttk.Entry(…)).

Provide User Feedback: Use labels, message boxes (tkinter.messagebox), or progress bars to inform the user about what the application is doing, especially during longer operations or when errors occur.

Handle Errors Gracefully: Use try-except blocks to catch potential errors (e.g., ValueError when converting entry text to numbers, IOError when dealing with files) and display user-friendly error messages instead of letting the application crash.

Organise with Frames: For complex interfaces, use Frame or ttk.LabelFrame widgets as containers to group related widgets. This makes your layout more modular and easier to manage.

Comment Your Code: Especially in UI programming where widget hierarchies and event bindings can become complex, good comments will help you (and others) understand your code later.

Conclusion: Your Gateway to Desktop Applications Tkinter, while sometimes viewed as old-fashioned, remains an incredibly valuable tool in the Python ecosystem. As we’ve seen, you can go from a simple window to a multi-tabbed, data-driven financial application with relative ease. Its built-in nature means you can quickly prototype ideas or build internal tools without worrying about external dependencies for your users.

For us finance professionals, this opens up a world of possibilities:

Creating custom calculators for specific financial models. Building simple dashboards to track key metrics. Developing tools to automate repetitive data entry or report generation tasks. The examples we’ve explored, from a basic investment calculator to a more comprehensive portfolio tracker, only scratch the surface. The key is to start simple, understand the core concepts of widgets, layout management, and event handling, and then gradually build up complexity.

While newer frameworks might offer more visual flair, Tkinter’s simplicity, stability, and ubiquity make it an excellent starting point for GUI development in Python. I encourage you to take these examples, experiment with them, and see what useful applications you can build to make your financial workflows more efficient and user-friendly!

Web Development Foundations with Python (Python for Finance, part 15)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 07 Aug 2025 00:00:00 +0000

Part 15 of my 17-part series on learning Python as a finance professional

After exploring all the fundamentals of Python programming, it’s time to put those skills to practical use by diving into web development. As a finance manager, I’ve found that building simple web applications can help automate reports, create interactive dashboards, and share financial data across teams.

In this post, I’ll cover three popular approaches to web development with Python:

Option A: Flask - A lightweight web framework
Option B: Django - A full-featured web framework
Option C: Web Scraping - Extracting financial data from websites

Let’s explore each option with practical examples relevant to finance work.

Option A: Flask - Building a Lightweight Financial Dashboard

Flask is perfect when you need a simple web interface without the overhead of a full framework. Let’s build a basic financial dashboard that displays company expense data.

Setting Up Flask

First, we need to install Flask:

# Create and activate your virtual environment first
# Then install Flask
pip install flask

Now, let’s create a simple Flask application in a file called app.py:

from flask import Flask, render_template
import json

app = Flask(__name__)

# Sample financial data (in a real app, this would come from a database)
expense_data = [
 {"month": "January", "marketing": 2400, "operations": 5000, "payroll": 12000},
 {"month": "February", "marketing": 1800, "operations": 5100, "payroll": 12000},
 {"month": "March", "marketing": 2200, "operations": 4800, "payroll": 12500},
 {"month": "April", "marketing": 2500, "operations": 5200, "payroll": 12500}
]

@app.route('/')
def index():
 # Calculate totals
 total_marketing = sum(month["marketing"] for month in expense_data)
 total_operations = sum(month["operations"] for month in expense_data)
 total_payroll = sum(month["payroll"] for month in expense_data)
 grand_total = total_marketing + total_operations + total_payroll
 
 return render_template(
 'dashboard.html', 
 expense_data=expense_data,
 total_marketing=total_marketing,
 total_operations=total_operations,
 total_payroll=total_payroll,
 grand_total=grand_total,
 chart_data=json.dumps(expense_data)
 )

if __name__ == '__main__':
 app.run(debug=True)

Creating Templates

Flask uses templates to generate HTML. Create a templates folder in the same directory as your app.py file, and add a new file called dashboard.html:

<!DOCTYPE html>
<html>
<head>
 <title>Finance Dashboard</title>
 <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
 <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
</head>
<body>
 <div class="container">
 <h1>Quarterly Expense Dashboard</h1>
 
 <div class="summary-box">
 <h2>Q1 + April Expense Summary</h2>
 <p>Total Marketing: ${{ total_marketing }}</p>
 <p>Total Operations: ${{ total_operations }}</p>
 <p>Total Payroll: ${{ total_payroll }}</p>
 <p class="grand-total">Grand Total: ${{ grand_total }}</p>
 </div>
 
 <div class="chart-container">
 <canvas id="expenseChart"></canvas>
 </div>
 
 <table class="expense-table">
 <thead>
 <tr>
 <th>Month</th>
 <th>Marketing</th>
 <th>Operations</th>
 <th>Payroll</th>
 <th>Monthly Total</th>
 </tr>
 </thead>
 <tbody>
 {% for month in expense_data %}
 <tr>
 <td>{{ month.month }}</td>
 <td>${{ month.marketing }}</td>
 <td>${{ month.operations }}</td>
 <td>${{ month.payroll }}</td>
 <td>${{ month.marketing + month.operations + month.payroll }}</td>
 </tr>
 {% endfor %}
 </tbody>
 </table>
 </div>
 
 <script>
 // Parse the data from Flask
 const expenseData = {{ chart_data|safe }};
 
 // Prepare data for Chart.js
 const labels = expenseData.map(item => item.month);
 const marketingData = expenseData.map(item => item.marketing);
 const operationsData = expenseData.map(item => item.operations);
 const payrollData = expenseData.map(item => item.payroll);
 
 // Create the chart
 const ctx = document.getElementById('expenseChart').getContext('2d');
 const expenseChart = new Chart(ctx, {
 type: 'bar',
 data: {
 labels: labels,
 datasets: [
 {
 label: 'Marketing',
 data: marketingData,
 backgroundColor: 'rgba(54, 162, 235, 0.5)'
 },
 {
 label: 'Operations',
 data: operationsData,
 backgroundColor: 'rgba(255, 206, 86, 0.5)'
 },
 {
 label: 'Payroll',
 data: payrollData,
 backgroundColor: 'rgba(255, 99, 132, 0.5)'
 }
 ]
 },
 options: {
 responsive: true,
 scales: {
 x: {
 stacked: false
 },
 y: {
 stacked: false,
 beginAtZero: true
 }
 }
 }
 });
 </script>
</body>
</html>

Adding CSS Styles

Create a static folder in the same directory as your app.py file, and add a file called styles.css:

body {
 font-family: Arial, sans-serif;
 line-height: 1.6;
 margin: 0;
 padding: 20px;
 background-color: #f5f5f5;
}

.container {
 max-width: 1000px;
 margin: 0 auto;
 background-color: white;
 padding: 20px;
 border-radius: 5px;
 box-shadow: 0 0 10px rgba(0,0,0,0.1);
}

h1 {
 color: #333;
 text-align: center;
 margin-bottom: 30px;
}

.summary-box {
 background-color: #f9f9f9;
 padding: 15px;
 border-radius: 5px;
 margin-bottom: 20px;
}

.grand-total {
 font-weight: bold;
 font-size: 1.2em;
 color: #0066cc;
}

.chart-container {
 margin-bottom: 30px;
 height: 400px;
}

.expense-table {
 width: 100%;
 border-collapse: collapse;
}

.expense-table th, .expense-table td {
 padding: 10px;
 text-align: right;
 border-bottom: 1px solid #ddd;
}

.expense-table th:first-child, .expense-table td:first-child {
 text-align: left;
}

.expense-table th {
 background-color: #f2f2f2;
}

.expense-table tr:hover {
 background-color: #f5f5f5;
}

Running the Flask Application

Run your application by executing:

python app.py

Then open your browser to http://127.0.0.1:5000/ to see your dashboard!

Project Structure

Your project should have this structure:

financial-dashboard/
├── app.py
├── static/
│ └── styles.css
└── templates/
 └── dashboard.html

Option B: Django - Building a Full-Featured Financial Application

Django is a more robust framework that’s perfect for complex applications. Let’s create a simplified financial transaction tracker.

Installing Django

pip install django

Creating a New Django Project

django-admin startproject financial_tracker
cd financial_tracker
python manage.py startapp transactions

Defining Models

Edit transactions/models.py:

from django.db import models
from django.utils import timezone

class Category(models.Model):
 name = models.CharField(max_length=100)
 
 def __str__(self):
 return self.name
 
 class Meta:
 verbose_name_plural = "Categories"

class Transaction(models.Model):
 TRANSACTION_TYPES = [
 ('income', 'Income'),
 ('expense', 'Expense'),
 ]
 
 amount = models.DecimalField(max_digits=10, decimal_places=2)
 description = models.CharField(max_length=255)
 category = models.ForeignKey(Category, on_delete=models.CASCADE)
 transaction_type = models.CharField(max_length=10, choices=TRANSACTION_TYPES)
 date = models.DateField(default=timezone.now)
 
 def __str__(self):
 return f"{self.description} - ${self.amount}"

Registering the App

Edit financial_tracker/settings.py to add the app to INSTALLED_APPS:

INSTALLED_APPS = [
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',
 'transactions', # Add your app here
]

Creating Migrations and Admin Interface

python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser

from django.contrib import admin
from .models import Category, Transaction

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
 list_display = ('name',)
 search_fields = ('name',)

@admin.register(Transaction)
class TransactionAdmin(admin.ModelAdmin):
 list_display = ('description', 'amount', 'category', 'transaction_type', 'date')
 list_filter = ('category', 'transaction_type', 'date')
 search_fields = ('description',)
 date_hierarchy = 'date'

Creating Views

Edit transactions/views.py:

from django.shortcuts import render
from django.db.models import Sum
from .models import Transaction

def dashboard(request):
 # Get recent transactions
 recent_transactions = Transaction.objects.order_by('-date')[:10]
 
 # Calculate summary statistics
 total_income = Transaction.objects.filter(transaction_type='income').aggregate(Sum('amount'))['amount__sum'] or 0
 total_expenses = Transaction.objects.filter(transaction_type='expense').aggregate(Sum('amount'))['amount__sum'] or 0
 net_balance = total_income - total_expenses
 
 # Get monthly data for chart
 from django.db.models.functions import TruncMonth
 monthly_data = Transaction.objects.annotate(month=TruncMonth('date')) \
 .values('month', 'transaction_type') \
 .annotate(total=Sum('amount')) \
 .order_by('month')
 
 # Prepare data for chart
 months = []
 income_data = []
 expense_data = []
 
 current_month = None
 current_income = 0
 current_expense = 0
 
 for item in monthly_data:
 month_str = item['month'].strftime('%b %Y')
 
 if current_month != month_str:
 if current_month is not None:
 months.append(current_month)
 income_data.append(current_income)
 expense_data.append(current_expense)
 
 current_month = month_str
 current_income = 0
 current_expense = 0
 
 if item['transaction_type'] == 'income':
 current_income = float(item['total'])
 else:
 current_expense = float(item['total'])
 
 # Add the last month
 if current_month is not None:
 months.append(current_month)
 income_data.append(current_income)
 expense_data.append(current_expense)
 
 context = {
 'recent_transactions': recent_transactions,
 'total_income': total_income,
 'total_expenses': total_expenses,
 'net_balance': net_balance,
 'months': months,
 'income_data': income_data,
 'expense_data': expense_data,
 }
 
 return render(request, 'transactions/dashboard.html', context)

Setting Up URLs

Create transactions/urls.py:

from django.urls import path
from . import views

urlpatterns = [
 path('', views.dashboard, name='dashboard'),
]

Then edit financial_tracker/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
 path('admin/', admin.site.urls),
 path('', include('transactions.urls')),
]

Creating Templates

Create directories:

mkdir -p transactions/templates/transactions

Create transactions/templates/transactions/dashboard.html:

{% load static %}
<!DOCTYPE html>
<html>
<head>
 <title>Financial Tracker</title>
 <link rel="stylesheet" href="{% static 'transactions/styles.css' %}">
 <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
</head>
<body>
 <div class="container">
 <h1>Financial Tracker Dashboard</h1>
 
 <div class="summary-container">
 <div class="summary-box income">
 <h3>Total Income</h3>
 <p>${{ total_income }}</p>
 </div>
 
 <div class="summary-box expenses">
 <h3>Total Expenses</h3>
 <p>${{ total_expenses }}</p>
 </div>
 
 <div class="summary-box balance">
 <h3>Net Balance</h3>
 <p>${{ net_balance }}</p>
 </div>
 </div>
 
 <div class="chart-container">
 <canvas id="financialChart"></canvas>
 </div>
 
 <div class="recent-transactions">
 <h2>Recent Transactions</h2>
 <table>
 <thead>
 <tr>
 <th>Date</th>
 <th>Description</th>
 <th>Category</th>
 <th>Type</th>
 <th>Amount</th>
 </tr>
 </thead>
 <tbody>
 {% for transaction in recent_transactions %}
 <tr class="{{ transaction.transaction_type }}">
 <td>{{ transaction.date }}</td>
 <td>{{ transaction.description }}</td>
 <td>{{ transaction.category }}</td>
 <td>{{ transaction.transaction_type|title }}</td>
 <td>${{ transaction.amount }}</td>
 </tr>
 {% endfor %}
 </tbody>
 </table>
 </div>
 </div>
 
 <script>
 // Get data from context
 const months = {{ months|safe }};
 const incomeData = {{ income_data|safe }};
 const expenseData = {{ expense_data|safe }};
 
 // Create chart
 const ctx = document.getElementById('financialChart').getContext('2d');
 const financialChart = new Chart(ctx, {
 type: 'bar',
 data: {
 labels: months,
 datasets: [
 {
 label: 'Income',
 data: incomeData,
 backgroundColor: 'rgba(75, 192, 192, 0.5)',
 borderColor: 'rgba(75, 192, 192, 1)',
 borderWidth: 1
 },
 {
 label: 'Expenses',
 data: expenseData,
 backgroundColor: 'rgba(255, 99, 132, 0.5)',
 borderColor: 'rgba(255, 99, 132, 1)',
 borderWidth: 1
 }
 ]
 },
 options: {
 responsive: true,
 scales: {
 y: {
 beginAtZero: true
 }
 }
 }
 });
 </script>
</body>
</html>

Adding Static Files

Create directories:

mkdir -p transactions/static/transactions

Create transactions/static/transactions/styles.css:

body {
 font-family: Arial, sans-serif;
 line-height: 1.6;
 margin: 0;
 padding: 20px;
 background-color: #f5f5f5;
}

.container {
 max-width: 1200px;
 margin: 0 auto;
 background-color: white;
 padding: 20px;
 border-radius: 5px;
 box-shadow: 0 0 10px rgba(0,0,0,0.1);
}

h1 {
 color: #333;
 text-align: center;
 margin-bottom: 30px;
}

.summary-container {
 display: flex;
 justify-content: space-between;
 margin-bottom: 30px;
}

.summary-box {
 flex: 1;
 padding: 20px;
 margin: 0 10px;
 border-radius: 5px;
 text-align: center;
}

.income {
 background-color: #d4edda;
 color: #155724;
}

.expenses {
 background-color: #f8d7da;
 color: #721c24;
}

.balance {
 background-color: #cce5ff;
 color: #004085;
}

.summary-box h3 {
 margin-top: 0;
}

.summary-box p {
 font-size: 24px;
 font-weight: bold;
 margin-bottom: 0;
}

.chart-container {
 margin-bottom: 30px;
 height: 400px;
}

.recent-transactions h2 {
 margin-bottom: 15px;
}

table {
 width: 100%;
 border-collapse: collapse;
}

th, td {
 padding: 12px 15px;
 text-align: left;
 border-bottom: 1px solid #ddd;
}

th {
 background-color: #f2f2f2;
}

tr.income {
 background-color: rgba(212, 237, 218, 0.2);
}

tr.expense {
 background-color: rgba(248, 215, 218, 0.2);
}

tr:hover {
 background-color: #f5f5f5;
}

Running the Django Application

python manage.py runserver

Access the admin interface at http://127.0.0.1:8000/admin/ and add some sample data. Then view your dashboard at http://127.0.0.1:8000/.

Option C: Web Scraping - Extracting Financial Data

Let’s create a simple web scraper to extract stock price data.

Installing Required Libraries

pip install requests beautifulsoup4 pandas matplotlib

Creating a Stock Price Scraper

Create a file named stock_scraper.py:

import requests
from bs4 import BeautifulSoup
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime

def get_stock_data(ticker):
 """Scrape basic stock information for the given ticker."""
 url = f"https://finance.yahoo.com/quote/{ticker}"
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 }
 
 try:
 response = requests.get(url, headers=headers)
 response.raise_for_status() # Raise exception for 4XX/5XX responses
 
 soup = BeautifulSoup(response.text, 'html.parser')
 
 # Extract the company name
 company_name = soup.find('h1', class_='D(ib)').text.strip()
 
 # Extract current price
 current_price = soup.find('fin-streamer', {'data-field': 'regularMarketPrice'}).text
 
 # Extract previous close
 prev_close_label = soup.find('td', text='Previous Close')
 prev_close = prev_close_label.find_next_sibling('td').text if prev_close_label else 'N/A'
 
 # Extract open price
 open_label = soup.find('td', text='Open')
 open_price = open_label.find_next_sibling('td').text if open_label else 'N/A'
 
 # Extract day range
 day_range_label = soup.find('td', text="Day's Range")
 day_range = day_range_label.find_next_sibling('td').text if day_range_label else 'N/A'
 
 # Extract 52 week range
 week_range_label = soup.find('td', text='52 Week Range')
 week_range = week_range_label.find_next_sibling('td').text if week_range_label else 'N/A'
 
 # Extract volume
 volume_label = soup.find('td', text='Volume')
 volume = volume_label.find_next_sibling('td').text if volume_label else 'N/A'
 
 # Extract market cap
 market_cap_label = soup.find('td', text='Market Cap')
 market_cap = market_cap_label.find_next_sibling('td').text if market_cap_label else 'N/A'
 
 # Extract P/E ratio
 pe_ratio_label = soup.find('td', text='PE Ratio (TTM)')
 pe_ratio = pe_ratio_label.find_next_sibling('td').text if pe_ratio_label else 'N/A'
 
 # Create a dictionary with all the data
 stock_data = {
 'Company': company_name,
 'Ticker': ticker,
 'Current Price': current_price,
 'Previous Close': prev_close,
 'Open': open_price,
 'Day Range': day_range,
 '52 Week Range': week_range,
 'Volume': volume,
 'Market Cap': market_cap,
 'PE Ratio (TTM)': pe_ratio,
 'Last Updated': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 }
 
 return stock_data
 
 except Exception as e:
 print(f"Error fetching data for {ticker}: {e}")
 return None

def get_historical_data(ticker, period='1mo'):
 """Scrape historical price data for charting."""
 url = f"https://finance.yahoo.com/quote/{ticker}/history"
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 }
 
 # For a proper application, you would use Yahoo Finance API or another service
 # This is a simplified example for demonstration purposes
 
 # Instead of actually scraping (which is complex for the history page),
 # we'll use pandas_datareader which is more reliable for historical data
 import pandas_datareader.data as web
 
 try:
 start_date = pd.Timestamp.now() - pd.DateOffset(months=1)
 if period == '3mo':
 start_date = pd.Timestamp.now() - pd.DateOffset(months=3)
 elif period == '6mo':
 start_date = pd.Timestamp.now() - pd.DateOffset(months=6)
 elif period == '1y':
 start_date = pd.Timestamp.now() - pd.DateOffset(years=1)
 
 end_date = pd.Timestamp.now()
 
 # Get data from Yahoo Finance
 df = web.DataReader(ticker, 'yahoo', start_date, end_date)
 return df
 
 except Exception as e:
 print(f"Error fetching historical data for {ticker}: {e}")
 return None

def plot_stock_price(ticker, period='1mo'):
 """Plot the historical stock price."""
 df = get_historical_data(ticker, period)
 
 if df is None:
 return None
 
 plt.figure(figsize=(12, 6))
 plt.plot(df.index, df['Close'], label=f'{ticker} Close Price')
 plt.title(f'{ticker} Stock Price - Last {period}')
 plt.xlabel('Date')
 plt.ylabel('Price ($)')
 plt.grid(True)
 plt.legend()
 
 # Save the figure
 file_name = f"{ticker}_{period}_price_chart.png"
 plt.savefig(file_name)
 plt.close()
 
 return file_name

def main():
 """Main function to demonstrate the stock scraper."""
 # List of stock tickers to analyze
 tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN']
 
 # Create a DataFrame to store all stock data
 all_data = []
 
 for ticker in tickers:
 print(f"Fetching data for {ticker}...")
 stock_data = get_stock_data(ticker)
 
 if stock_data:
 all_data.append(stock_data)
 
 # Generate and save a price chart
 chart_file = plot_stock_price(ticker, '3mo')
 if chart_file:
 print(f"Chart saved as {chart_file}")
 
 # Convert to DataFrame for easier analysis and display
 if all_data:
 df = pd.DataFrame(all_data)
 print("\nStock Data Summary:")
 print(df)
 
 # Save to CSV
 df.to_csv('stock_data_summary.csv', index=False)
 print("Data saved to stock_data_summary.csv")

if __name__ == "__main__":
 main()

Running the Web Scraper

Execute the script:

pip install pandas-datareader # Additional dependency for the example
python stock_scraper.py

This script will:

Fetch current stock data for Apple, Microsoft, Google, and Amazon
Generate price charts for each stock
Save all data to a CSV file

Deploying Your Web Application

Once you’ve built your web application, you’ll want to deploy it so others can access it.

Deploying to Render (Free Alternative to Heroku)

Render is a good free alternative since Heroku no longer offers a free tier.

For Flask Applications:

Create a requirements.txt file:

flask==2.0.1
gunicorn==20.1.0

Create a Procfile:

web: gunicorn app:app

Create a new project on GitHub with your app code
Sign up for a Render account at render.com
Create a new Web Service
Connect your GitHub repository
Configure settings:
- Environment: Python 3
- Build Command: pip install -r requirements.txt
- Start Command: gunicorn app:app
Click “Create Web Service”

For Django Applications:

Update settings.py:

import os

# Add your Render domain to allowed hosts
ALLOWED_HOSTS = ['localhost', '127.0.0.1', 'your-app-name.onrender.com']

# Static files settings
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

# Configure database (use SQLite for simplicity)
DATABASES = {
 'default': {
 'ENGINE': 'django.db.backends.sqlite3',
 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
 }
}

Create a requirements.txt file:

django==4.0.0
gunicorn==20.1.0
whitenoise==5.3.0

Create a Procfile:

web: gunicorn financial_tracker.wsgi

Follow the same steps as Flask to deploy on Render

Conclusion

In this post, we’ve covered three different approaches to web development with Python:

Flask - A lightweight framework perfect for simple financial dashboards and internal tools
Django - A full-featured framework ideal for complex financial applications with user authentication, database models, and admin interfaces
Web Scraping - A technique to extract financial data from websites for analysis and visualisation

As a finance professional, I’ve found that these web development skills can significantly enhance your workflow, whether it’s creating simple dashboards for expense tracking, building full-featured financial applications, or scraping financial data for analysis.

In the next post, we’ll explore building desktop GUI applications with Tkinter, which can be useful for creating financial calculators and other tools that don’t require a web interface.

Let me know in the comments which approach you’re most interested in exploring further, or if you have any questions about implementing these techniques for your specific financial use case.

Note: Remember that web scraping should be done responsibly. Always check a website’s robots.txt file and terms of service before scraping, and ensure you’re not overloading their servers with requests.

Introduction to Object-Oriented Programming (OOP) in Python (Python for Finance, part 14)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 31 Jul 2025 00:00:00 +0000

As a finance professional learning Python, I’ve discovered that Object-Oriented Programming (OOP) is one of those concepts that initially seems abstract but becomes incredibly powerful once you understand it. In this post, I’ll break down what OOP is, why it matters, and how we can use it to model financial concepts in our code.

What is Object-Oriented Programming?

In the simplest terms, OOP is a programming paradigm that organises code around “objects” rather than functions and logic. An object bundles related data (attributes) and behaviours (methods) together.

Think of it this way: in finance, we deal with various entities like accounts, investments, transactions, and financial instruments. Each has specific properties and actions associated with them. OOP gives us a way to represent these real-world entities in our code.

Key Concepts in OOP

1. Classes vs. Objects

Classes are like blueprints or templates that define the structure and behaviour of a particular type of object. Objects are specific instances created from these classes.

In finance terms:

A class might be BankAccount, which describes what all bank accounts have in common
An object would be a specific account, like my_checking_account

Let’s create our first class:

class BankAccount:
 """A simple bank account class"""
 
 def __init__(self, account_number, holder_name, balance=0.0):
 """Initialize a new bank account"""
 self.account_number = account_number
 self.holder_name = holder_name
 self.balance = balance
 self.transactions = []

2. The `init` Method and `self`

The __init__ method (short for “initialise”) is a special method that runs automatically whenever we create a new object from a class. It’s sometimes called a constructor.

self is a reference to the specific instance of the class that’s being created or operated on. It’s how the object keeps track of its own data.

Let’s create some bank account objects:

# Creating instances of the BankAccount class
checking = BankAccount("CHK123456", "John Doe", 1000.00)
savings = BankAccount("SAV789012", "John Doe", 5000.00)

# Accessing attributes
print(f"Account Holder: {checking.holder_name}")
print(f"Checking Balance: ${checking.balance:.2f}")
print(f"Savings Balance: ${savings.balance:.2f}")

Output:

Account Holder: John Doe
Checking Balance: $1000.00
Savings Balance: $5000.00

3. Methods: Adding Behaviour to Our Objects

Methods are functions that belong to a class. They define what actions objects of that class can perform.

Let’s add some methods to our BankAccount class:

class BankAccount:
 """A simple bank account class"""
 
 def __init__(self, account_number, holder_name, balance=0.0):
 """Initialize a new bank account"""
 self.account_number = account_number
 self.holder_name = holder_name
 self.balance = balance
 self.transactions = []
 
 # Record opening deposit if initial balance was provided
 if balance > 0:
 self.transactions.append(("DEPOSIT", balance, "Initial deposit"))
 
 def deposit(self, amount, description="Deposit"):
 """Add funds to the account"""
 if amount <= 0:
 raise ValueError("Deposit amount must be positive")
 
 self.balance += amount
 self.transactions.append(("DEPOSIT", amount, description))
 return self.balance
 
 def withdraw(self, amount, description="Withdrawal"):
 """Remove funds from the account if sufficient balance exists"""
 if amount <= 0:
 raise ValueError("Withdrawal amount must be positive")
 
 if amount > self.balance:
 raise ValueError("Insufficient funds")
 
 self.balance -= amount
 self.transactions.append(("WITHDRAWAL", amount, description))
 return self.balance
 
 def get_balance(self):
 """Return the current balance"""
 return self.balance
 
 def print_statement(self):
 """Print a simple account statement"""
 print(f"\nAccount Statement for {self.account_number} ({self.holder_name})")
 print(f"Current Balance: ${self.balance:.2f}")
 print("\nTransaction History:")
 print("Type | Amount | Description")
 print("-" * 50)
 
 for trans_type, amount, description in self.transactions:
 print(f"{trans_type:<10} | ${amount:<9.2f} | {description}")

Now let’s use our enhanced BankAccount class:

# Create a new account
account = BankAccount("CHK123456", "John Doe", 1000.00)

# Perform some transactions
account.deposit(500, "Paycheck")
account.withdraw(200, "Grocery shopping")
account.deposit(1000, "Tax refund")
account.withdraw(800, "Rent payment")

# Print a statement
account.print_statement()

This would output:

Account Statement for CHK123456 (John Doe)
Current Balance: $1500.00

Transaction History:
Type | Amount | Description
--------------------------------------------------
DEPOSIT | $1000.00 | Initial deposit
DEPOSIT | $500.00 | Paycheck
WITHDRAWAL | $200.00 | Grocery shopping
DEPOSIT | $1000.00 | Tax refund
WITHDRAWAL | $800.00 | Rent payment

The Four Pillars of OOP

1. Encapsulation

Encapsulation refers to bundling data and methods that operate on that data within a single unit (the class) and restricting direct access to some of an object’s components. It helps protect the integrity of the data.

In Python, we use naming conventions to indicate that certain attributes or methods should be treated as private (although Python doesn’t strictly enforce this):

class BankAccount:
 def __init__(self, account_number, holder_name, balance=0.0):
 self.account_number = account_number
 self.holder_name = holder_name
 self._balance = balance # Prefixed with underscore to indicate it's "protected"
 self.__transaction_id = 1000 # Double underscore for "private" attributes
 self.transactions = []
 
 if balance > 0:
 self.__record_transaction("DEPOSIT", balance, "Initial deposit")
 
 def __record_transaction(self, trans_type, amount, description):
 """Private method to record transactions with IDs"""
 self.transactions.append((self.__transaction_id, trans_type, amount, description))
 self.__transaction_id += 1
 
 def deposit(self, amount, description="Deposit"):
 if amount <= 0:
 raise ValueError("Deposit amount must be positive")
 
 self._balance += amount
 self.__record_transaction("DEPOSIT", amount, description)
 return self._balance
 
 # Other methods...

With encapsulation:

We’ve made _balance protected (indicated by single underscore)
We’ve made __transaction_id and __record_transaction private (indicated by double underscore)
We still provide public methods to interact with these protected attributes safely

2. Inheritance

Inheritance allows a class to inherit attributes and methods from another class. The original class is called the parent or base class, and the new class is the child or derived class.

Let’s create specialised account types that inherit from our BankAccount class:

class SavingsAccount(BankAccount):
 """A bank account that earns interest"""
 
 def __init__(self, account_number, holder_name, balance=0.0, interest_rate=0.01):
 # Call the parent class's __init__ method
 super().__init__(account_number, holder_name, balance)
 self.interest_rate = interest_rate
 
 def apply_interest(self):
 """Apply interest to the account balance"""
 interest = self._balance * self.interest_rate
 self.deposit(interest, "Interest payment")
 return self._balance


class CheckingAccount(BankAccount):
 """A bank account for frequent transactions with overdraft protection"""
 
 def __init__(self, account_number, holder_name, balance=0.0, overdraft_limit=100.0):
 super().__init__(account_number, holder_name, balance)
 self.overdraft_limit = overdraft_limit
 
 def withdraw(self, amount, description="Withdrawal"):
 """Override withdraw to implement overdraft protection"""
 if amount <= 0:
 raise ValueError("Withdrawal amount must be positive")
 
 if amount > (self._balance + self.overdraft_limit):
 raise ValueError(f"Amount exceeds balance plus overdraft limit of ${self.overdraft_limit}")
 
 self._balance -= amount
 self._record_transaction("WITHDRAWAL", amount, description)
 
 if self._balance < 0:
 self._record_transaction("FEE", 15, "Overdraft fee")
 self._balance -= 15
 
 return self._balance

Now we can use these specialised account types:

# Create a savings account
savings = SavingsAccount("SAV12345", "John Doe", 5000.00, 0.02) # 2% interest
savings.deposit(1000, "Bonus")
savings.apply_interest() # Apply interest
savings.print_statement()

# Create a checking account with overdraft protection
checking = CheckingAccount("CHK67890", "John Doe", 500.00, 200.00) # $200 overdraft limit
checking.withdraw(600, "Emergency expense") # This will use the overdraft
checking.print_statement()

3. Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common base class. The most common use is when a parent class reference is used to refer to a child class object.

Let’s see polymorphism in action with our bank accounts:

def process_month_end(account):
 """Process month-end activities for any type of account"""
 print(f"Processing month-end for {account.account_number}")
 
 # Apply specific actions based on account type
 if isinstance(account, SavingsAccount):
 account.apply_interest()
 print("Applied interest to savings account")
 elif isinstance(account, CheckingAccount):
 if account.get_balance() < 100:
 print("Low balance warning issued")
 
 # Common actions for all account types
 account.print_statement()

# Create different account types
accounts = [
 BankAccount("BNK-001", "Alice Smith", 1500),
 SavingsAccount("SAV-002", "Bob Johnson", 5000, 0.025),
 CheckingAccount("CHK-003", "Carol Williams", 750, 300)
]

# Process all accounts the same way, but with type-specific behaviors
for account in accounts:
 process_month_end(account)

This demonstrates polymorphism—we’re treating different account types through a common interface, but each responds according to its specific implementation.

4. Abstraction

Abstraction means hiding complex implementation details and showing only the necessary features of an object. Python supports abstraction through abstract base classes (ABCs).

Let’s create an abstract base class for financial instruments:

from abc import ABC, abstractmethod

class FinancialInstrument(ABC):
 """Abstract base class for financial instruments"""
 
 def __init__(self, symbol, name, current_price):
 self.symbol = symbol
 self.name = name
 self.current_price = current_price
 
 @abstractmethod
 def calculate_value(self, quantity):
 """Calculate the value of holding a certain quantity"""
 pass
 
 @abstractmethod
 def risk_level(self):
 """Return the risk level of this instrument"""
 pass
 
 def update_price(self, new_price):
 """Update the current price"""
 self.current_price = new_price


class Stock(FinancialInstrument):
 """A stock/equity financial instrument"""
 
 def __init__(self, symbol, name, current_price, beta=1.0):
 super().__init__(symbol, name, current_price)
 self.beta = beta # Beta measures volatility
 
 def calculate_value(self, quantity):
 return self.current_price * quantity
 
 def risk_level(self):
 if self.beta < 0.8:
 return "Low"
 elif self.beta < 1.2:
 return "Medium"
 else:
 return "High"


class Bond(FinancialInstrument):
 """A bond financial instrument"""
 
 def __init__(self, symbol, name, current_price, yield_rate, maturity_date):
 super().__init__(symbol, name, current_price)
 self.yield_rate = yield_rate
 self.maturity_date = maturity_date
 
 def calculate_value(self, quantity):
 return self.current_price * quantity
 
 def risk_level(self):
 # Simple risk assessment based on yield
 if self.yield_rate < 0.03:
 return "Low"
 elif self.yield_rate < 0.06:
 return "Medium"
 else:
 return "High"
 
 def calculate_income(self, face_value, quantity):
 """Calculate annual income from the bond"""
 return face_value * quantity * self.yield_rate

Note that we can’t create an instance of FinancialInstrument directly because it’s abstract. We must create one of its concrete subclasses.

# Try to create an abstract class instance - this would fail
# instrument = FinancialInstrument("ABST", "Abstract Instrument", 100) # This will raise an error

# Create concrete implementations
apple_stock = Stock("AAPL", "Apple Inc.", 175.50, 1.2)
govt_bond = Bond("GOVT10", "10-Year Treasury", 98.75, 0.035, "2033-05-15")

# Use polymorphism
instruments = [apple_stock, govt_bond]
portfolio_value = 0

for instrument in instruments:
 quantity = 10 # Assume we own 10 of each
 value = instrument.calculate_value(quantity)
 portfolio_value += value
 print(f"{instrument.symbol} ({instrument.name}):")
 print(f" Risk Level: {instrument.risk_level()}")
 print(f" Value of 10 units: ${value:.2f}")

print(f"\nTotal portfolio value: ${portfolio_value:.2f}")

Practical Financial Application: Portfolio Management

Let’s build a simple portfolio management system that demonstrates these OOP concepts together:

class Asset:
 """Base class for any asset that can be held in a portfolio"""
 
 def __init__(self, symbol, name):
 self.symbol = symbol
 self.name = name
 
 @abstractmethod
 def current_value(self):
 """Return the current value of this asset"""
 pass
 
 def __str__(self):
 return f"{self.symbol} - {self.name}"


class Cash(Asset):
 """Cash holdings in a portfolio"""
 
 def __init__(self, amount, currency="USD"):
 super().__init__(currency, f"Cash ({currency})")
 self.amount = amount
 
 def current_value(self):
 return self.amount


class Stock(Asset):
 """Stock/equity asset"""
 
 def __init__(self, symbol, name, shares, price_per_share):
 super().__init__(symbol, name)
 self.shares = shares
 self.price = price_per_share
 
 def current_value(self):
 return self.shares * self.price
 
 def update_price(self, new_price):
 self.price = new_price


class Bond(Asset):
 """Bond asset"""
 
 def __init__(self, symbol, name, face_value, quantity, market_price, yield_rate):
 super().__init__(symbol, name)
 self.face_value = face_value
 self.quantity = quantity
 self.market_price = market_price
 self.yield_rate = yield_rate
 
 def current_value(self):
 return self.market_price * self.quantity
 
 def annual_income(self):
 return self.face_value * self.quantity * self.yield_rate


class Portfolio:
 """A collection of financial assets"""
 
 def __init__(self, name, owner):
 self.name = name
 self.owner = owner
 self.assets = []
 
 def add_asset(self, asset):
 """Add an asset to the portfolio"""
 self.assets.append(asset)
 
 def remove_asset(self, symbol):
 """Remove an asset from the portfolio by symbol"""
 self.assets = [asset for asset in self.assets if asset.symbol != symbol]
 
 def total_value(self):
 """Calculate the total value of all assets"""
 return sum(asset.current_value() for asset in self.assets)
 
 def asset_allocation(self):
 """Calculate the percentage allocation of each asset class"""
 total = self.total_value()
 allocation = {}
 
 for asset in self.assets:
 asset_type = type(asset).__name__
 asset_value = asset.current_value()
 
 if asset_type not in allocation:
 allocation[asset_type] = 0
 
 allocation[asset_type] += asset_value
 
 # Convert to percentages
 for asset_type in allocation:
 allocation[asset_type] = (allocation[asset_type] / total) * 100
 
 return allocation
 
 def print_summary(self):
 """Print a summary of the portfolio"""
 print(f"\n=== {self.name} Portfolio Summary ===")
 print(f"Owner: {self.owner}")
 print(f"Total Value: ${self.total_value():.2f}")
 
 print("\nAssets:")
 print(f"{'Symbol':<10} {'Type':<10} {'Name':<30} {'Value':<15}")
 print("-" * 65)
 
 for asset in self.assets:
 asset_type = type(asset).__name__
 print(f"{asset.symbol:<10} {asset_type:<10} {asset.name:<30} ${asset.current_value():<15.2f}")
 
 print("\nAsset Allocation:")
 allocation = self.asset_allocation()
 for asset_type, percentage in allocation.items():
 print(f"{asset_type}: {percentage:.2f}%")

Now let’s use our portfolio management system:

# Create a retirement portfolio
retirement = Portfolio("Retirement", "John Doe")

# Add assets
retirement.add_asset(Cash(15000))
retirement.add_asset(Stock("AAPL", "Apple Inc.", 50, 175.50))
retirement.add_asset(Stock("MSFT", "Microsoft Corporation", 25, 330.75))
retirement.add_asset(Bond("T-BOND", "Treasury Bond", 1000, 10, 980, 0.035))

# Print the portfolio summary
retirement.print_summary()

# Update a stock price and see the impact
for asset in retirement.assets:
 if isinstance(asset, Stock) and asset.symbol == "AAPL":
 print(f"\nUpdating {asset.symbol} price from ${asset.price} to $190.25")
 asset.update_price(190.25)

# Print the updated portfolio
retirement.print_summary()

Why OOP Matters: Organising and Reusing Code

OOP offers several advantages that become increasingly important as your projects grow:

Organisation: OOP helps structure your code around real-world entities, making it easier to understand and maintain.
Reusability: Inherit and extend classes rather than rewriting code from scratch.
Modularity: Each class handles a specific entity, making it easier to update, test, and debug.
Encapsulation: Hide implementation details and protect data integrity.
Real-world modelling: Financial concepts translate naturally to OOP—assets, accounts, transactions, and portfolios all become classes.

Common OOP Pitfalls to Avoid

Overengineering: Don’t create complex class hierarchies if simpler solutions work. Start with basic classes and refine as needed.
Inheritance Overuse: Not everything needs inheritance. Consider composition (having one class contain instances of another) when appropriate.
Forgetting self: Always include self as the first parameter in instance methods.
Misusing Private Attributes: Don’t circumvent the leading underscore convention—it’s there for a reason.

Practical Exercise: Build a Loan Calculator Class

As a finance professional, understanding loan calculations is essential. Let’s create a Loan class that encapsulates different loan calculations:

class Loan:
 """A class representing a loan with various calculation methods"""
 
 def __init__(self, principal, annual_interest_rate, years, compounding_periods=12):
 self.principal = principal
 self.annual_rate = annual_interest_rate
 self.years = years
 self.compounding_periods = compounding_periods
 
 def monthly_payment(self):
 """Calculate the fixed monthly payment"""
 # Convert annual rate to monthly rate
 r = self.annual_rate / 12
 n = self.years * 12
 
 # Use the formula: PMT = P * (r * (1+r)^n) / ((1+r)^n - 1)
 numerator = r * (1 + r) ** n
 denominator = (1 + r) ** n - 1
 
 if denominator == 0:
 return self.principal / n # Zero interest edge case
 
 return self.principal * (numerator / denominator)
 
 def total_payment(self):
 """Calculate the total amount paid over the loan term"""
 return self.monthly_payment() * self.years * 12
 
 def total_interest(self):
 """Calculate the total interest paid over the loan term"""
 return self.total_payment() - self.principal
 
 def amortization_schedule(self, show_every_period=True):
 """Generate an amortization schedule"""
 schedule = []
 remaining_balance = self.principal
 monthly_rate = self.annual_rate / 12
 payment = self.monthly_payment()
 
 for period in range(1, self.years * 12 + 1):
 interest_payment = remaining_balance * monthly_rate
 principal_payment = payment - interest_payment
 remaining_balance -= principal_payment
 
 if show_every_period or period % 12 == 0 or period == 1:
 schedule.append({
 'period': period,
 'payment': payment,
 'principal': principal_payment,
 'interest': interest_payment,
 'remaining': max(0, remaining_balance) # Avoid negative zero
 })
 
 return schedule
 
 def print_loan_summary(self):
 """Print a summary of the loan details"""
 print("\n=== Loan Summary ===")
 print(f"Principal: ${self.principal:.2f}")
 print(f"Annual Interest Rate: {self.annual_rate:.2%}")
 print(f"Term: {self.years} years")
 print(f"Monthly Payment: ${self.monthly_payment():.2f}")
 print(f"Total Payments: ${self.total_payment():.2f}")
 print(f"Total Interest: ${self.total_interest():.2f}")
 
 def print_amortization_table(self, periods_per_year=1):
 """Print an amortization table"""
 schedule = self.amortization_schedule(show_every_period=False)
 
 print("\n=== Amortization Schedule ===")
 print(f"{'Period':<10} {'Payment':<15} {'Principal':<15} {'Interest':<15} {'Remaining':<15}")
 print("-" * 70)
 
 for entry in schedule:
 print(f"{entry['period']:<10} ${entry['payment']:<14.2f} ${entry['principal']:<14.2f} ${entry['interest']:<14.2f} ${entry['remaining']:<14.2f}")


# Example use:
home_loan = Loan(350000, 0.045, 30) # $350,000 at 4.5% for 30 years
home_loan.print_loan_summary()
home_loan.print_amortization_table()

car_loan = Loan(30000, 0.039, 5) # $30,000 at 3.9% for 5 years
car_loan.print_loan_summary()

Conclusion

Object-Oriented Programming provides a powerful way to structure your Python code, especially when modelling real-world financial entities and processes. By organising your code into classes with attributes and methods, you create reusable, maintainable components that can grow with your applications.

In this post, we covered:

The basics of classes and objects
Method creation and the role of self
The four pillars of OOP: encapsulation, inheritance, polymorphism, and abstraction
Practical financial applications using OOP principles

As your Python skills progress, you’ll find OOP concepts becoming increasingly valuable, especially for financial modelling, analysis, and application development.

Next Steps

Practice creating your own financial classes (e.g., Investment, FinancialReport)
Explore more complex inheritance relationships
Learn about dataclasses (Python 3.7+) for even cleaner class definitions
Look into property decorators for more controlled attribute access

Data Visualisation Basics in Python (Python for Finance, part 13)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 24 Jul 2025 00:00:00 +0000

Welcome to the thirteenth post in our Python learning series! In this article, we’ll explore how to create effective data visualisations in Python - an essential skill for analysing and communicating financial data.

If you’ve been following along, you’ve already learned how to work with data using NumPy and pandas. Now it’s time to bring that data to life through visualisation. Whether you’re analysing budget trends, tracking investment performance, or presenting financial reports, the right visualisation can transform raw numbers into actionable insights.

Why Data Visualisation Matters in Finance

As a finance professional, I’ve found that visualisations can:

Quickly identify trends that might be missed in spreadsheets
Effectively communicate financial performance to stakeholders
Spot outliers or anomalies in financial data
Compare actual results against forecasts more intuitively
Support data-driven decision making

Let’s dive into the tools and techniques we’ll need to create these visualisations.

Setting Up Your Environment

First, make sure you have the necessary libraries installed. If you’re using Anaconda, you likely already have these. If not, install them using pip:

pip install matplotlib seaborn pandas numpy

Let’s import the libraries we’ll need:

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

# Set the style for our plots
plt.style.use('seaborn-v0_8-whitegrid') # Clean, professional look

Matplotlib Basics: Your Visualisation Foundation

Matplotlib is the cornerstone of Python visualisation. While it can be a bit verbose, it gives you complete control over your plots.

Creating a Simple Line Plot

Let’s start with a simple line chart showing monthly revenue:

# Sample financial data
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
revenue = [45000, 48000, 47500, 52000, 56000, 58000]

# Create a simple line plot
plt.figure(figsize=(10, 6)) # Set figure size (width, height in inches)
plt.plot(months, revenue, marker='o', linewidth=2, color='#004D99')
plt.title('Monthly Revenue (2025)', fontsize=15)
plt.xlabel('Month', fontsize=12)
plt.ylabel('Revenue ($)', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

This code creates a line chart showing monthly revenue. Let’s break down what each part does:

plt.figure(figsize=(10, 6)): Sets the size of our chart (width by height in inches)
plt.plot(): Creates the actual line plot with data points
marker='o': Adds circular markers at each data point
linewidth=2: Makes the line thicker for better visibility
color='#004D99': Sets a professional blue colour using hex code
The remaining functions add title, labels, and grid lines

Bar Charts for Comparison

Bar charts are excellent for comparing categorical data, like department expenses:

departments = ['Finance', 'Marketing', 'Operations', 'IT', 'HR']
expenses = [65000, 72000, 89000, 56000, 48000]

plt.figure(figsize=(10, 6))
bars = plt.bar(departments, expenses, color='#2D7BB6')

# Add value labels on top of each bar
for bar in bars:
 height = bar.get_height()
 plt.text(bar.get_x() + bar.get_width()/2., height + 1000,
 f'${height:,}', ha='center', va='bottom')

plt.title('Q1 Department Expenses', fontsize=15)
plt.xlabel('Department', fontsize=12)
plt.ylabel('Expenses ($)', fontsize=12)
plt.ylim(0, max(expenses) * 1.15) # Add some headroom for the labels
plt.tight_layout()
plt.show()

This code adds a nice touch by displaying the actual values above each bar, making it easy to see the exact numbers while still getting the visual comparison.

Pie Charts for Part-to-Whole Relationships

Pie charts can be effective for showing how parts make up a whole, such as budget allocation:

categories = ['Salaries', 'Marketing', 'R&D', 'Operations', 'Other']
budget_allocation = [45, 15, 20, 12, 8] # percentages

plt.figure(figsize=(10, 7))
plt.pie(budget_allocation, labels=categories, autopct='%1.1f%%',
 startangle=90, shadow=False, explode=[0.05, 0, 0, 0, 0],
 colors=['#4878D0', '#EE854A', '#6ACC64', '#D65F5F', '#956CB4'])
plt.title('Annual Budget Allocation', fontsize=15)
plt.axis('equal') # Equal aspect ratio ensures the pie chart is circular
plt.tight_layout()
plt.show()

The explode parameter slightly separates the ‘Salaries’ slice to emphasise it as the largest expense.

Histograms for Distribution Analysis

Histograms help visualise the distribution of continuous data. This is useful for analysing things like daily stock returns:

# Generate some random daily returns data (normally distributed)
np.random.seed(42) # For reproducibility
daily_returns = np.random.normal(0.001, 0.02, 250) # Mean, std dev, number of trading days

plt.figure(figsize=(10, 6))
plt.hist(daily_returns, bins=25, alpha=0.7, color='#2D7BB6', edgecolor='black')
plt.axvline(x=0, color='r', linestyle='--', alpha=0.7) # Add line at x=0
plt.title('Distribution of Daily Stock Returns', fontsize=15)
plt.xlabel('Daily Return', fontsize=12)
plt.ylabel('Frequency', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

The red vertical line at x=0 helps distinguish between positive and negative returns.

Scatter Plots for Correlation Analysis

Scatter plots are perfect for examining relationships between two variables, like the correlation between marketing spend and revenue:

# Generate sample data
np.random.seed(42)
marketing_spend = np.random.normal(50000, 15000, 30) # 30 months of data
revenue = 3.5 * marketing_spend + np.random.normal(20000, 40000, 30) # Revenue with noise

plt.figure(figsize=(10, 6))
plt.scatter(marketing_spend, revenue, alpha=0.7, color='#2D7BB6', edgecolor='black')

# Add a trend line
z = np.polyfit(marketing_spend, revenue, 1)
p = np.poly1d(z)
plt.plot(marketing_spend, p(marketing_spend), "r--", alpha=0.7)

plt.title('Correlation: Marketing Spend vs. Revenue', fontsize=15)
plt.xlabel('Marketing Spend ($)', fontsize=12)
plt.ylabel('Revenue ($)', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

The trend line helps visualise the overall relationship between the variables.

Customising Matplotlib Plots

Now let’s look at some additional customisation options that can make your financial visualisations more professional and effective.

Creating Subplots

Often you’ll want to show multiple related charts together. Subplots are perfect for this:

# Generate some financial data
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
revenue = [45000, 48000, 47500, 52000, 56000, 58000]
expenses = [38000, 42000, 40000, 43000, 45000, 47000]
profit = [r - e for r, e in zip(revenue, expenses)]

# Create subplots
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))

# First subplot: Revenue and Expenses
ax1.plot(months, revenue, 'o-', label='Revenue', linewidth=2, color='#2D7BB6')
ax1.plot(months, expenses, 's-', label='Expenses', linewidth=2, color='#EE854A')
ax1.set_title('Revenue vs. Expenses (H1 2025)', fontsize=15)
ax1.set_ylabel('Amount ($)', fontsize=12)
ax1.grid(True, linestyle='--', alpha=0.7)
ax1.legend()

# Second subplot: Profit
bars = ax2.bar(months, profit, color='#6ACC64')
# Add value labels on top of each bar
for bar in bars:
 height = bar.get_height()
 ax2.text(bar.get_x() + bar.get_width()/2., height + 500,
 f'${height:,}', ha='center', va='bottom')
 
ax2.set_title('Monthly Profit (H1 2025)', fontsize=15)
ax2.set_xlabel('Month', fontsize=12)
ax2.set_ylabel('Profit ($)', fontsize=12)
ax2.grid(True, linestyle='--', alpha=0.7)

plt.tight_layout()
plt.show()

This code creates two charts stacked vertically: a line chart comparing revenue and expenses, and a bar chart showing the resulting profit.

Adding Annotations

Annotations can add important context to your charts:

quarters = ['Q1 2024', 'Q2 2024', 'Q3 2024', 'Q4 2024', 'Q1 2025']
stock_price = [45.50, 48.75, 52.30, 54.10, 62.80]

fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(quarters, stock_price, 'o-', linewidth=2, color='#2D7BB6')

# Add annotation for significant event
ax.annotate('New Product Launch', 
 xy=(3, 54.10), # Position to point at
 xytext=(3, 58), # Text position
 arrowprops=dict(facecolor='black', shrink=0.05, width=1.5),
 fontsize=12)

# Add annotation for earnings report
ax.annotate('Earnings Beat\nEstimates by 15%', 
 xy=(4, 62.80), # Position to point at
 xytext=(3.5, 67), # Text position
 arrowprops=dict(facecolor='black', shrink=0.05, width=1.5),
 fontsize=12)

ax.set_title('Quarterly Stock Price', fontsize=15)
ax.set_ylabel('Price ($)', fontsize=12)
ax.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

Saving Your Plots

Save your visualisations for reports or presentations:

plt.figure(figsize=(10, 6))
plt.plot(months, revenue, marker='o', linewidth=2, color='#004D99')
plt.title('Monthly Revenue (2025)', fontsize=15)
plt.xlabel('Month', fontsize=12)
plt.ylabel('Revenue ($)', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()

# Save in different formats
plt.savefig('monthly_revenue.png', dpi=300) # High-resolution PNG
plt.savefig('monthly_revenue.pdf') # PDF for publications
plt.savefig('monthly_revenue.svg') # Scalable vector graphic

Advanced Visualisation with Seaborn

Seaborn builds on matplotlib and provides a higher-level interface for creating attractive statistical graphics.

Heatmaps for Correlation Matrices

Heatmaps are excellent for visualising correlation matrices of financial instruments:

# Generate correlated returns for 5 assets
np.random.seed(42)
n = 1000 # Number of days
# Create correlated returns for 5 assets
corr_matrix = np.array([
 [1.0, 0.7, 0.5, 0.3, 0.1],
 [0.7, 1.0, 0.6, 0.4, 0.2],
 [0.5, 0.6, 1.0, 0.7, 0.5],
 [0.3, 0.4, 0.7, 1.0, 0.6],
 [0.1, 0.2, 0.5, 0.6, 1.0]
])
asset_names = ['S&P 500', 'NASDAQ', 'DJIA', 'Treasury Bonds', 'Gold']

plt.figure(figsize=(10, 8))
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', 
 xticklabels=asset_names, yticklabels=asset_names,
 linewidths=0.5, vmin=-1, vmax=1)
plt.title('Asset Correlation Matrix', fontsize=15)
plt.tight_layout()
plt.show()

This creates a heatmap showing the correlation between different assets, with values annotated directly on the cells.

Box Plots for Distribution Comparison

Box plots are useful for comparing distributions, like monthly expenses across departments:

# Create sample data
departments = ['Finance', 'Marketing', 'Operations', 'IT', 'HR']
data = {
 'Department': np.repeat(departments, 20),
 'Monthly_Expense': [
 *np.random.normal(5000, 800, 20), # Finance
 *np.random.normal(8500, 1200, 20), # Marketing
 *np.random.normal(7200, 1500, 20), # Operations
 *np.random.normal(6800, 1000, 20), # IT
 *np.random.normal(4500, 600, 20) # HR
 ]
}
df = pd.DataFrame(data)

plt.figure(figsize=(12, 7))
sns.boxplot(x='Department', y='Monthly_Expense', data=df, palette='muted')
plt.title('Monthly Expense Distribution by Department', fontsize=15)
plt.xlabel('Department', fontsize=12)
plt.ylabel('Monthly Expense ($)', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

Box plots show the median, quartiles, and outliers, giving you a complete picture of each distribution.

Pair Plots for Multi-variable Analysis

When analysing multiple variables, pair plots can show all possible scatter plots at once:

# Generate sample financial metrics for companies
np.random.seed(42)
n_companies = 30
revenue = np.random.normal(1000, 300, n_companies)
profit_margin = np.random.normal(0.15, 0.05, n_companies)
debt_to_equity = np.random.normal(0.5, 0.2, n_companies)
pe_ratio = np.random.normal(18, 5, n_companies)

df = pd.DataFrame({
 'Revenue': revenue,
 'Profit_Margin': profit_margin,
 'Debt_to_Equity': debt_to_equity,
 'PE_Ratio': pe_ratio
})

# Create pair plot
sns.pairplot(df, height=2.5, corner=True)
plt.suptitle('Relationships Between Financial Metrics', y=1.02, fontsize=16)
plt.tight_layout()
plt.show()

This creates scatter plots for every combination of variables, helping you spot relationships between multiple financial metrics at once.

Combined Line and Bar Chart

For financial reports, you often want to combine different chart types, like showing monthly profit as bars with a revenue trend line:

months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
revenue = [250, 310, 290, 340, 390, 420] # in thousands
profit = [50, 70, 65, 85, 100, 115] # in thousands

fig, ax1 = plt.subplots(figsize=(10, 6))

# Bar chart for profit
ax1.bar(months, profit, color='#6ACC64', alpha=0.7, label='Profit')
ax1.set_xlabel('Month', fontsize=12)
ax1.set_ylabel('Profit ($ thousands)', fontsize=12)
ax1.tick_params(axis='y')

# Create second y-axis for revenue
ax2 = ax1.twinx()
ax2.plot(months, revenue, 'o-', color='#2D7BB6', linewidth=2, label='Revenue')
ax2.set_ylabel('Revenue ($ thousands)', fontsize=12)
ax2.tick_params(axis='y')

# Add legends
lines1, labels1 = ax1.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left')

plt.title('Monthly Revenue and Profit (H1 2025)', fontsize=15)
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

This creates a dual-axis chart with bars for profit and a line for revenue, making it easy to see the relationship between the two.

Best Practices for Financial Visualisations

Based on my experience in finance, here are some best practices to make your visualisations more effective:

Choose the right chart type for your data and the story you want to tell:
- Line charts for trends over time
- Bar charts for comparing categories
- Pie charts for part-to-whole relationships (use sparingly)
- Scatter plots for correlations
- Box plots for distributions
Keep it simple and focused - make sure your visualisation answers a specific question or highlights a key insight.
Use consistent colours that represent your data appropriately (red for negative, green for positive in financial contexts).
Label everything clearly - titles, axes, legends, and data points where appropriate.
Consider your audience - executives might want high-level trends, while analysts need more detailed visualisations.
Use appropriate scales - avoid truncating axes in ways that might exaggerate changes.
Add context with annotations - highlight key events or outliers to tell the complete story.

Practical Exercise: Financial Dashboard

Let’s put everything together to create a simple financial dashboard with multiple charts:

# Create sample data
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
revenue = [250, 310, 290, 340, 390, 420] # in thousands
expenses = [200, 240, 225, 255, 290, 305] # in thousands
profit = [r - e for r, e in zip(revenue, expenses)] # in thousands
profit_margin = [p/r for p, r in zip(profit, revenue)]
expense_breakdown = {
 'Salaries': [120, 125, 130, 132, 135, 140],
 'Marketing': [30, 55, 40, 58, 82, 85],
 'Operations': [35, 40, 35, 45, 50, 55],
 'Other': [15, 20, 20, 20, 23, 25]
}

# Create a 2x2 grid of subplots
fig, axs = plt.subplots(2, 2, figsize=(15, 12))

# Plot 1: Revenue and Expenses line chart (top left)
axs[0, 0].plot(months, revenue, 'o-', label='Revenue', linewidth=2, color='#2D7BB6')
axs[0, 0].plot(months, expenses, 's-', label='Expenses', linewidth=2, color='#EE854A')
axs[0, 0].set_title('Revenue vs. Expenses', fontsize=14)
axs[0, 0].set_ylabel('Amount ($ thousands)', fontsize=12)
axs[0, 0].grid(True, linestyle='--', alpha=0.7)
axs[0, 0].legend()

# Plot 2: Profit bar chart (top right)
bars = axs[0, 1].bar(months, profit, color='#6ACC64')
for bar in bars:
 height = bar.get_height()
 axs[0, 1].text(bar.get_x() + bar.get_width()/2., height + 2,
 f'${height:,}k', ha='center', va='bottom')
axs[0, 1].set_title('Monthly Profit', fontsize=14)
axs[0, 1].set_ylabel('Profit ($ thousands)', fontsize=12)
axs[0, 1].grid(True, linestyle='--', alpha=0.7)

# Plot 3: Expense breakdown stacked bar chart (bottom left)
bottom = np.zeros(6)
for category, values in expense_breakdown.items():
 axs[1, 0].bar(months, values, bottom=bottom, label=category)
 bottom += values
axs[1, 0].set_title('Expense Breakdown', fontsize=14)
axs[1, 0].set_xlabel('Month', fontsize=12)
axs[1, 0].set_ylabel('Expenses ($ thousands)', fontsize=12)
axs[1, 0].legend()
axs[1, 0].grid(True, linestyle='--', alpha=0.7)

# Plot 4: Profit margin line chart (bottom right)
axs[1, 1].plot(months, [m*100 for m in profit_margin], 'D-', color='#956CB4', linewidth=2)
for i, m in enumerate(profit_margin):
 axs[1, 1].text(i, m*100 + 0.5, f'{m*100:.1f}%', ha='center')
axs[1, 1].set_title('Profit Margin', fontsize=14)
axs[1, 1].set_xlabel('Month', fontsize=12)
axs[1, 1].set_ylabel('Margin (%)', fontsize=12)
axs[1, 1].grid(True, linestyle='--', alpha=0.7)

plt.tight_layout()
plt.suptitle('H1 2025 Financial Performance Dashboard', fontsize=18, y=1.02)
plt.subplots_adjust(top=0.9)
plt.savefig('financial_dashboard.png', dpi=300, bbox_inches='tight')
plt.show()

This code creates a comprehensive financial dashboard with four different visualisations that provide a complete picture of the financial performance.

Conclusion

Data visualisation is a powerful tool in your financial analysis toolkit. With matplotlib and seaborn, you can create everything from simple charts to complex dashboards that help you and your stakeholders understand financial data more effectively.

In this post, we’ve covered:

Creating basic charts (line, bar, pie, histogram, scatter)
Customising your plots with titles, labels, and annotations
Using advanced features like subplots and dual axes
Applying seaborn for statistical visualisations
Building a financial dashboard

As you continue your Python journey, I encourage you to experiment with these visualisation techniques on your own financial data. Try recreating some of the charts you currently use in Excel or other tools, and see how Python can enhance your financial analysis workflow.

In the next post, we’ll explore object-oriented programming (OOP) in Python, which will help you organise your code more effectively for larger projects.

Data Analysis with pandas (Python for Finance, part 12)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 17 Jul 2025 00:00:00 +0000

Welcome to post #12 in our Python journey! In the previous post, we explored NumPy and its powerful numerical capabilities. Now we’re taking a step up to pandas, which builds on NumPy’s foundation to provide specialised tools for working with tabular and time series data—exactly the kind of data we deal with daily in finance and accounting.

Why pandas for Finance?

pandas is specifically designed for data analysis and manipulation, with particular strengths in:

Working with tabular data (like spreadsheets, CSV files, and SQL tables)
Handling time series (perfect for financial data)
Cleaning messy data (a constant challenge in real-world accounting)
Joining and merging datasets (combining data from multiple sources)
Advanced grouping and aggregation (similar to pivot tables in Excel)

If you’ve spent hours manipulating data in Excel, pandas will feel both familiar yet incredibly more powerful—think Excel on steroids with the automation capabilities of Python.

Installing pandas

Let’s start by installing pandas:

pip install pandas

If you’re using Anaconda, pandas is already included in the distribution.

Let’s verify the installation:

import pandas as pd
print(pd.__version__)

You should see the version number displayed (like 2.0.3 or similar). By convention, pandas is imported with the alias pd to make your code more readable.

The Core pandas Data Structures

pandas provides two primary data structures:

Series: A one-dimensional labeled array (like a column in a spreadsheet)
DataFrame: A two-dimensional labeled data structure with columns (like a spreadsheet or SQL table)

Let’s explore both with financial examples.

Series: One-Dimensional Data

A Series is essentially a column of data with labeled indices:

import pandas as pd
import numpy as np

# Create a Series of monthly expenses
monthly_expenses = pd.Series([1200, 1500, 1100, 1800], 
 index=['Rent', 'Payroll', 'Utilities', 'Inventory'])

print(monthly_expenses)
# Output:
# Rent 1200
# Payroll 1500
# Utilities 1100
# Inventory 1800
# dtype: int64

# Access by label
print(f"Monthly rent: ${monthly_expenses['Rent']}") # Output: Monthly rent: $1200

# Access by position
print(f"Second highest expense: ${monthly_expenses.iloc[1]}") # Output: Second highest expense: $1500

# Perform calculations
print(f"Total monthly expenses: ${monthly_expenses.sum()}") # Output: Total monthly expenses: $5600
print(f"Average expense: ${monthly_expenses.mean()}") # Output: Average expense: $1400

# Filter expenses greater than 1200
high_expenses = monthly_expenses[monthly_expenses > 1200]
print(high_expenses)
# Output:
# Payroll 1500
# Inventory 1800
# dtype: int64

Series are useful for representing:

A single financial metric across multiple companies
Monthly or yearly values for a specific account
Daily stock prices

DataFrame: Two-Dimensional Data

DataFrames are where pandas really shines. Think of them as an Excel spreadsheet within Python:

# Create a DataFrame representing a simplified income statement
income_statement = pd.DataFrame({
 'Q1': [100000, 45000, 15000, 40000],
 'Q2': [110000, 47000, 15000, 48000],
 'Q3': [95000, 42000, 16000, 37000],
 'Q4': [125000, 52000, 17000, 56000]
}, index=['Revenue', 'COGS', 'Operating Expenses', 'Net Income'])

print(income_statement)
# Output:
# Q1 Q2 Q3 Q4
# Revenue 100000 110000 95000 125000
# COGS 45000 47000 42000 52000
# Operating Expenses 15000 15000 16000 17000
# Net Income 40000 48000 37000 56000

# Or create the same DataFrame with a different orientation
# (More commonly used format with rows as observations and columns as variables)
income_statement_alt = pd.DataFrame({
 'Quarter': ['Q1', 'Q2', 'Q3', 'Q4'],
 'Revenue': [100000, 110000, 95000, 125000],
 'COGS': [45000, 47000, 42000, 52000],
 'Operating_Expenses': [15000, 15000, 16000, 17000],
 'Net_Income': [40000, 48000, 37000, 56000]
})

print(income_statement_alt)
# Output:
# Quarter Revenue COGS Operating_Expenses Net_Income
# 0 Q1 100000 45000 15000 40000
# 1 Q2 110000 47000 15000 48000
# 2 Q3 95000 42000 16000 37000
# 3 Q4 125000 52000 17000 56000

The orientation you choose often depends on your data and analysis goals. For financial data:

Use index for time periods and columns for accounts when tracking few accounts over time
Use rows for time periods and columns for accounts when tracking many accounts

Reading Data from External Sources

In real-world finance, data often comes from external files. pandas excels at importing from various sources:

Reading from CSV

CSVs are common for exporting financial data:

# Read a transaction register CSV file
# transactions.csv contains: Date,Description,Category,Amount
transactions = pd.read_csv('transactions.csv')

# Preview the first 5 rows
print(transactions.head())
# Output:
# Date Description Category Amount
# 0 2023-01-05 Office Supplies Expense -89.99
# 1 2023-01-07 Client Payment - ABC Inc Income 1250.00
# 2 2023-01-10 Payroll Expense -4500.00
# 3 2023-01-15 Software License Expense -199.99
# 4 2023-01-18 Bank Interest Income 2.13

Reading from Excel

Excel files are ubiquitous in finance and accounting:

# Install openpyxl first if you haven't:
# pip install openpyxl

# Read an Excel file, specifying the sheet
financial_data = pd.read_excel('financial_model.xlsx', sheet_name='Income Statement')

# Preview the data
print(financial_data.head())

Connecting to Databases

For more enterprise-level finance applications:

# pip install sqlalchemy
# pip install pymysql (or other database driver)

from sqlalchemy import create_engine

# Connect to database (example with MySQL)
engine = create_engine('mysql+pymysql://username:password@localhost/finance_db')

# Read data directly from SQL query
sql_query = "SELECT * FROM general_ledger WHERE account_type = 'Asset' AND transaction_date > '2023-01-01'"
gl_data = pd.read_sql(sql_query, engine)

print(gl_data.head())

Inspecting and Exploring Your Data

When you receive a new financial dataset, your first step is usually to understand its structure:

# Assuming we've loaded our transactions data
print(f"Data shape (rows, columns): {transactions.shape}")
print("\nColumn names:")
print(transactions.columns.tolist())

print("\nData types:")
print(transactions.dtypes)

print("\nSummary statistics:")
print(transactions.describe())

print("\nMissing values:")
print(transactions.isnull().sum())

# Check for duplicates
print(f"\nDuplicate rows: {transactions.duplicated().sum()}")

Data Selection and Filtering

pandas offers powerful ways to select and filter data:

# Select specific columns
amounts_and_categories = transactions[['Category', 'Amount']]
print(amounts_and_categories.head())

# Filter rows based on conditions
expenses = transactions[transactions['Amount'] < 0]
income = transactions[transactions['Amount'] > 0]

print(f"Total expenses: ${expenses['Amount'].sum():.2f}")
print(f"Total income: ${income['Amount'].sum():.2f}")

# Filter with multiple conditions
# Find large office expenses
large_office_expenses = transactions[
 (transactions['Category'] == 'Expense') & 
 (transactions['Description'].str.contains('Office')) & 
 (transactions['Amount'] < -100)
]
print(large_office_expenses)

# Select data from a specific date range
# First, ensure Date is a datetime type
transactions['Date'] = pd.to_datetime(transactions['Date'])

# Filter for Q1 data
q1_data = transactions[(transactions['Date'] >= '2023-01-01') & 
 (transactions['Date'] <= '2023-03-31')]
print(f"Q1 transaction count: {len(q1_data)}")

Handling Missing Data

Missing data is a common challenge in financial datasets:

# Check for missing values
print(transactions.isnull().sum())

# Fill missing values in Amount column with 0
transactions['Amount'] = transactions['Amount'].fillna(0)

# Fill missing categories with 'Uncategorized'
transactions['Category'] = transactions['Category'].fillna('Uncategorized')

# Drop rows with any remaining missing values
transactions_clean = transactions.dropna()

# Alternative: Only drop rows where specific columns are missing
transactions_essential = transactions.dropna(subset=['Date', 'Amount'])

Data Transformation and Feature Engineering

Often, you’ll need to create new calculated fields for financial analysis:

# Add a Month column for easier grouping
transactions['Month'] = transactions['Date'].dt.strftime('%Y-%m')

# Add an Absolute Amount column for analysis
transactions['Abs_Amount'] = transactions['Amount'].abs()

# Categorize transactions by size
def categorize_amount(amount):
 if abs(amount) < 100:
 return 'Small'
 elif abs(amount) < 1000:
 return 'Medium'
 else:
 return 'Large'

transactions['Size_Category'] = transactions['Amount'].apply(categorize_amount)

# Create a new column indicating if it's end of quarter
transactions['Is_Quarter_End'] = transactions['Date'].dt.is_quarter_end

# Add a calculated running balance
transactions = transactions.sort_values('Date')
transactions['Running_Balance'] = transactions['Amount'].cumsum()

print(transactions.head())

Grouping and Aggregation: The Heart of Financial Analysis

Grouping operations are similar to Excel’s pivot tables and are perfect for financial reporting:

# Group by Category and calculate sum, count, and average
category_summary = transactions.groupby('Category').agg({
 'Amount': ['sum', 'count', 'mean'],
 'Description': 'count' # count of transactions
})

print(category_summary)

# Group by Month and Category to see spending trends
monthly_by_category = transactions.groupby(['Month', 'Category'])['Amount'].sum().unstack()

print(monthly_by_category)

# Calculate monthly totals
monthly_totals = transactions.groupby('Month')['Amount'].sum()
print(monthly_totals)

# Find the month with the highest expenses
monthly_expenses = transactions[transactions['Amount'] < 0].groupby('Month')['Amount'].sum()
highest_expense_month = monthly_expenses.idxmin() # min because expenses are negative
print(f"Month with highest expenses: {highest_expense_month}, Amount: ${monthly_expenses.min():.2f}")

Advanced Financial Calculations

Let’s implement some practical financial calculations:

# Monthly Profit and Loss Statement
monthly_pl = transactions.pivot_table(
 index='Month',
 columns='Category',
 values='Amount',
 aggfunc='sum'
).fillna(0)

# Add a Profit column
monthly_pl['Profit'] = monthly_pl['Income'] + monthly_pl['Expense'] # Adding because expenses are negative

print(monthly_pl)

# Calculate running cash balance by date
daily_net = transactions.groupby('Date')['Amount'].sum().reset_index()
daily_net['Running_Balance'] = daily_net['Amount'].cumsum()

print(daily_net.head())

# Calculate 30-day moving average of daily transaction amounts
transactions_by_date = transactions.groupby('Date')['Amount'].sum()
moving_avg_30d = transactions_by_date.rolling(window=30).mean()

print(moving_avg_30d.tail())

Merging and Joining Datasets

In finance, we often need to combine data from multiple sources:

# Create a sample budget DataFrame
budget = pd.DataFrame({
 'Category': ['Rent', 'Utilities', 'Payroll', 'Marketing', 'Software'],
 'Budgeted_Amount': [1200, 300, 5000, 1000, 500]
})

# Group actual expenses by category
actual_expenses = transactions[transactions['Amount'] < 0].groupby('Category')['Amount'].sum().abs().reset_index()
actual_expenses.columns = ['Category', 'Actual_Amount']

# Merge the budget with actual expenses
budget_vs_actual = pd.merge(budget, actual_expenses, on='Category', how='outer')

# Calculate variance (negative means over budget)
budget_vs_actual['Variance'] = budget_vs_actual['Budgeted_Amount'] - budget_vs_actual['Actual_Amount']
budget_vs_actual['Variance_Percent'] = (budget_vs_actual['Variance'] / budget_vs_actual['Budgeted_Amount']) * 100

print(budget_vs_actual)

# Find categories that are over budget
over_budget = budget_vs_actual[budget_vs_actual['Variance'] < 0]
print("\nCategories over budget:")
print(over_budget)

Time Series Analysis: Perfect for Financial Data

pandas has exceptional support for time series data:

# Convert Date to datetime if not already
transactions['Date'] = pd.to_datetime(transactions['Date'])

# Set Date as index for time series analysis
ts_data = transactions.set_index('Date')

# Resample to get monthly totals
monthly_data = ts_data['Amount'].resample('M').sum()
print(monthly_data)

# Compute rolling average (e.g., 3-month rolling revenue)
income_only = ts_data[ts_data['Amount'] > 0]
rolling_3m_revenue = income_only['Amount'].resample('M').sum().rolling(window=3).mean()
print(rolling_3m_revenue)

# Calculate percent change period-over-period
monthly_growth = monthly_data.pct_change() * 100
print(f"Monthly growth rates (%):\n{monthly_growth}")

# Seasonal decomposition
from statsmodels.tsa.seasonal import seasonal_decompose

# Need 2+ years of data for proper decomposition, but here's the concept:
# Assuming we have enough data:
# decomposition = seasonal_decompose(monthly_data, model='additive', period=12)
# fig = decomposition.plot()

Handling Excel-Like Functionality with pandas

If you’re transitioning from Excel, pandas offers similar functionality with more power:

# VLOOKUP equivalent
product_info = pd.DataFrame({
 'Product_ID': ['A001', 'B002', 'C003', 'D004'],
 'Product_Name': ['Laptop', 'Monitor', 'Keyboard', 'Mouse'],
 'Unit_Cost': [1200, 300, 80, 25]
})

sales = pd.DataFrame({
 'Date': ['2023-01-15', '2023-01-20', '2023-01-22', '2023-01-25'],
 'Product_ID': ['A001', 'C003', 'A001', 'B002'],
 'Quantity': [2, 5, 1, 3]
})

# Merge sales with product info (like VLOOKUP)
sales_with_info = pd.merge(sales, product_info, on='Product_ID')

# Calculate total sales amount
sales_with_info['Total_Cost'] = sales_with_info['Quantity'] * sales_with_info['Unit_Cost']
print(sales_with_info)

# Pivot tables
pivot_sales = sales_with_info.pivot_table(
 index='Product_Name',
 values=['Quantity', 'Total_Cost'],
 aggfunc={'Quantity': 'sum', 'Total_Cost': 'sum'}
)
print(pivot_sales)

# Sort by total cost (descending)
print(pivot_sales.sort_values('Total_Cost', ascending=False))

Exporting and Saving Your Analysis

Once your analysis is complete, you’ll often need to export the results:

# Export as CSV
budget_vs_actual.to_csv('budget_analysis.csv', index=False)

# Export to Excel
with pd.ExcelWriter('financial_analysis.xlsx') as writer:
 budget_vs_actual.to_excel(writer, sheet_name='Budget Analysis', index=False)
 pivot_sales.to_excel(writer, sheet_name='Sales by Product')
 monthly_pl.to_excel(writer, sheet_name='Monthly P&L')
 
# Export specific results to JSON (useful for web applications)
over_budget.to_json('over_budget_alert.json', orient='records')

Case Study: Comprehensive Financial Analysis

Let’s pull everything together in a finance-focused case study:

# 1. Load and prepare data
transactions = pd.read_csv('transactions.csv')
transactions['Date'] = pd.to_datetime(transactions['Date'])
transactions['Month'] = transactions['Date'].dt.strftime('%Y-%m')
transactions['Quarter'] = transactions['Date'].dt.to_period('Q').astype(str)

# 2. Clean data
transactions['Category'] = transactions['Category'].fillna('Uncategorized')
transactions['Amount'] = transactions['Amount'].fillna(0)

# 3. Create income and expense dataframes
income = transactions[transactions['Amount'] > 0]
expenses = transactions[transactions['Amount'] < 0]
expenses['Abs_Amount'] = expenses['Amount'].abs() # Make expenses positive for easier calculations

# 4. Quarterly Financial Reports
quarterly_summary = pd.DataFrame({
 'Total_Income': income.groupby('Quarter')['Amount'].sum(),
 'Total_Expenses': expenses.groupby('Quarter')['Abs_Amount'].sum(),
})

quarterly_summary['Net_Profit'] = quarterly_summary['Total_Income'] - quarterly_summary['Total_Expenses']
quarterly_summary['Profit_Margin'] = quarterly_summary['Net_Profit'] / quarterly_summary['Total_Income'] * 100

print("Quarterly Financial Summary:")
print(quarterly_summary)

# 5. Top 5 expense categories
top_expenses = expenses.groupby('Category')['Abs_Amount'].sum().sort_values(ascending=False).head(5)
print("\nTop 5 Expense Categories:")
print(top_expenses)

# 6. Monthly trend analysis
monthly_net = pd.DataFrame({
 'Income': income.groupby('Month')['Amount'].sum(),
 'Expenses': expenses.groupby('Month')['Abs_Amount'].sum() * -1 # Make expenses negative again
})

monthly_net['Net'] = monthly_net['Income'] + monthly_net['Expenses'] # Net will be positive or negative
monthly_net['3M_Rolling_Avg'] = monthly_net['Net'].rolling(window=3).mean()

print("\nMonthly Trend Analysis:")
print(monthly_net)

# 7. Cash flow analysis
transactions = transactions.sort_values('Date')
transactions['Running_Balance'] = transactions['Amount'].cumsum()

# Find any days where cash balance went negative
cash_issues = transactions[transactions['Running_Balance'] < 0]
if not cash_issues.empty:
 print("\nCash Flow Alert - Negative Balance Detected:")
 print(cash_issues[['Date', 'Running_Balance']].head())

# 8. Year-over-year comparison (assuming we have multiple years of data)
transactions['Year'] = transactions['Date'].dt.year
yoy_income = income.groupby(['Year', 'Quarter'])['Amount'].sum().unstack()
print("\nYear-over-Year Quarterly Income:")
print(yoy_income)

# 9. Export key insights to Excel
with pd.ExcelWriter('financial_insights.xlsx') as writer:
 quarterly_summary.to_excel(writer, sheet_name='Quarterly Summary')
 top_expenses.to_excel(writer, sheet_name='Top Expenses')
 monthly_net.to_excel(writer, sheet_name='Monthly Trends')
 
print("\nFinancial analysis complete! Results exported to 'financial_insights.xlsx'")

Key Takeaways from pandas for Finance Professionals

For finance and accounting professionals, pandas offers several key advantages:

Automation: Automate repetitive data tasks that would take hours in Excel
Scale: Handle much larger datasets than Excel can manage
Reproducibility: Document your analysis as code for future reference or audit
Flexibility: Customize your analysis beyond what Excel templates allow
Integration: Connect directly to databases, APIs, and other data sources
Analysis Power: Perform complex statistical operations with minimal code

Next Steps

Now that you understand the basics of pandas for financial data analysis, you’re ready to move on to data visualization in our next post. We’ll explore how to transform these financial insights into compelling visualizations using Matplotlib and Seaborn!

Exercise: Financial Data Analysis

Before you go, try this exercise to practice your pandas skills:

You have a CSV file of transactions with columns for Date, Description, Category, and Amount. Using pandas:

Calculate the monthly income, expenses, and net profit
Find the top 3 expense categories by total amount
Create a month-over-month percentage change analysis of your net profit
Identify any expense categories that show an increasing trend over time

Good luck, and feel free to share your solutions in the comments!

This post is part of my journey learning Python. I’m a chartered accountant exploring programming to enhance my financial analysis toolkit. Follow along as we discover together how Python can transform our work in finance and accounting!

NumPy Fundamentals for Numerical Data (Python for Finance, part 11)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 10 Jul 2025 00:00:00 +0000

Welcome to post #11 in our Python learning journey! If you’ve been following along, you’re starting to build a solid foundation in Python. Now it’s time to explore NumPy, the powerhouse library that makes Python a serious contender for numerical computing and data analysis.

As a finance professional myself, I’ve found NumPy particularly useful for financial calculations, portfolio analysis, and working with large datasets. Let’s dive in and see how this library can level up your Python skills.

What is NumPy and Why Should You Care?

NumPy (Numerical Python) is a fundamental library that provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays efficiently.

Why is this important, especially for finance work?

Performance: NumPy operations are executed in optimised C code, making them much faster than equivalent Python loops
Memory efficiency: NumPy arrays use less memory than Python lists for numerical data
Mathematical operations: Built-in functions for statistical analysis, linear algebra, and other operations common in finance
Foundation for other tools: Libraries like pandas, matplotlib, and scikit-learn are built on NumPy

Simply put, if you’re doing any kind of numerical analysis in Python—whether that’s calculating portfolio returns, analysing balance sheets, or running financial simulations—NumPy will make your life easier.

Installing NumPy

Before we get started, let’s make sure NumPy is installed in your environment:

pip install numpy

If you’re using Anaconda (which we covered in post #10), NumPy is already included!

To confirm the installation worked, open a Python shell and try:

import numpy as np
print(np.__version__)

You should see the version number printed (like 1.24.3 or similar). The convention is to import NumPy with the alias np to save typing.

The NumPy ndarray: Python Lists on Steroids

The core of NumPy is the ndarray (n-dimensional array) object. Think of it as a more powerful version of Python lists, specifically designed for numerical data.

Creating Arrays

Let’s start by creating some simple arrays:

import numpy as np

# Create an array from a Python list
revenue_data = np.array([10500, 15200, 12100, 18900])
print(revenue_data)
# Output: [10500 15200 12100 18900]

# Create an array of zeros (useful as a placeholder)
empty_balance_sheet = np.zeros((3, 4)) # 3 rows, 4 columns
print(empty_balance_sheet)
# Output:
# [[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]

# Create an array of ones
unit_values = np.ones(5)
print(unit_values)
# Output: [1. 1. 1. 1. 1.]

# Create an array with a range of values (like Python's range)
quarters = np.arange(1, 5) # 1 to 4
print(quarters)
# Output: [1 2 3 4]

# Create evenly spaced values (useful for time series)
interest_rates = np.linspace(2.5, 3.5, 5) # 5 values from 2.5 to 3.5
print(interest_rates)
# Output: [2.5 2.75 3. 3.25 3.5 ]

# Create a 2D array (matrix) for financial data
# Rows: Q1, Q2, Q3, Q4
# Columns: Revenue, Expenses, Profit
financial_data = np.array([
 [10500, 8200, 2300], # Q1
 [15200, 9500, 5700], # Q2
 [12100, 7800, 4300], # Q3
 [18900, 10200, 8700] # Q4
])

print(financial_data)
# Output:
# [[10500 8200 2300]
# [15200 9500 5700]
# [12100 7800 4300]
# [18900 10200 8700]]

Array Attributes

NumPy arrays come with useful attributes that tell you about their shape and contents:

# Using the financial_data from above

# Shape (dimensions) of the array
print(financial_data.shape) # Output: (4, 3)

# Number of dimensions
print(financial_data.ndim) # Output: 2

# Total number of elements
print(financial_data.size) # Output: 12

# Data type of the elements
print(financial_data.dtype) # Output: int64

The shape attribute is particularly useful—it tells us we have 4 rows (quarters) and 3 columns (financial metrics).

Indexing and Slicing: Accessing Your Data

Getting to specific elements in your arrays is similar to Python lists, but with more power.

Basic Indexing

# Using our financial_data array from above

# Get Q1 revenue (first row, first column)
q1_revenue = financial_data[0, 0]
print(q1_revenue) # Output: 10500

# Get Q3 profit (third row, third column)
q3_profit = financial_data[2, 2]
print(q3_profit) # Output: 4300

# Get all expenses (second column)
all_expenses = financial_data[:, 1]
print(all_expenses) # Output: [8200 9500 7800 10200]

# Get data for Q2 and Q3 (second and third rows)
mid_year_data = financial_data[1:3, :]
print(mid_year_data)
# Output:
# [[15200 9500 5700]
# [12100 7800 4300]]

Fancy Indexing

NumPy also lets you select elements that meet certain conditions—incredibly useful for financial analysis:

# Find quarters where revenue exceeded 12000
high_revenue_mask = financial_data[:, 0] > 12000
print(high_revenue_mask) # Output: [False True True True]

# Get the financial data for those high-revenue quarters
high_revenue_quarters = financial_data[high_revenue_mask]
print(high_revenue_quarters)
# Output:
# [[15200 9500 5700]
# [12100 7800 4300]
# [18900 10200 8700]]

# Find quarters where profit margin (profit/revenue) exceeded 30%
revenue = financial_data[:, 0]
profit = financial_data[:, 2]
profit_margin = profit / revenue
print(profit_margin) # Output: [0.21904762 0.375 0.35537191 0.46031746]

high_margin_quarters = financial_data[profit_margin > 0.3]
print(high_margin_quarters)
# Output:
# [[15200 9500 5700]
# [12100 7800 4300]
# [18900 10200 8700]]

This ability to filter data based on conditions is one of NumPy’s most powerful features for financial analysis.

Vectorised Operations: NumPy’s Superpower

In traditional Python, if you want to perform calculations across arrays, you’d need to write loops. NumPy eliminates this need with vectorised operations—allowing you to express calculations directly on entire arrays.

Element-wise Operations

# Revenue growth calculation for quarters
revenue = financial_data[:, 0]
revenue_prev = np.roll(revenue, 1) # Shift values to calculate previous quarter
revenue_prev[0] = revenue[0] # Set first value (no previous quarter)

revenue_growth = (revenue - revenue_prev) / revenue_prev * 100
print(revenue_growth) # Output: [ 0. 44.76190476 -20.39473684 56.19834711]

# Apply 10% discount to all revenue figures
discounted_revenue = revenue * 0.9
print(discounted_revenue) # Output: [ 9450. 13680. 10890. 17010.]

# Add a 5% bonus to all profit figures
profit = financial_data[:, 2]
bonus_adjusted_profit = profit * 1.05
print(bonus_adjusted_profit) # Output: [2415. 5985. 4515. 9135.]

# Calculate profit margin for each quarter
profit_margin = profit / revenue * 100 # as percentage
print(profit_margin) # Output: [21.9047619 37.5 35.53719008 46.03174603]

Broadcasting

One of NumPy’s most powerful features is broadcasting, which allows operations between arrays of different shapes. This is especially useful in finance for scenarios like applying different tax rates or calculating weighted averages.

# Applying different tax rates to quarterly profits
tax_rates = np.array([0.21, 0.22, 0.21, 0.20]) # Different rates each quarter
profit = financial_data[:, 2]
taxes_paid = profit * tax_rates
after_tax_profit = profit - taxes_paid

print(taxes_paid) # Output: [ 483. 1254. 903. 1740.]
print(after_tax_profit) # Output: [1817. 4446. 3397. 6960.]

# Creating a weighted average of financial metrics
# Giving more weight to recent quarters
weights = np.array([0.1, 0.2, 0.3, 0.4]) # Weights sum to 1
weighted_revenue = np.sum(revenue * weights)
print(weighted_revenue) # Output: 14970.0

Statistical Methods: Financial Analysis Made Easy

NumPy provides built-in methods for common statistical operations, which are invaluable for financial analysis:

revenue = financial_data[:, 0]
expenses = financial_data[:, 1]
profit = financial_data[:, 2]

# Basic statistics
print(f"Average Quarterly Revenue: {np.mean(revenue)}") # Output: 14175.0
print(f"Total Annual Revenue: {np.sum(revenue)}") # Output: 56700
print(f"Lowest Quarterly Profit: {np.min(profit)}") # Output: 2300
print(f"Highest Quarterly Expenses: {np.max(expenses)}") # Output: 10200
print(f"Revenue Variance: {np.var(revenue)}") # Output: 12577500.0
print(f"Profit Standard Deviation: {np.std(profit)}") # Output: 2326.53...

# Finding best and worst performing quarters
best_quarter_idx = np.argmax(profit)
worst_quarter_idx = np.argmin(profit)

print(f"Best Quarter: Q{best_quarter_idx + 1} with ${profit[best_quarter_idx]} profit")
# Output: Best Quarter: Q4 with $8700 profit
print(f"Worst Quarter: Q{worst_quarter_idx + 1} with ${profit[worst_quarter_idx]} profit")
# Output: Worst Quarter: Q1 with $2300 profit

# Cumulative sums (running totals) - useful for YTD calculations
ytd_revenue = np.cumsum(revenue)
print(f"Revenue YTD: {ytd_revenue}") # Output: [10500 25700 37800 56700]

# Moving averages (e.g., 2-quarter moving average)
def moving_average(a, window_size):
 return np.convolve(a, np.ones(window_size)/window_size, mode='valid')

revenue_2q_avg = moving_average(revenue, 2)
print(f"2-Quarter Moving Average Revenue: {revenue_2q_avg}")
# Output: [12850. 13650. 15500.]

Performance Comparison: Why NumPy is Faster

To really appreciate NumPy, let’s compare it with pure Python for a common financial calculation: computing the cumulative returns from a series of daily returns.

import time
import random

# Generate sample daily returns (+/- 2%)
daily_returns_list = [random.uniform(-0.02, 0.02) for _ in range(10000)]
daily_returns_np = np.array(daily_returns_list)

# Pure Python approach
start_time = time.time()
cumulative_return = 1
for daily_return in daily_returns_list:
 cumulative_return *= (1 + daily_return)
final_value_python = cumulative_return
python_time = time.time() - start_time

# NumPy approach
start_time = time.time()
final_value_numpy = np.prod(1 + daily_returns_np)
numpy_time = time.time() - start_time

print(f"Pure Python result: {final_value_python}, time: {python_time:.6f} seconds")
print(f"NumPy result: {final_value_numpy}, time: {numpy_time:.6f} seconds")
print(f"NumPy is {python_time/numpy_time:.1f}x faster")

On my machine, the NumPy version typically runs about 100x faster! This performance advantage becomes even more significant as your datasets grow, which is why NumPy is essential for serious financial analysis.

Finance Case Study: Portfolio Analysis

Let’s put everything together in a simple portfolio analysis example:

# Portfolio stocks data (price at end of each quarter)
# Rows: Quarters, Columns: Stocks (AAPL, MSFT, GOOGL, AMZN)
stock_prices = np.array([
 [150.10, 225.75, 2720.30, 3110.50], # Q1 prices
 [168.30, 265.90, 2781.25, 3450.75], # Q2 prices
 [155.80, 285.40, 2950.60, 3320.20], # Q3 prices
 [182.40, 305.65, 3050.40, 3680.35] # Q4 prices
])

# Initial portfolio allocation (number of shares)
holdings = np.array([10, 5, 1, 2])

# Calculate portfolio value each quarter
portfolio_values = np.sum(stock_prices * holdings, axis=1)
print(f"Portfolio value by quarter: {portfolio_values}")
# Output: [9807.8 11207.15 11612.4 12687.05]

# Calculate quarterly returns
portfolio_returns = np.diff(portfolio_values) / portfolio_values[:-1] * 100
print(f"Quarterly returns (%): {portfolio_returns}")
# Output: [14.26731123 3.61594237 9.25456674]

# Calculate annualized return (geometric mean)
annual_return = (portfolio_values[-1] / portfolio_values[0]) ** (4/4) - 1
print(f"Annualized return: {annual_return*100:.2f}%")
# Output: Annualized return: 29.36%

# Calculate volatility (standard deviation of returns)
volatility = np.std(portfolio_returns)
print(f"Return volatility: {volatility:.2f}%")
# Output: Return volatility: 5.33%

# Calculate Sharpe ratio (assuming risk-free rate of 2%)
risk_free_rate = 2 # 2% annual
sharpe_ratio = (annual_return*100 - risk_free_rate) / volatility
print(f"Sharpe ratio: {sharpe_ratio:.2f}")
# Output: Sharpe ratio: 5.13

# Analyze correlation between stocks
# Calculate returns for each stock
stock_returns = np.diff(stock_prices, axis=0) / stock_prices[:-1] * 100

# Calculate correlation matrix
corr_matrix = np.corrcoef(stock_returns.T)
print("Stock correlation matrix:")
print(corr_matrix)
# Output:
# [[ 1. -0.71294839 -0.99819453 0.77866361]
# [-0.71294839 1. 0.75844502 -0.17973701]
# [-0.99819453 0.75844502 1. -0.80727807]
# [ 0.77866361 -0.17973701 -0.80727807 1. ]]

This example shows how NumPy makes it straightforward to perform complex financial analyses with just a few lines of code!

Key Takeaways

NumPy transforms Python from a general-purpose language into a powerful numerical computing tool. For finance professionals, it offers:

Speed and efficiency for working with large datasets
Intuitive syntax for numerical operations that maps well to financial calculations
Built-in statistical functions that eliminate the need for custom implementations
Vectorised operations that make mathematical formulas easier to express
The foundation for more advanced financial analysis libraries like pandas

Next Steps

Now that you have a solid understanding of NumPy basics, you’re ready to move on to pandas, which builds on NumPy to provide even more powerful data analysis capabilities specifically designed for tabular data like financial statements, price histories, and transaction records.

In our next post, we’ll explore how pandas can make your financial data analysis workflow even more efficient and insightful.

Exercise: Calculate Financial Metrics

Before you go, try this exercise to practice your NumPy skills:

Create an array with monthly sales data for a year, then:

Calculate the average monthly sales
Find the highest and lowest sales months
Calculate the quarter-by-quarter growth rate
Determine if any month had sales 20% above the yearly average

The Python Ecosystem & Interactive Data Workflows (Python for Finance, part 10)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 03 Jul 2025 00:00:00 +0000

As a finance professional diving deeper into Python, I’ve found that understanding the broader ecosystem of tools is just as important as learning the language itself. In this post, we’ll explore the different ways to manage Python packages and environments, and dive into interactive data workflows that can transform how you work with financial data.

Package vs. Environment Managers: pip, conda, and Anaconda

When I first started with Python, I was confused by the different tools available for installing packages and managing environments. Let’s clarify these concepts.

pip: The Standard Package Manager

pip is Python’s default package manager - it’s what we’ve been using in previous posts. It comes bundled with Python and is straightforward for basic needs.

# Install a package with pip
pip install pandas

# Install a specific version
pip install pandas==1.4.2

# Upgrade a package
pip install --upgrade pandas

# List installed packages
pip list

# Generate a requirements file
pip freeze > requirements.txt

# Install from requirements file
pip install -r requirements.txt

Pros of pip:

Simple and lightweight
Built-in with Python
Works with virtual environments (venv)
Perfect for most Python projects

Cons of pip:

Doesn’t manage non-Python dependencies well
Can’t create standalone environments (relies on venv)
Not ideal for complex data science setups with conflicting dependencies

conda: The Environment and Package Manager

conda is both a package manager and an environment manager. Unlike pip, conda isn’t specific to Python - it can manage packages for any language.

# Create a new environment
conda create --name finance_env

# Activate the environment
conda activate finance_env

# Install a package
conda install pandas

# Install a package from a specific channel
conda install -c conda-forge plotly

# List installed packages
conda list

# Export environment
conda env export > environment.yml

# Create environment from file
conda env create -f environment.yml

Pros of conda:

Manages both Python and non-Python dependencies
Creates isolated environments
Better dependency resolution than pip
Great for data science packages with complex dependencies
Cross-platform compatibility

Cons of conda:

More complex than pip
Can be slower for simple installations
Larger footprint on your system

Anaconda: The All-in-One Distribution

Anaconda is a distribution of Python that comes bundled with conda and a collection of 250+ pre-installed data science packages. Think of it as the “deluxe edition” of Python.

Pros of Anaconda:

Everything installed in one go
Includes widely-used data science packages
Comes with Anaconda Navigator (GUI)
Includes many finance-relevant packages pre-installed
Great for beginners who want everything set up

Cons of Anaconda:

Very large download (several GB)
Takes up a lot of disk space
Includes many packages you might never use
Can be overkill for simple projects

Miniconda: The Lightweight Alternative

If you like conda but don’t want all the extra packages, Miniconda gives you just Python and conda. You can then install only what you need.

# Install specific packages as needed
conda create --name finance_env python=3.10 pandas numpy matplotlib

When to Choose Each Option

Here’s a simple decision matrix I use:

Use pip + venv when:
- You’re building a standard Python application
- Your project has simple dependencies
- You’re developing a package for others to use
- You’re following my previous posts where we used venv
- You want to keep things lightweight
Use conda when:
- You need complex scientific packages (NumPy, SciPy, etc.)
- You work with packages that have non-Python dependencies
- You switch between different projects with conflicting dependencies
- You need consistent environments across different operating systems
Use Anaconda when:
- You’re just getting started with data science
- You want a hassle-free setup with all major packages included
- You prefer using a GUI (Anaconda Navigator)
- Disk space isn’t a concern
- You’re setting up a training environment

For my financial analysis work, I primarily use conda environments because many financial modelling packages have complex dependencies, and I often need to switch between different project environments.

Installing and Exploring Anaconda Navigator

Let’s explore Anaconda Navigator, which provides a graphical interface to manage environments and packages.

Installation

Download Anaconda from the official site
Run the installer:
- Windows: Double-click the .exe file and follow the wizard
- macOS: Double-click the .pkg file and follow the prompts
- Linux: Run bash Anaconda-latest-Linux-x86_64.sh in terminal

During installation:

Install for “Just Me” (recommended)
Accept the default location (or choose another)
Important choice: Whether to add Anaconda to your PATH environment variable
- I recommend selecting “Yes” for convenience, though the installer suggests “No”

Launching Anaconda Navigator

Windows: Start menu → Anaconda3 → Anaconda Navigator
macOS: Launchpad → Anaconda Navigator
Linux: Terminal → anaconda-navigator

Navigator Interface Overview

When you open Navigator, you’ll see a dashboard with various applications and tools:

The main sections include:

Home: Launch applications like Jupyter Notebook, JupyterLab, etc.
Environments: Create and manage conda environments
Learning: Educational resources (tutorials, documentation)
Community: Forums, bug reports, feature requests

Creating an Environment for Financial Analysis

Let’s create a dedicated environment for financial analysis:

Click on “Environments” in the left sidebar
Click the “Create” button at the bottom
Name it “finance” and select Python 3.9
Click “Create”
With your new environment selected, switch to “Installed” packages
Use the search box to find and install essential financial packages:
- pandas
- numpy
- matplotlib
- pandas-datareader
- yfinance
- scipy
- statsmodels
- scikit-learn

After selecting the packages, click “Apply” to install them in your environment.

Using Navigator to Launch Applications

Now that we have our environment set up:

Go back to the “Home” tab
Make sure your “finance” environment is selected in the dropdown
Click “Launch” under Jupyter Notebook

This will start Jupyter Notebook with access to all the packages we installed in our finance environment.

Jupyter Notebooks: Interactive Financial Data Analysis

Jupyter Notebooks are interactive documents that combine code, outputs, visualisations, and explanatory text. They’re perfect for financial analysis where you want to document your thought process alongside your calculations.

Installing Jupyter

If you’re using Anaconda, Jupyter is already installed. Otherwise, you can install it with pip:

# Using pip in a virtual environment
pip install notebook

# Using conda
conda install -c conda-forge notebook

Launching Jupyter Notebook

# From the command line
jupyter notebook

This will open a browser window showing the Jupyter dashboard.

Notebook Anatomy

A Jupyter Notebook (.ipynb file) consists of cells, which can be:

Code cells: Contain executable Python code
Markdown cells: Contain formatted text, equations, and explanations
Raw cells: Contain unformatted text

Let’s create a simple notebook to analyse stock returns:

# In a code cell
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import yfinance as yf
from datetime import datetime

# Set the output to display inline
%matplotlib inline

# Make the plots look nicer
plt.style.use('fivethirtyeight')

In a new code cell, let’s download some financial data:

# Define a list of tech stocks
tech_stocks = ['AAPL', 'MSFT', 'GOOG', 'AMZN']

# Set date range for analysis
start_date = '2020-01-01'
end_date = datetime.now().strftime('%Y-%m-%d')

# Download the data
df = yf.download(tech_stocks, start=start_date, end=end_date)

# Display the first few rows of Adjusted Close prices
df['Adj Close'].head()

Now let’s add a Markdown cell to explain what we’re doing:

## Tech Stock Performance Analysis

This analysis examines the performance of major tech stocks since 2020, including:
- Apple (AAPL)
- Microsoft (MSFT)
- Google (GOOG)
- Amazon (AMZN)

We'll calculate returns and volatility to assess risk-adjusted performance.

Next, let’s calculate returns and create a visualisation:

# Calculate daily returns
returns = df['Adj Close'].pct_change().dropna()

# Plot the cumulative returns
(1 + returns).cumprod().plot(figsize=(12, 8))
plt.title('Cumulative Returns of Tech Stocks (2020-Present)')
plt.ylabel('Cumulative Return')
plt.axhline(y=1, color='k', linestyle='--', alpha=0.3)
plt.show()

We can also calculate risk metrics:

# Calculate annualized volatility (standard deviation of returns * sqrt(252 trading days))
volatility = returns.std() * np.sqrt(252)

# Calculate annualized returns
ann_returns = (1 + returns.mean())**252 - 1

# Create a risk-return DataFrame
risk_return = pd.DataFrame({
 'Annualized Return': ann_returns,
 'Annualized Volatility': volatility,
 'Sharpe Ratio': ann_returns / volatility # Simplified Sharpe ratio (assuming 0% risk-free rate)
}).sort_values('Sharpe Ratio', ascending=False)

risk_return

Notebook Features That Enhance Financial Analysis

Magic Commands

Jupyter notebooks support “magic commands” that enhance functionality:

# Display all variables in memory
%who

# Time the execution of a cell
%%time
result = [i**2 for i in range(1000000)]

# Run external shell commands
!pip list | grep pandas

Rich Display for Financial Data

Jupyter can display HTML, charts, tables, and even interactive visualisations:

# Interactive stock chart using Plotly
import plotly.express as px

fig = px.line(
 returns.reset_index(), 
 x='Date', 
 y=tech_stocks,
 title='Daily Returns of Tech Stocks'
)
fig.show()

Widgets for Interactive Financial Models

Jupyter supports interactive widgets that let you build dynamic financial models:

from ipywidgets import interact, FloatSlider

def calculate_loan_payment(principal=100000, interest_rate=0.05, years=30):
 """Calculate monthly mortgage payment."""
 monthly_rate = interest_rate / 12
 payments = years * 12
 payment = principal * (monthly_rate * (1 + monthly_rate)**payments) / ((1 + monthly_rate)**payments - 1)
 
 return f"Monthly payment: ${payment:.2f}"

interact(
 calculate_loan_payment,
 principal=FloatSlider(min=50000, max=1000000, step=10000, value=250000),
 interest_rate=FloatSlider(min=0.01, max=0.10, step=0.0025, value=0.045),
 years=FloatSlider(min=5, max=30, step=5, value=30)
)

Once you’ve completed your analysis, you can:

Share the .ipynb file with colleagues who have Jupyter installed
Export to various formats:
- HTML (with interactive elements)
- PDF (for formal reports)
- Python script (.py)
- Markdown
- Slides (for presentations)

To export:

File → Download as → Select format
Or from the command line: jupyter nbconvert --to pdf my_notebook.ipynb

Using Notebooks for Financial Reporting

Notebooks are excellent for creating reproducible financial reports:

Start with a markdown cell describing the purpose of the analysis
Import data from your financial systems
Perform calculations and create visualisations
Add markdown cells explaining your methodology and findings
Export to PDF or HTML for distribution

For example, here’s how you might start a monthly financial performance report:

# Monthly Financial Performance Report
## Period: April 2023

This notebook analyzes the company's financial performance for April 2023 compared to budget and previous periods. It includes:

1. Revenue analysis by product line
2. Cost structure breakdown
3. Margin analysis
4. Cash flow metrics
5. Financial ratios

**Data sources:** GL extract as of May 3, 2023

JupyterLab: The Next-Generation Notebook Interface

While Jupyter Notebook is fantastic, JupyterLab is its more powerful successor with a modern interface.

Installing JupyterLab

# Using pip
pip install jupyterlab

# Using conda
conda install -c conda-forge jupyterlab

If you’re using Anaconda, JupyterLab is already installed.

Launching JupyterLab

# From the command line
jupyter lab

JupyterLab Features for Financial Analysis

JupyterLab enhances the notebook experience with:

Multiple panels: View multiple notebooks, terminals, and files side-by-side
File browser: Navigate your project files without leaving the interface
Integrated terminal: Run shell commands directly in JupyterLab
Table of Contents: Navigate long financial reports easily
Extensions: Add functionality like Git integration, variable inspectors, etc.

This layout is particularly useful for financial analysis where you might want to:

Compare multiple financial models side-by-side
Keep reference data open while working on calculations
Run terminal commands to fetch latest financial data
Browse through different financial statements

Google Colab: Cloud-Based Notebooks

If you want to work on notebooks without installing anything, Google Colab is a free, cloud-based alternative:

Runs entirely in the browser
Provides free access to GPUs and TPUs for machine learning
Integrates with Google Drive for storage
Includes many pre-installed data science packages

It’s perfect for:

Working on financial analysis when you’re away from your main computer
Sharing interactive financial models with colleagues who don’t have Python installed
Experimenting with machine learning for financial predictions

Visit Google Colab to get started.

Practical Example: Building an Interactive Financial Dashboard

Let’s bring everything together with a practical example. Here’s an outline for creating an interactive financial dashboard in a Jupyter notebook:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import plotly.graph_objects as go
from ipywidgets import interact, widgets
from datetime import datetime, timedelta

# Sample financial data (in practice, you'd import from your financial systems)
def generate_financial_data():
 # Generate dates for the past 12 months
 end_date = datetime.now()
 start_date = end_date - timedelta(days=365)
 dates = pd.date_range(start=start_date, end=end_date, freq='M')
 
 # Create sample department data with some randomness
 np.random.seed(42) # For reproducibility
 
 data = {
 'Date': dates,
 'Revenue': 1000000 + np.random.normal(0, 50000, len(dates)) + np.linspace(0, 200000, len(dates)),
 'COGS': 600000 + np.random.normal(0, 30000, len(dates)) + np.linspace(0, 100000, len(dates)),
 'Marketing': 50000 + np.random.normal(0, 5000, len(dates)),
 'R&D': 75000 + np.random.normal(0, 7500, len(dates)),
 'Admin': 100000 + np.random.normal(0, 10000, len(dates)),
 'IT': 40000 + np.random.normal(0, 4000, len(dates))
 }
 
 df = pd.DataFrame(data)
 
 # Calculate derived metrics
 df['Gross_Profit'] = df['Revenue'] - df['COGS']
 df['Total_Expenses'] = df['Marketing'] + df['R&D'] + df['Admin'] + df['IT']
 df['Operating_Income'] = df['Gross_Profit'] - df['Total_Expenses']
 df['Gross_Margin'] = df['Gross_Profit'] / df['Revenue']
 df['Operating_Margin'] = df['Operating_Income'] / df['Revenue']
 
 return df

# Generate our sample data
financial_data = generate_financial_data()

# Display first few rows
financial_data.head()

Now let’s create interactive visualisations:

# Create a function for our dashboard
def financial_dashboard(metric):
 if metric == 'Revenue vs Expenses':
 fig = go.Figure()
 fig.add_trace(go.Bar(
 x=financial_data['Date'],
 y=financial_data['Revenue'],
 name='Revenue'
 ))
 fig.add_trace(go.Bar(
 x=financial_data['Date'],
 y=financial_data['COGS'] + financial_data['Total_Expenses'],
 name='Total Costs'
 ))
 fig.update_layout(
 title='Revenue vs. Total Costs',
 xaxis_title='Month',
 yaxis_title='Amount ($)',
 barmode='group'
 )
 
 elif metric == 'Profit Margins':
 fig = go.Figure()
 fig.add_trace(go.Scatter(
 x=financial_data['Date'],
 y=financial_data['Gross_Margin'],
 mode='lines+markers',
 name='Gross Margin'
 ))
 fig.add_trace(go.Scatter(
 x=financial_data['Date'],
 y=financial_data['Operating_Margin'],
 mode='lines+markers',
 name='Operating Margin'
 ))
 fig.update_layout(
 title='Profit Margins Over Time',
 xaxis_title='Month',
 yaxis_title='Margin (%)',
 yaxis=dict(tickformat='.0%')
 )
 
 elif metric == 'Expense Breakdown':
 # Create a pie chart of the latest month's expenses
 latest = financial_data.iloc[-1]
 labels = ['COGS', 'Marketing', 'R&D', 'Admin', 'IT']
 values = [latest['COGS'], latest['Marketing'], latest['R&D'], latest['Admin'], latest['IT']]
 
 fig = go.Figure(data=[go.Pie(
 labels=labels,
 values=values,
 hole=.3
 )])
 fig.update_layout(title=f'Expense Breakdown (Latest Month: {latest["Date"].strftime("%b %Y")})')
 
 elif metric == 'Trend Analysis':
 # Month-over-month growth rates
 growth_data = financial_data.copy()
 growth_data['Revenue_Growth'] = financial_data['Revenue'].pct_change() * 100
 growth_data['Gross_Profit_Growth'] = financial_data['Gross_Profit'].pct_change() * 100
 growth_data['Operating_Income_Growth'] = financial_data['Operating_Income'].pct_change() * 100
 
 fig = go.Figure()
 fig.add_trace(go.Bar(
 x=growth_data['Date'][1:], # Skip first month (no growth rate)
 y=growth_data['Revenue_Growth'][1:],
 name='Revenue Growth'
 ))
 fig.add_trace(go.Bar(
 x=growth_data['Date'][1:],
 y=growth_data['Operating_Income_Growth'][1:],
 name='Operating Income Growth'
 ))
 fig.update_layout(
 title='Month-over-Month Growth Rates',
 xaxis_title='Month',
 yaxis_title='Growth Rate (%)'
 )
 
 fig.show()

# Create an interactive widget
interact(
 financial_dashboard,
 metric=widgets.Dropdown(
 options=['Revenue vs Expenses', 'Profit Margins', 'Expense Breakdown', 'Trend Analysis'],
 value='Revenue vs Expenses',
 description='Metric:',
 style={'description_width': 'initial'}
 )
)

This interactive dashboard allows you to explore different financial metrics with a dropdown menu. In a real-world scenario, you would connect this to your actual financial data sources.

Conclusion

The Python ecosystem offers a rich set of tools for financial analysis, from package managers to interactive notebooks. Let’s recap what we’ve covered:

Package and environment management: pip, conda, and Anaconda each have their place in the Python ecosystem, with conda being particularly valuable for complex financial analysis packages.
Anaconda Navigator: Provides a user-friendly interface for managing environments and launching applications, making it easier to set up environments for different financial analysis tasks.
Jupyter Notebooks: Offer an interactive way to combine code, data, and narrative, perfect for financial reporting and exploratory analysis.
JupyterLab: Enhances the notebook experience with a multi-panel interface ideal for complex financial analysis workflows.
Interactive widgets: Allow you to build dynamic financial models and dashboards without web development knowledge.

As you continue your Python journey, these tools will become essential parts of your financial analysis toolkit. They enable a more interactive, exploratory approach to financial data analysis that traditional spreadsheets simply can’t match.

Next Steps

Install Anaconda and create a dedicated environment for financial analysis
Convert an existing financial spreadsheet to a Jupyter notebook
Create an interactive dashboard for a key financial metric you track
Explore the extensive ecosystem of financial packages available in Python

In the next post, we’ll dive deeper into NumPy, the foundation for numerical computing in Python, and see how it can speed up your financial calculations.

Command-Line Tools & Automation with Python (Python for Finance, part 9)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 26 Jun 2025 00:00:00 +0000

I’ve discovered that some of the most practical Python applications aren’t fancy data visualisations or machine learning models, but rather simple automation scripts that save time on repetitive tasks. In this post, I’ll walk through how to build command-line tools and automate everyday processes using Python.

Building Command-Line Scripts with argparse

When you’re working with financial data, you often need flexible tools that can handle different inputs. The argparse module lets you build command-line scripts that accept various arguments and options.

Basic argparse Structure

First, let’s create a simple script that calculates compound interest:

import argparse

def calculate_compound_interest(principal, rate, time, compounds_per_year=1):
 """Calculate compound interest.
 
 Args:
 principal: Initial investment amount
 rate: Annual interest rate (decimal)
 time: Time in years
 compounds_per_year: Number of times interest compounds per year
 
 Returns:
 Final amount after compound interest
 """
 return principal * (1 + rate/compounds_per_year)**(compounds_per_year*time)

def main():
 # Create argument parser
 parser = argparse.ArgumentParser(description='Calculate compound interest')
 
 # Add arguments
 parser.add_argument('principal', type=float, help='Initial investment amount')
 parser.add_argument('rate', type=float, help='Annual interest rate (decimal)')
 parser.add_argument('time', type=float, help='Time in years')
 parser.add_argument('--compounds', type=int, default=1, 
 help='Number of times interest compounds per year (default: 1)')
 
 # Parse arguments
 args = parser.parse_args()
 
 # Calculate result
 result = calculate_compound_interest(
 args.principal, 
 args.rate, 
 args.time, 
 args.compounds
 )
 
 # Print result
 print(f"Initial principal: ${args.principal:.2f}")
 print(f"Annual rate: {args.rate:.2%}")
 print(f"Time: {args.time} years")
 print(f"Compounds per year: {args.compounds}")
 print(f"Final amount: ${result:.2f}")
 print(f"Interest earned: ${result - args.principal:.2f}")

if __name__ == "__main__":
 main()

Save this script as compound_interest.py and run it from the command line:

python compound_interest.py 10000 0.05 5 --compounds 12

This would calculate the compound interest on $10,000 at 5% annual interest for 5 years, compounded monthly.

Understanding argparse Components

Let’s break down what’s happening in our script:

We create an ArgumentParser object with a description
We add arguments with add_argument():
- Positional arguments (principal, rate, time) are required
- Optional arguments (like --compounds) start with -- and have default values
We parse the command-line arguments with parse_args()
We access the values via args.parameter_name

Adding Help Text

One of the best features of argparse is automatic help text generation. Users can run your script with -h or --help to see instructions:

python compound_interest.py --help

Which produces:

usage: compound_interest.py [-h] [--compounds COMPOUNDS] principal rate time

Calculate compound interest

positional arguments:
 principal Initial investment amount
 rate Annual interest rate (decimal)
 time Time in years

optional arguments:
 -h, --help show this help message and exit
 --compounds COMPOUNDS Number of times interest compounds per year (default: 1)

More argparse Features

For financial applications, you might want to add more sophisticated options:

parser.add_argument('--currency', default='$', help='Currency symbol to display')
parser.add_argument('--output-file', help='Save results to a file')
parser.add_argument('--verbose', '-v', action='store_true', help='Display additional information')

The action='store_true' creates a flag that’s either True or False depending on whether it’s included.

Packaging Entry Points for Installable Commands

If you find yourself using the same script frequently, you can package it so it’s available as a system-wide command.

Creating a Package Structure

First, organise your files like this:

finance_tools/
├── finance_tools/
│ ├── __init__.py
│ ├── compound_interest.py
│ └── other_modules.py
├── README.md
└── pyproject.toml

Setting Up pyproject.toml

Create a pyproject.toml file:

[build-system]
requires = ["setuptools>=42", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "finance_tools"
version = "0.1.0"
description = "Financial calculation tools"
readme = "README.md"
authors = [{name = "Your Name", email = "your.email@example.com"}]
license = {text = "MIT"}
requires-python = ">=3.6"

[project.scripts]
compound-interest = "finance_tools.compound_interest:main"

The [project.scripts] section is what creates the entry point. After installing this package, you’ll be able to run compound-interest directly from your command line without typing python first.

Installing Your Package

Install your package in development mode:

pip install -e .

Now you can run:

compound-interest 10000 0.05 5 --compounds 12

Automating File and Folder Tasks

As a finance professional, you probably deal with lots of reports, spreadsheets, and data files. Python can help automate file handling tasks.

Basic File Operations with os and shutil

Here’s a script that organises financial statements by month and type:

import os
import shutil
import re
import argparse
from datetime import datetime

def organize_financial_statements(source_dir, target_dir):
 """Organise financial statements into folders by month and type.
 
 Assumes filenames like: 'Income_Statement_2023-05-15.xlsx' or 'Balance_Sheet_05_15_2023.pdf'
 """
 # Create target directory if it doesn't exist
 os.makedirs(target_dir, exist_ok=True)
 
 # Regular expressions for date patterns
 patterns = [
 r'(\d{4})-(\d{2})-\d{2}', # YYYY-MM-DD
 r'(\d{2})_\d{2}_(\d{4})', # MM_DD_YYYY
 r'(\d{2})-\d{2}-(\d{4})' # MM-DD-YYYY
 ]
 
 # Document types to look for
 doc_types = ['Income_Statement', 'Balance_Sheet', 'Cash_Flow', 'Trial_Balance']
 
 # Process each file in the source directory
 for filename in os.listdir(source_dir):
 file_path = os.path.join(source_dir, filename)
 
 # Skip directories
 if os.path.isdir(file_path):
 continue
 
 # Try to extract date
 date_found = False
 for pattern in patterns:
 match = re.search(pattern, filename)
 if match:
 # Extract year and month
 if len(match.group(1)) == 4: # If first group is year (YYYY-MM-DD)
 year, month = match.group(1), match.group(2)
 else: # If first group is month (MM_DD_YYYY)
 month, year = match.group(1), match.group(2)
 
 month_name = datetime.strptime(month, "%m").strftime("%B")
 date_found = True
 break
 
 if not date_found:
 # If no date pattern found, put in 'Unsorted'
 year, month_name = 'Unsorted', 'Unsorted'
 
 # Try to match document type
 doc_type = 'Other'
 for dtype in doc_types:
 if dtype in filename:
 doc_type = dtype
 break
 
 # Create year and month folders if they don't exist
 year_dir = os.path.join(target_dir, year)
 os.makedirs(year_dir, exist_ok=True)
 
 month_dir = os.path.join(year_dir, month_name)
 os.makedirs(month_dir, exist_ok=True)
 
 # Create document type folder if it doesn't exist
 doc_type_dir = os.path.join(month_dir, doc_type)
 os.makedirs(doc_type_dir, exist_ok=True)
 
 # Copy the file to its destination
 dest_path = os.path.join(doc_type_dir, filename)
 shutil.copy2(file_path, dest_path)
 print(f"Copied {filename} to {dest_path}")

def main():
 parser = argparse.ArgumentParser(description='Organise financial statements by date and type')
 parser.add_argument('source_dir', help='Directory containing financial statements')
 parser.add_argument('--target-dir', default='./Organised_Statements',
 help='Target directory for organised files (default: ./Organised_Statements)')
 
 args = parser.parse_args()
 organize_financial_statements(args.source_dir, args.target_dir)
 print("Financial statement organisation complete!")

if __name__ == "__main__":
 main()

This script:

Scans a directory for financial documents
Extracts dates and document types from filenames
Creates an organised folder structure by year, month, and document type
Copies files to the appropriate locations

Understanding Key File Operations

os.path.join(): Combines path components correctly for your operating system
os.makedirs(): Creates directories recursively with exist_ok=True to avoid errors
os.listdir(): Lists files and directories in a path
shutil.copy2(): Copies files while preserving metadata

Automating Financial Report Backups

Here’s another practical example that creates date-stamped backups of your financial reports:

import os
import shutil
import datetime
import argparse
import zipfile

def backup_financial_reports(reports_dir, backup_dir=None):
 """Create a date-stamped ZIP backup of financial reports."""
 # Set default backup directory if none provided
 if backup_dir is None:
 backup_dir = os.path.join(os.path.dirname(reports_dir), 'Backups')
 
 # Create backup directory if it doesn't exist
 os.makedirs(backup_dir, exist_ok=True)
 
 # Create timestamp for backup filename
 timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
 backup_filename = f"Financial_Reports_Backup_{timestamp}.zip"
 backup_path = os.path.join(backup_dir, backup_filename)
 
 # Create ZIP file
 with zipfile.ZipFile(backup_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
 # Walk through all files in the reports directory
 for root, _, files in os.walk(reports_dir):
 for file in files:
 file_path = os.path.join(root, file)
 # Calculate path relative to reports_dir for ZIP structure
 rel_path = os.path.relpath(file_path, reports_dir)
 zipf.write(file_path, rel_path)
 print(f"Added {rel_path} to backup")
 
 print(f"Backup created at: {backup_path}")
 print(f"Total size: {os.path.getsize(backup_path) / (1024*1024):.2f} MB")
 
 return backup_path

def main():
 parser = argparse.ArgumentParser(description='Create a backup of financial reports')
 parser.add_argument('reports_dir', help='Directory containing financial reports')
 parser.add_argument('--backup-dir', help='Target directory for backups')
 
 args = parser.parse_args()
 backup_financial_reports(args.reports_dir, args.backup_dir)

if __name__ == "__main__":
 main()

Automating GUI Interactions with PyAutoGUI

Sometimes you need to automate interactions with desktop applications that don’t have APIs. For example, maybe you need to extract data from an older accounting system that can only export data through its GUI. PyAutoGUI can help automate these interactions.

Installing and Setting Up PyAutoGUI

pip install pyautogui

Safety Features

PyAutoGUI has a fail-safe feature - quickly move your mouse to any corner of the screen to abort the script. This is crucial when you’re testing automation that controls your mouse!

Basic PyAutoGUI Example

Here’s a simple script that could help export a monthly report from a financial application:

import pyautogui
import time
import argparse
from datetime import datetime

# Safety delay - gives you time to switch to the target application
SAFETY_DELAY = 5

def export_monthly_report(year, month):
 """Automate exporting a monthly report from a financial application.
 
 Args:
 year: Year for the report
 month: Month number (1-12) for the report
 """
 # Convert month number to name for the filename
 month_name = datetime.strptime(f"{month}", "%m").strftime("%B")
 
 print(f"Preparing to export {month_name} {year} report...")
 print(f"Switch to your financial application within {SAFETY_DELAY} seconds!")
 time.sleep(SAFETY_DELAY)
 
 # Click on 'Reports' menu
 pyautogui.click(x=100, y=20) # Adjust coordinates based on your application
 time.sleep(1)
 
 # Click on 'Monthly' option
 pyautogui.click(x=100, y=50) # Adjust coordinates based on your application
 time.sleep(1)
 
 # Fill in date fields
 pyautogui.typewrite(str(year))
 pyautogui.press('tab')
 pyautogui.typewrite(str(month).zfill(2))
 pyautogui.press('tab')
 
 # Click 'Generate Report' button
 pyautogui.click(x=200, y=300) # Adjust coordinates based on your application
 time.sleep(3) # Wait for report to generate
 
 # Save the report
 pyautogui.hotkey('ctrl', 's') # Press Ctrl+S to save
 time.sleep(1)
 
 # Type the filename
 filename = f"Financial_Report_{year}_{month_name}.xlsx"
 pyautogui.typewrite(filename)
 pyautogui.press('enter')
 time.sleep(2)
 
 print(f"Report exported as {filename}")

def main():
 parser = argparse.ArgumentParser(description='Automate monthly report export')
 parser.add_argument('--year', type=int, default=datetime.now().year, 
 help='Year for the report (default: current year)')
 parser.add_argument('--month', type=int, default=datetime.now().month - 1 or 12,
 help='Month for the report (1-12, default: previous month)')
 
 args = parser.parse_args()
 
 # Validate month
 if not 1 <= args.month <= 12:
 print("Error: Month must be between 1 and 12")
 return
 
 export_monthly_report(args.year, args.month)

if __name__ == "__main__":
 main()

Important note: The coordinates in this script (e.g., pyautogui.click(x=100, y=20)) need to be adjusted for your specific application. Use pyautogui.position() to get the coordinates of your mouse pointer.

PyAutoGUI Key Functions

pyautogui.click(x, y): Move mouse to coordinates and click
pyautogui.typewrite('text'): Type text
pyautogui.press('key'): Press a single key
pyautogui.hotkey('ctrl', 's'): Press multiple keys simultaneously
pyautogui.screenshot(): Take a screenshot
pyautogui.locateOnScreen('image.png'): Find an image on screen

Putting It All Together: Sample Financial Automation Project

Let’s build a financial quarter-end automation tool that:

Creates organised backup of last quarter’s data
Generates reports using a GUI application
Organises the reports into the correct folders

import os
import argparse
import time
import datetime
import pyautogui
import shutil
import zipfile

def get_last_quarter(reference_date=None):
 """Calculate the previous quarter based on a reference date."""
 if reference_date is None:
 reference_date = datetime.datetime.now()
 
 current_month = reference_date.month
 current_year = reference_date.year
 
 # Calculate previous quarter end month (3, 6, 9, or 12)
 last_quarter_month = ((current_month - 1) // 3) * 3
 if last_quarter_month == 0:
 last_quarter_month = 12
 last_quarter_year = current_year - 1
 else:
 last_quarter_year = current_year
 
 return last_quarter_year, last_quarter_month

def create_backup(data_dir, backup_dir=None):
 """Create a date-stamped ZIP backup."""
 if backup_dir is None:
 backup_dir = os.path.join(os.path.dirname(data_dir), 'Quarterly_Backups')
 
 os.makedirs(backup_dir, exist_ok=True)
 
 timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
 backup_filename = f"Financial_Data_Backup_{timestamp}.zip"
 backup_path = os.path.join(backup_dir, backup_filename)
 
 with zipfile.ZipFile(backup_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
 for root, _, files in os.walk(data_dir):
 for file in files:
 file_path = os.path.join(root, file)
 rel_path = os.path.relpath(file_path, data_dir)
 zipf.write(file_path, rel_path)
 print(f"Added {rel_path} to backup")
 
 print(f"Backup created at: {backup_path}")
 return backup_path

def generate_quarterly_reports(year, quarter, output_dir):
 """Automate generating quarterly reports using PyAutoGUI."""
 os.makedirs(output_dir, exist_ok=True)
 
 # Calculate quarter end month
 end_month = quarter * 3
 
 # Quarter name for folder organization
 quarter_name = f"Q{quarter}_{year}"
 
 print(f"Preparing to generate {quarter_name} reports...")
 print("Switch to your financial application within 5 seconds!")
 time.sleep(5)
 
 # This is a simplified example - you would need to adjust coordinates
 # and actions based on your specific application
 
 # Click on Reports menu
 pyautogui.click(x=100, y=20)
 time.sleep(1)
 
 # Click on Quarterly Reports
 pyautogui.click(x=100, y=80)
 time.sleep(1)
 
 # Enter year and quarter
 pyautogui.typewrite(str(year))
 pyautogui.press('tab')
 pyautogui.typewrite(str(quarter))
 pyautogui.press('tab')
 
 # Generate reports
 report_types = [
 "Income_Statement",
 "Balance_Sheet",
 "Cash_Flow",
 "Accounts_Receivable"
 ]
 
 for report_type in report_types:
 # Select report type from dropdown
 pyautogui.press('down', presses=report_types.index(report_type) + 1)
 pyautogui.press('enter')
 time.sleep(1)
 
 # Click Generate button
 pyautogui.click(x=200, y=300)
 time.sleep(3) # Wait for report to generate
 
 # Save report
 pyautogui.hotkey('ctrl', 's')
 time.sleep(1)
 
 # Type filename and save to output directory
 filename = f"{report_type}_{quarter_name}.xlsx"
 filepath = os.path.join(output_dir, filename)
 pyautogui.typewrite(filepath)
 pyautogui.press('enter')
 time.sleep(2)
 
 print(f"Generated {filename}")
 
 # Return to report selection
 pyautogui.click(x=150, y=150)
 time.sleep(1)
 
 return output_dir

def organize_reports(reports_dir, organized_dir=None):
 """Organize reports into a structured folder system."""
 if organized_dir is None:
 organized_dir = os.path.join(os.path.dirname(reports_dir), 'Organized_Reports')
 
 os.makedirs(organized_dir, exist_ok=True)
 
 # Process each file in the reports directory
 for filename in os.listdir(reports_dir):
 file_path = os.path.join(reports_dir, filename)
 
 # Skip directories
 if os.path.isdir(file_path):
 continue
 
 # Extract information from filename
 parts = filename.split('_')
 if len(parts) >= 3:
 report_type = parts[0]
 quarter_info = parts[1] # e.g., "Q1"
 year = parts[2].split('.')[0] # Remove file extension
 
 # Create folders if they don't exist
 year_dir = os.path.join(organized_dir, year)
 os.makedirs(year_dir, exist_ok=True)
 
 quarter_dir = os.path.join(year_dir, quarter_info)
 os.makedirs(quarter_dir, exist_ok=True)
 
 # Copy the file to its destination
 dest_path = os.path.join(quarter_dir, filename)
 shutil.copy2(file_path, dest_path)
 print(f"Organized {filename} to {dest_path}")
 
 return organized_dir

def main():
 parser = argparse.ArgumentParser(description='Automate quarterly financial processes')
 parser.add_argument('--data-dir', default='./Financial_Data',
 help='Directory containing financial data')
 parser.add_argument('--year', type=int, 
 help='Year for processing (default: previous quarter\'s year)')
 parser.add_argument('--quarter', type=int,
 help='Quarter for processing (1-4, default: previous quarter)')
 
 args = parser.parse_args()
 
 # Determine year and quarter if not specified
 if args.year is None or args.quarter is None:
 calc_year, calc_month = get_last_quarter()
 
 # Map month to quarter
 calc_quarter = (calc_month + 2) // 3
 
 if args.year is None:
 args.year = calc_year
 if args.quarter is None:
 args.quarter = calc_quarter
 
 # Validate quarter
 if not 1 <= args.quarter <= 4:
 print("Error: Quarter must be between 1 and 4")
 return
 
 print(f"=== Starting Quarter-End Process for Q{args.quarter} {args.year} ===")
 
 # Step 1: Create backup
 print("\n-- Step 1: Creating Data Backup --")
 backup_path = create_backup(args.data_dir)
 
 # Step 2: Generate reports
 print("\n-- Step 2: Generating Quarterly Reports --")
 reports_dir = f"./Reports_Q{args.quarter}_{args.year}"
 reports_path = generate_quarterly_reports(args.year, args.quarter, reports_dir)
 
 # Step 3: Organise reports
 print("\n-- Step 3: Organizing Reports --")
 organized_dir = organize_reports(reports_path)
 
 print("\n=== Quarter-End Process Complete ===")
 print(f"Data backup: {backup_path}")
 print(f"Reports directory: {reports_path}")
 print(f"Organized reports: {organized_dir}")

if __name__ == "__main__":
 main()

Conclusion

Automation is where Python really shines for finance professionals. Even if you never build a complex data model or web application, these automation tools can save you hours of repetitive work each week:

CLI tools with argparse help you build flexible, reusable scripts
Package entry points let you install your tools system-wide
File operations with os and shutil organise your financial documents
PyAutoGUI can automate interactions with desktop financial applications

As you build your automation toolkit, start small with scripts that solve specific pain points in your workflow. Over time, you’ll develop a collection of tools that dramatically increase your productivity.

Next Steps

Try automating a simple task you perform regularly
Build a command-line tool for a financial calculation you frequently need
Create a script to organise a messy folder of financial documents
Consider which parts of your quarter-end process could be automated

Remember that the best automations are the ones that solve your specific problems. The scripts in this post are just starting points - customise them to fit your unique workflow needs.

Resources

Testing & Debugging Python Code (Python for Finance, part 8)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 19 Jun 2025 00:00:00 +0000

When working with financial data and calculations, accuracy is essential. A small bug in your code could mean reporting incorrect figures, making flawed investment decisions, or even compliance issues. This post will guide you through testing and debugging techniques that ensure your financial Python code works correctly and reliably.

Why Testing Matters in Finance

Imagine you’ve created a Python script that calculates loan amortisation schedules. Your company uses this tool to price thousands of loans. If there’s an error in your interest calculation logic, even a small one, the financial impact could be enormous.

As a finance professional, you need confidence in your code. Testing provides that confidence by systematically verifying that your calculations work correctly across a range of scenarios and edge cases.

Unit Testing Basics

Unit testing involves testing individual components (usually functions) in isolation to ensure they work as expected.

Getting Started with unittest

Python’s built-in unittest framework provides all the tools you need for basic testing. Let’s test our financial ratio calculator from the previous post:

First, create a file called test_ratio_calculator.py:

import unittest
from ratio_calculator import calculate_current_ratio, calculate_debt_to_equity

class TestFinancialRatios(unittest.TestCase):
 
 def test_current_ratio(self):
 # Test basic calculation
 self.assertEqual(calculate_current_ratio(100000, 50000), 2.0)
 
 # Test with zero liabilities - should raise ValueError
 with self.assertRaises(ValueError):
 calculate_current_ratio(100000, 0)
 
 def test_debt_to_equity(self):
 # Test basic calculation
 self.assertEqual(calculate_debt_to_equity(200000, 400000), 0.5)
 
 # Test highly leveraged company
 self.assertEqual(calculate_debt_to_equity(800000, 200000), 4.0)
 
 # Test with zero equity - should raise ValueError
 with self.assertRaises(ValueError):
 calculate_debt_to_equity(100000, 0)

if __name__ == '__main__':
 unittest.main()

Run the tests with:

python test_ratio_calculator.py

If all tests pass, you’ll see something like:

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

If a test fails, unittest will tell you which test failed and why, helping you pinpoint the issue.

Common Assertions in unittest

Here are some assertions particularly useful for financial calculations:

# Checking exact equality
self.assertEqual(calculate_npv(cash_flows, 0.1), 1025.79)

# Checking approximate equality (for floating point calculations)
self.assertAlmostEqual(calculate_irr([-1000, 500, 600]), 0.0734, places=4)

# Checking if a value is greater than another
self.assertGreater(calculate_profit_margin(revenue, costs), 0)

# Checking if an exception is raised for invalid inputs
with self.assertRaises(ValueError):
 calculate_pe_ratio(stock_price=50, earnings_per_share=0)

Moving to pytest

While unittest is perfectly capable, pytest offers a more modern and flexible approach to testing. Let’s see how we might test the same functions with pytest:

Install pytest:

pip install pytest

Create a file named test_ratios_pytest.py:

import pytest
from ratio_calculator import calculate_current_ratio, calculate_debt_to_equity

def test_current_ratio_basic():
 assert calculate_current_ratio(100000, 50000) == 2.0

def test_current_ratio_zero_liabilities():
 with pytest.raises(ValueError):
 calculate_current_ratio(100000, 0)

def test_debt_to_equity_basic():
 assert calculate_debt_to_equity(200000, 400000) == 0.5

def test_debt_to_equity_high_leverage():
 assert calculate_debt_to_equity(800000, 200000) == 4.0

def test_debt_to_equity_zero_equity():
 with pytest.raises(ValueError):
 calculate_debt_to_equity(100000, 0)

Run the tests:

pytest test_ratios_pytest.py -v

The -v flag gives you verbose output showing each test that was run.

The Power of pytest Fixtures

One of pytest’s most powerful features is fixtures, which let you set up preconditions for your tests. This is especially useful for financial testing where you might have complex data structures:

import pytest
from financial_analyzer import StockAnalyzer

@pytest.fixture
def sample_stock_data():
 # Return a sample dataset that can be used by multiple tests
 return {
 'ticker': 'AAPL',
 'prices': [150.25, 151.30, 149.80, 152.50, 153.75],
 'volumes': [12345678, 9876543, 11234567, 10234567, 13456789],
 'financials': {
 'revenue': 365.82, # In billions
 'net_income': 94.68, # In billions
 'total_assets': 351.0, # In billions
 'total_liabilities': 287.91, # In billions
 'shareholders_equity': 63.09 # In billions
 }
 }

def test_pe_ratio_calculation(sample_stock_data):
 analyzer = StockAnalyzer(sample_stock_data)
 # Assuming current price is the last in the list and EPS is net_income / outstanding_shares
 # For this example, let's say outstanding_shares is 16.07B
 expected_pe = 150.25 / (94.68 / 16.07)
 assert round(analyzer.calculate_pe_ratio(), 2) == round(expected_pe, 2)

def test_debt_to_equity_ratio(sample_stock_data):
 analyzer = StockAnalyzer(sample_stock_data)
 expected_ratio = 287.91 / 63.09
 assert round(analyzer.calculate_debt_to_equity(), 2) == round(expected_ratio, 2)

This way, you set up your test data once and reuse it across multiple tests.

Parameterised Tests for Multiple Scenarios

Financial calculations often need to be tested with multiple sets of inputs. Pytest’s parameterisation makes this elegant:

import pytest
from finance_calcs import calculate_compound_interest

@pytest.mark.parametrize("principal,rate,time,compounding,expected", [
 (1000, 0.05, 5, 1, 1276.28), # Annual compounding
 (1000, 0.05, 5, 12, 1283.36), # Monthly compounding
 (1000, 0.05, 5, 365, 1284.52), # Daily compounding
])
def test_compound_interest(principal, rate, time, compounding, expected):
 result = calculate_compound_interest(principal, rate, time, compounding)
 assert round(result, 2) == expected

This tests our compound interest function with annual, monthly, and daily compounding periods, all in a single test function.

Test-Driven Development (TDD) for Finance

Test-Driven Development is a methodology where you write tests before you write code. For financial calculations, this approach can be particularly beneficial:

Write the test first: Define what your function should do before implementing it
Run the test and watch it fail: Confirm the test works
Write the implementation: Create the function to make the test pass
Run the test again: Verify your implementation works
Refactor: Clean up your code while ensuring tests continue to pass

A TDD Example: Calculating EBITDA

Let’s say we need to add an EBITDA calculation function. Following TDD:

First, write the test:

# test_financial_metrics.py
import pytest
from financial_metrics import calculate_ebitda

def test_calculate_ebitda():
 # EBITDA = Net Income + Interest + Taxes + Depreciation + Amortisation
 income_statement = {
 'net_income': 1000000,
 'interest_expense': 200000,
 'income_tax': 300000,
 'depreciation': 150000,
 'amortisation': 50000
 }
 
 expected_ebitda = 1700000 # Sum of all the components
 
 assert calculate_ebitda(income_statement) == expected_ebitda

Run the test (it will fail since we haven’t implemented the function yet):

pytest test_financial_metrics.py

Implement the function:

# financial_metrics.py
def calculate_ebitda(income_statement):
 """
 Calculate EBITDA from income statement components.
 
 Args:
 income_statement (dict): Dictionary containing income statement items
 
 Returns:
 float: EBITDA value
 """
 return (
 income_statement['net_income'] +
 income_statement['interest_expense'] +
 income_statement['income_tax'] +
 income_statement['depreciation'] +
 income_statement['amortisation']
 )

Run the test again - it should pass now!

Debugging Financial Code

Even with tests, bugs will sometimes creep into your code. Let’s explore techniques to find and fix them.

Print-Driven Debugging

The simplest debugging technique is adding print() statements to your code:

def calculate_loan_payment(principal, annual_rate, years):
 monthly_rate = annual_rate / 12
 print(f"Monthly rate: {monthly_rate}")
 
 num_payments = years * 12
 print(f"Number of payments: {num_payments}")
 
 payment = principal * (monthly_rate * (1 + monthly_rate) ** num_payments) / \
 ((1 + monthly_rate) ** num_payments - 1)
 print(f"Calculated payment: {payment}")
 
 return payment

While simple, this approach can be effective for quick debugging sessions.

Using Python’s Built-in Debugger (pdb)

For more complex issues, Python’s debugger (pdb) gives you interactive control:

def analyze_portfolio(holdings):
 import pdb; pdb.set_trace() # Debugger will start here
 
 total_value = 0
 for ticker, data in holdings.items():
 shares = data['shares']
 price = data['current_price']
 position_value = shares * price
 total_value += position_value
 
 return total_value

When this code runs, it will pause at the pdb.set_trace() line and drop you into an interactive debugger. Common commands include:

n (next): Execute the current line and move to the next one
s (step): Step into a function call
c (continue): Continue execution until the next breakpoint
p variable_name: Print the value of a variable
q (quit): Exit the debugger

IDE-Based Debugging

Most modern IDEs offer powerful visual debugging:

Set a breakpoint by clicking in the margin next to your code
Start the debugger (usually with a “Debug” button)
The program will pause at your breakpoint
Examine variables, step through code, and find issues

This is particularly useful for financial applications where you need to inspect complex data structures or track down calculation errors.

Common Financial Code Bugs

Watch out for these common issues in financial code:

Rounding errors: Financial calculations often require precise decimal handling

# Problematic: Floating point imprecision
0.1 + 0.2 # Returns 0.30000000000000004

# Better: Use Decimal for financial calculations
from decimal import Decimal
Decimal('0.1') + Decimal('0.2') # Returns Decimal('0.3')

Off-by-one errors in time periods: Check if your code correctly handles time period boundaries

# Is this calculating 29 or 30 days of interest?
days_in_month = 30
daily_interest = principal * (annual_rate / 365)
total_interest = 0

# Potential off-by-one error
for day in range(days_in_month): # This gives 0-29, so only 30 days
 total_interest += daily_interest

Negative input validation: Financial functions often have domain restrictions

def calculate_loan_payment(principal, rate, years):
 # Validate inputs
 if principal <= 0:
 raise ValueError("Principal must be positive")
 if rate < 0:
 raise ValueError("Interest rate cannot be negative")
 if years <= 0:
 raise ValueError("Loan term must be positive")
 
 # Rest of the calculation

Custom Exceptions for Financial Validation

Creating custom exceptions helps make your financial code more robust and self-documenting:

class NegativePrincipalError(ValueError):
 """Raised when a negative principal amount is provided"""
 pass

class ZeroDivisionFinancialError(ValueError):
 """Raised when a financial calculation would result in division by zero"""
 pass

def calculate_return_on_investment(gain, cost):
 """
 Calculate ROI: (Gain - Cost) / Cost
 
 Args:
 gain (float): The amount gained from the investment
 cost (float): The cost of the investment
 
 Returns:
 float: ROI as a decimal
 
 Raises:
 NegativePrincipalError: If cost is negative
 ZeroDivisionFinancialError: If cost is zero
 """
 if cost < 0:
 raise NegativePrincipalError("Investment cost cannot be negative")
 if cost == 0:
 raise ZeroDivisionFinancialError("Cannot calculate ROI with zero cost")
 
 return (gain - cost) / cost

These custom exceptions make error handling clearer and provide better feedback to users of your code.

Structured Logging for Financial Applications

For production financial applications, proper logging is essential for auditing and debugging:

import logging

# Set up logging
logging.basicConfig(
 filename='financial_calculations.log',
 level=logging.INFO,
 format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

def calculate_mortgage_payment(principal, rate, years):
 """Calculate monthly mortgage payment"""
 logging.info(f"Calculating mortgage payment: principal={principal}, rate={rate}, years={years}")
 
 try:
 monthly_rate = rate / 12
 num_payments = years * 12
 
 if monthly_rate == 0:
 payment = principal / num_payments
 else:
 payment = principal * (monthly_rate * (1 + monthly_rate) ** num_payments) / \
 ((1 + monthly_rate) ** num_payments - 1)
 
 logging.info(f"Calculated payment: {payment}")
 return payment
 
 except Exception as e:
 logging.error(f"Error calculating mortgage payment: {str(e)}")
 raise

This creates a log file with timestamped entries that can be invaluable for tracking down issues in complex financial applications.

Logging Levels

Different logging levels serve different purposes:

logging.DEBUG: Detailed information, typically useful only for diagnosing problems
logging.INFO: Confirmation that things are working as expected
logging.WARNING: Indication that something unexpected happened, but the program is still working
logging.ERROR: Due to a more serious problem, the program couldn’t perform a function
logging.CRITICAL: A serious error indicating the program may be unable to continue running

For financial applications, consider using these levels to differentiate between routine calculations and potential issues:

def analyze_investment_portfolio(portfolio):
 logging.info(f"Analyzing portfolio with {len(portfolio)} positions")
 
 for position in portfolio:
 # Log routine information
 logging.debug(f"Processing position: {position['ticker']}")
 
 # Log potential concerns
 if position['allocation'] > 0.20: # More than 20% in single position
 logging.warning(f"High concentration in {position['ticker']}: {position['allocation']:.1%}")
 
 # Log serious issues
 if position['value'] < 0:
 logging.error(f"Negative position value for {position['ticker']}: {position['value']}")

Handling Sensitive Financial Data in Logs

Be careful not to log sensitive financial information:

# BAD: Logging personal financial data
logging.info(f"Processing transaction for account {account_number}, balance: {balance}")

# GOOD: Log only what's necessary without exposing private data
logging.info(f"Processing transaction for account ending in {account_number[-4:]}")

Putting It All Together: A Complete Financial Testing Example

Let’s bring everything together with a complete example for a financial calculator module:

# financial_calculator.py
from decimal import Decimal
import logging

# Set up logging
logging.basicConfig(
 filename='financial_calculator.log',
 level=logging.INFO,
 format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

class FinancialError(Exception):
 """Base class for financial calculation errors"""
 pass

class NegativeValueError(FinancialError):
 """Raised when a negative value is provided where it's not allowed"""
 pass

class ZeroValueError(FinancialError):
 """Raised when a zero value is provided where it's not allowed"""
 pass

def npv(cash_flows, discount_rate):
 """
 Calculate Net Present Value for a series of cash flows.
 
 Args:
 cash_flows (list): List of cash flows where the first element is typically negative (investment)
 discount_rate (float): Annual discount rate as a decimal (e.g., 0.1 for 10%)
 
 Returns:
 Decimal: Net Present Value rounded to 2 decimal places
 
 Raises:
 TypeError: If inputs are not in the expected format
 ValueError: If discount_rate is less than -1
 """
 logging.info(f"Calculating NPV with discount rate: {discount_rate}")
 logging.debug(f"Cash flows: {cash_flows}")
 
 if not isinstance(cash_flows, (list, tuple)):
 logging.error("Cash flows must be a list or tuple")
 raise TypeError("Cash flows must be a list or tuple")
 
 if not all(isinstance(cf, (int, float, Decimal)) for cf in cash_flows):
 logging.error("All cash flows must be numeric")
 raise TypeError("All cash flows must be numeric")
 
 if discount_rate < -1:
 logging.error(f"Invalid discount rate: {discount_rate}")
 raise ValueError("Discount rate cannot be less than -100%")
 
 # Convert to Decimal for precise financial calculations
 npv_value = Decimal('0')
 rate = Decimal(str(discount_rate))
 
 for i, cf in enumerate(cash_flows):
 cf_decimal = Decimal(str(cf))
 # Initial cash flow isn't discounted
 if i == 0:
 npv_value += cf_decimal
 else:
 npv_value += cf_decimal / (Decimal('1') + rate) ** Decimal(str(i))
 
 logging.info(f"NPV calculation result: {npv_value.quantize(Decimal('0.01'))}")
 return npv_value.quantize(Decimal('0.01')) # Round to 2 decimal places

def irr(cash_flows, guess=0.1, tolerance=0.0001, max_iterations=1000):
 """
 Calculate Internal Rate of Return for a series of cash flows.
 
 Args:
 cash_flows (list): List of cash flows where the first element is typically negative
 guess (float): Initial guess for IRR
 tolerance (float): The calculation will stop when the result is within this tolerance
 max_iterations (int): Maximum number of iterations to perform
 
 Returns:
 float: The internal rate of return as a decimal
 
 Raises:
 ValueError: If calculation doesn't converge
 """
 # Implementation using Newton's method
 # (Full implementation would go here)
 logging.info("IRR calculation requested")
 # Simplified example return for brevity
 return 0.1548

And here’s how we would test this module:

# test_financial_calculator.py
import pytest
from decimal import Decimal
from financial_calculator import npv, irr, NegativeValueError, ZeroValueError

class TestNPV:
 def test_basic_npv_calculation(self):
 # Initial investment of 1000, followed by 4 annual returns
 cash_flows = [-1000, 300, 400, 400, 300]
 assert npv(cash_flows, 0.1) == Decimal('152.92')
 
 def test_npv_with_all_positive_values(self):
 # All positive cash flows (unusual but mathematically valid)
 cash_flows = [1000, 300, 400, 500]
 assert npv(cash_flows, 0.1) > Decimal('1000')
 
 def test_npv_with_high_discount_rate(self):
 cash_flows = [-1000, 300, 400, 400, 300]
 # High discount rate should reduce NPV
 assert npv(cash_flows, 0.25) < npv(cash_flows, 0.1)
 
 def test_npv_with_invalid_input(self):
 # Test with non-list input
 with pytest.raises(TypeError):
 npv("not a list", 0.1)
 
 # Test with non-numeric cash flows
 with pytest.raises(TypeError):
 npv([-1000, "300", 400], 0.1)
 
 # Test with invalid discount rate
 with pytest.raises(ValueError):
 npv([-1000, 300, 400], -1.5) # Can't have less than -100% discount

class TestIRR:
 def test_basic_irr_calculation(self):
 cash_flows = [-1000, 300, 400, 400, 300]
 # Using almost equal because IRR can have small floating point differences
 assert abs(irr(cash_flows) - 0.1548) < 0.0001
 
 # Additional IRR tests would go here...

# We could add more test classes for other financial functions

Conclusion

For finance professionals using Python, robust testing and debugging are essential practices that ensure your calculations are reliable and accurate. By incorporating unit tests, effective debugging strategies, and structured logging into your workflow, you can build financial tools that you and your colleagues can trust.

In our next post, we’ll explore how to turn your financial scripts into proper command-line tools and automate routine financial tasks; a crucial skill for improving your productivity as a finance professional.

Practice Exercises

Create a simple function to calculate compound interest with different compounding periods, then write tests for it using pytest.
Debug a financial calculation by setting breakpoints and using your IDE’s debugging tools.
Implement a custom exception for a financial calculation and write a test that verifies it’s raised appropriately.
Add structured logging to a financial script you’ve already written.

Further Resources

pytest Documentation
Python Debugging with pdb
Python’s logging Module
Test-Driven Development by Example by Kent Beck
Clean Code by Robert C. Martin

Code Quality & Collaboration in Python (Python for Finance, part 7)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 12 Jun 2025 00:00:00 +0000

As a finance professional learning Python, you’ll soon want to move beyond writing scripts just for yourself. Whether you’re building financial models, automating reporting, or creating data analysis tools, there comes a point when your code needs to be shared with colleagues or even the wider finance community. This post will guide you through best practices for creating high-quality, shareable code.

Version Control: Git & GitHub for Financial Projects

Why Version Control Matters in Finance

Imagine you’ve built a Python script that calculates key financial ratios from quarterly reports. After sharing it with your team, you make changes that accidentally break the debt-to-equity calculation. Without version control, finding and fixing this error could be a nightmare. With Git, you can simply revert to the previous working version.

In finance, where accuracy is paramount and regulatory compliance often requires audit trails, version control is essential.

Getting Started with Git

First, download and install Git for your operating system.

Once installed, open a command prompt or terminal and set up your identity:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Creating Your First Finance Repository

Let’s walk through creating a repository for a simple financial calculator:

Create a new directory for your project:

mkdir financial-ratio-calculator
cd financial-ratio-calculator

Initialis a Git repository:

git init

You’ll see a message that an empty Git repository has been initialised.

Create a simple Python file called ratio_calculator.py:

def calculate_current_ratio(current_assets, current_liabilities):
 """
 Calculate the current ratio.
 
 Args:
 current_assets (float): Total current assets
 current_liabilities (float): Total current liabilities
 
 Returns:
 float: Current ratio (current assets / current liabilities)
 """
 if current_liabilities == 0:
 raise ValueError("Current liabilities cannot be zero (division by zero)")
 return current_assets / current_liabilities

def calculate_debt_to_equity(total_debt, shareholders_equity):
 """
 Calculate the debt-to-equity ratio.
 
 Args:
 total_debt (float): Total debt
 shareholders_equity (float): Total shareholders' equity
 
 Returns:
 float: Debt-to-equity ratio (total debt / shareholders' equity)
 """
 if shareholders_equity == 0:
 raise ValueError("Shareholders' equity cannot be zero (division by zero)")
 return total_debt / shareholders_equity

# Add more financial ratios as needed

Track the file with Git:

git add ratio_calculator.py

Commit the changes:

git commit -m "Add basic financial ratio calculator functions"

Core Git Commands for Daily Use

git status: Check which files have been modified
git diff: See exactly what changed in your files
git add <filename>: Stage a file for commit
git commit -m "Your message": Commit staged changes
git log: View commit history

Branching for New Features

Branching lets you work on new features without affecting your main code. This is perfect for when you’re adding new financial calculations to your toolkit.

# Create a branch for a new profitability ratio feature
git branch profitability-ratios

# Switch to that branch
git checkout profitability-ratios

Or do both at once:

git checkout -b profitability-ratios

Now add some code to your ratio_calculator.py file:

def calculate_roe(net_income, average_shareholders_equity):
 """
 Calculate Return on Equity (ROE).
 
 Args:
 net_income (float): Net income for the period
 average_shareholders_equity (float): Average shareholders' equity
 
 Returns:
 float: ROE ratio (net income / average shareholders' equity)
 """
 if average_shareholders_equity == 0:
 raise ValueError("Average shareholders' equity cannot be zero")
 return net_income / average_shareholders_equity

Commit this new function:

git add ratio_calculator.py
git commit -m "Add ROE calculation function"

When you’re ready to merge this back into your main code:

git checkout main
git merge profitability-ratios

Collaborating with GitHub

GitHub extends Git’s functionality by hosting your repositories online, making collaboration easier.

Create a GitHub account if you don’t have one
Create a new repository on GitHub
Connect your local repository to GitHub:

git remote add origin https://github.com/yourusername/financial-ratio-calculator.git
git push -u origin main

Now your code is on GitHub! You can share the link with colleagues, collaborate on improvements, and track issues.

Pull Requests: The Professional Way to Collaborate

When working with a team of financial analysts, direct changes to the main codebase can be risky. Pull requests (PRs) provide a mechanism for review and discussion before code is merged:

Make your changes in a separate branch
Push that branch to GitHub
Open a PR to merge your branch into main
Have teammates review your code
Merge the PR once approved

This workflow is perfect for finance teams where code accuracy is critical; catching calculation errors before they make it into production reports!

Writing Clean, PEP 8 Compliant Code

What is PEP 8?

PEP 8 is Python’s style guide—a set of conventions for writing readable code. In finance, where you might be sharing models with auditors or other stakeholders, clean code is particularly important.

Key PEP 8 Rules for Finance Code

Use 4 spaces for indentation (not tabs)
Keep lines under 79 characters for better readability in documentation
Use descriptive variable names that reflect financial concepts:

# Bad
def calc(a, b):
 return a / b

# Good
def calculate_price_to_earnings_ratio(stock_price, earnings_per_share):
 return stock_price / earnings_per_share

Use whitespace appropriately:

# Bad
profit=revenue-expenses
tax_amount=profit*tax_rate

# Good
profit = revenue - expenses
tax_amount = profit * tax_rate

Using Linters: flake8

Linters automatically check your code for style issues. Let’s set up flake8:

Install flake8:

pip install flake8

Run flake8 on your code:

flake8 ratio_calculator.py

It will show any style violations that need fixing.

For a real finance project, create a configuration file (.flake8) in your project root:

[flake8]
max-line-length = 88
exclude = .git,__pycache__,build,dist
per-file-ignores =
 __init__.py: F401

Auto-formatting with black

Why spend time manually formatting code when tools can do it for you?

Install black:

pip install black

Format your code:

black ratio_calculator.py

Black will automatically reformat your code to follow a consistent style.

For finance projects, you might want to create a pyproject.toml file to configure black:

[tool.black]
line-length = 88
target-version = ['py38']
include = '\.pyi?$'
exclude = '''
/(
 \.git
 | \.hg
 | \.mypy_cache
 | \.tox
 | \.venv
 | _build
 | buck-out
 | build
 | dist
)/
'''

Organising Imports with isort

isort automatically organises your import statements by type and alphabetically.

Install isort:

pip install isort

Run isort on your file:

isort ratio_calculator.py

For finance projects where you might be importing various data analysis libraries, isort keeps your imports clean and consistent:

# Standard library imports
import datetime
import os
from decimal import Decimal

# Third-party imports
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt

# Local application imports
from .financial_models import discounted_cash_flow
from .ratio_analysis import calculate_current_ratio

Writing Effective Documentation

Docstrings: Your Future Self Will Thank You

Documentation isn’t just for others, it’s useful for you six months from now when you can’t remember why you wrote that complex financial calculation a certain way.

Google Style Docstrings

def calculate_npv(cash_flows, discount_rate):
 """
 Calculate Net Present Value of a series of cash flows.
 
 Args:
 cash_flows (list): List of cash flows, where the first element is the initial investment (negative)
 discount_rate (float): Annual discount rate as a decimal (e.g., 0.1 for 10%)
 
 Returns:
 float: Net Present Value
 
 Examples:
 >>> calculate_npv([-1000, 200, 300, 400, 500], 0.1)
 152.07
 """
 npv = cash_flows[0] # Initial investment
 for i, cf in enumerate(cash_flows[1:], 1):
 npv += cf / (1 + discount_rate) ** i
 return round(npv, 2)

NumPy Style Docstrings

def calculate_irr(cash_flows):
 """
 Calculate Internal Rate of Return for a series of cash flows.
 
 Parameters
 ----------
 cash_flows : list or array-like
 List of cash flows, where the first element is the initial investment (negative)
 
 Returns
 -------
 float
 The Internal Rate of Return as a decimal
 
 Notes
 -----
 Uses Newton's method to find the rate that makes NPV = 0
 
 Examples
 --------
 >>> calculate_irr([-1000, 300, 400, 500])
 0.1548
 """
 # IRR implementation...

Choose one style and be consistent across your project.

Generating Documentation with Sphinx

For larger finance projects, automatic documentation generation with Sphinx is invaluable:

Install Sphinx:

pip install sphinx sphinx-rtd-theme

Set up a docs directory:

mkdir docs
cd docs
sphinx-quickstart

Configure conf.py to use a nice theme:

html_theme = 'sphinx_rtd_theme'

Build your documentation:

sphinx-build -b html . _build

This creates HTML documentation you can share with your finance team.

Putting It All Together: A Finance Project Workflow

Let’s walk through a complete workflow for a hypothetical financial analysis tool:

Set up your environment:
- Create a virtual environment
- Install dependencies
- Set up Git
Create your project structure:

financial-analysis-toolkit/
├── .git/
├── .gitignore
├── .flake8
├── pyproject.toml
├── README.md
├── requirements.txt
├── setup.py
├── docs/
└── financial_toolkit/
 ├── __init__.py
 ├── ratio_analysis.py
 ├── valuation_models.py
 ├── risk_metrics.py
 └── utilities.py

Write your code with documentation:
- Start with core functions
- Add comprehensive docstrings
- Make small, focused commits
Validate with linters and formatters:
- Run black to format code
- Run isort to organise imports
- Run flake8 to check for issues
Create tests (more on this in the next post)
Push to GitHub and collaborate:
- Share with colleagues
- Use pull requests for reviews
- Track issues and feature requests

Conclusion

As a finance professional using Python, the practices outlined in this post will help you create reliable, maintainable code that you can confidently share with colleagues or the wider finance community. Taking the time to learn these professional techniques now will save you countless hours in the future and elevate the quality of your financial analysis tools.

In the next post, we’ll look at testing and debugging your financial code, which are critical skills for ensuring your calculations are accurate and robust.

Further Resources

Questions for Practice:

Try creating a Git repository for a simple financial calculator with at least three ratio calculations
Format your code with black and check it with flake8
Write Google-style docstrings for each function
Push your repository to GitHub and create a README explaining what your calculator does

Virtual Environments & Packaging in Python (Python for Finance, part 6)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 05 Jun 2025 00:00:00 +0000

As your Python journey progresses and you start building more sophisticated financial tools, you’ll inevitably need to use external libraries. This is where virtual environments and package management become crucial skills. In this post, I’ll cover how to create isolated environments for your projects and manage dependencies effectively.

Why Virtual Environments Matter

Imagine this scenario: You’re working on two different financial applications. One requires pandas version 1.3 for compatibility with other tools, while the other needs the latest pandas 2.0 for new features. Without virtual environments, you’d be forced to choose one version for your entire system, potentially breaking one of your applications.

Virtual environments solve this problem by creating isolated Python installations for each project. Benefits include:

Dependency isolation: Each project can have its own versions of packages
Reproducibility: Easily share environment specifications with colleagues
Clean testing: Test in environments that match production settings
Avoiding permission issues: Install packages without admin privileges

Creating and Managing Virtual Environments

Python comes with the venv module built-in, which is the recommended way to create virtual environments.

Creating a Virtual Environment on Windows

Open Command Prompt and navigate to your project directory:

cd C:\Users\YourName\Documents\financial-analysis-project

Create a new virtual environment:

python -m venv env

This creates a directory named env containing a copy of the Python interpreter and the standard library.

Activating the Virtual Environment

On Windows:

env\Scripts\activate

You’ll notice your command prompt changes to show the active environment:

(env) C:\Users\YourName\Documents\financial-analysis-project>

If you’re using PowerShell instead of Command Prompt on Windows, the commands are slightly different:

.\env\Scripts\Activate.ps1

If you encounter execution policy restrictions, you may need to allow script execution:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Now any Python commands will use this isolated environment.

Notes for macOS/Linux

The process is similar on macOS and Linux, with slight differences:

Create: python3 -m venv env
Activate: source env/bin/activate

Deactivating the Virtual Environment

When you’re done working on your project:

deactivate

Your prompt will return to normal, and Python commands will use the system interpreter again.

Managing Packages with pip

pip is Python’s package installer, and it’s the primary tool for adding external libraries to your environments.

Installing Packages

Once your virtual environment is activated, install packages with:

pip install package-name

For example, to install key financial packages:

pip install pandas numpy matplotlib openpyxl xlrd

You can also specify exact versions:

pip install pandas==1.5.3

Or version ranges:

pip install pandas>=1.4.0,<2.0.0

Listing Installed Packages

To see what’s installed in your environment:

pip list

Output example:

Package Version
--------------- -------
matplotlib 3.7.1
numpy 1.24.3
openpyxl 3.1.2
pandas 1.5.3
pip 23.1.2
python-dateutil 2.8.2
pytz 2023.3
setuptools 65.6.3
six 1.16.0
tzdata 2023.3
xlrd 2.0.1

Freezing Requirements

When you want to share your project, it’s important to specify exactly which packages and versions it needs. The freeze command creates a requirements file:

pip freeze > requirements.txt

This generates a text file with all installed packages and their versions:

# requirements.txt contents
matplotlib==3.7.1
numpy==1.24.3
openpyxl==3.1.2
pandas==1.5.3
python-dateutil==2.8.2
pytz==2023.3
six==1.16.0
tzdata==2023.3
xlrd==2.0.1

Installing from Requirements

When someone else (or you on a different machine) wants to recreate your environment:

pip install -r requirements.txt

This is essential for collaborative financial projects where everyone needs the same libraries and versions.

Practical Example: Setting Up a Financial Analysis Environment

Let’s walk through creating a virtual environment for a financial analysis project:

# Create project directory
mkdir financial_analysis
cd financial_analysis

# Create and activate virtual environment
python -m venv env
env\Scripts\activate

# Install required packages
pip install pandas numpy matplotlib openpyxl xlsxwriter jupyter

# Verify installations
pip list

# Create requirements.txt
pip freeze > requirements.txt

# Create a marker file for your project
echo # Financial Analysis Project > README.md

Basic Package Structure

As your financial tools grow more complex, you might want to create your own Python packages that you can reuse across projects or share with colleagues.

Project Structure

A typical Python package structure looks like this:

financial_tools/
│
├── pyproject.toml # Modern project configuration
├── README.md # Documentation
├── LICENSE # License information
│
└── src/ # Source code directory
 └── financial_tools/ # Actual package
 ├── __init__.py # Makes it a package
 ├── analysis.py # Analysis module
 ├── reporting.py # Reporting module
 └── utils.py # Utility functions

The `init.py` File

This file marks a directory as a Python package and can be used to define what gets imported when someone uses your package:

# src/financial_tools/__init__.py

# Version information
__version__ = '0.1.0'

# Import commonly used functions for easier access
from .analysis import calculate_roi, calculate_npv
from .reporting import generate_monthly_report

Setting Up a Package with `pyproject.toml`

Modern Python packaging uses pyproject.toml for configuration:

[build-system]
requires = ["setuptools>=42", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "financial_tools"
version = "0.1.0"
description = "Tools for financial analysis and reporting"
readme = "README.md"
authors = [
 {name = "Your Name", email = "your.email@example.com"}
]
license = {text = "MIT"}
classifiers = [
 "Programming Language :: Python :: 3",
 "License :: OSI Approved :: MIT License",
 "Operating System :: OS Independent",
]
dependencies = [
 "pandas>=1.3.0",
 "numpy>=1.20.0",
 "matplotlib>=3.4.0",
]
requires-python = ">=3.8"

[project.urls]
"Homepage" = "https://github.com/yourusername/financial_tools"
"Bug Tracker" = "https://github.com/yourusername/financial_tools/issues"

[project.optional-dependencies]
dev = [
 "pytest>=6.0",
 "black>=21.5b2",
 "flake8>=3.9",
]
excel = [
 "openpyxl>=3.0.0",
 "xlsxwriter>=1.4.0",
]

Building and Installing Your Package

With your package structure set up, you can install it in development mode:

pip install -e .

This makes the package available but still editable in its original location.

Publishing to PyPI

When your financial package is ready to share with the world, you can publish it to the Python Package Index (PyPI).

Build Distribution Packages

First, make sure you have the build tools:

pip install build twine

Then create distribution packages:

python -m build

This will create a directory called dist with distribution files.

Upload to PyPI

Use twine to upload your package:

twine upload dist/*

You’ll need to create an account on PyPI before uploading.

Versioning Best Practices

For financial software where accuracy is critical, proper versioning is essential:

Use Semantic Versioning: MAJOR.MINOR.PATCH
- MAJOR: Incompatible API changes
- MINOR: New features, backward-compatible
- PATCH: Bug fixes, backward-compatible
Document Changes: Keep a CHANGELOG.md file
Version Bumping: Update version in one place only (pyproject.toml)
Git Tags: Tag releases in your version control system

git tag -a v0.1.0 -m "Initial release"
git push origin v0.1.0

Real-World Example: Financial Toolkit Package

Let’s create a minimal example of what a financial analysis package might look like:

# src/financial_tools/analysis.py

def calculate_roi(gain, cost):
 """
 Calculate Return on Investment (ROI)
 
 Args:
 gain: The profit or gain from the investment
 cost: The cost of the investment
 
 Returns:
 ROI as a decimal (e.g., 0.15 for 15%)
 """
 return (gain - cost) / cost


def calculate_npv(cash_flows, discount_rate):
 """
 Calculate Net Present Value
 
 Args:
 cash_flows: List of cash flows where the first element is the initial investment (negative)
 discount_rate: The discount rate as a decimal (e.g., 0.1 for 10%)
 
 Returns:
 The Net Present Value of the cash flows
 """
 npv = 0
 for i, cf in enumerate(cash_flows):
 npv += cf / (1 + discount_rate) ** i
 return npv


def calculate_irr(cash_flows, iterations=1000, guess=0.1):
 """
 Calculate Internal Rate of Return using iterative approach
 
 Args:
 cash_flows: List of cash flows where the first element is the initial investment (negative)
 iterations: Maximum number of iterations to perform
 guess: Initial guess for the IRR
 
 Returns:
 Estimated IRR as a decimal
 """
 rate = guess
 step = 0.05
 
 for _ in range(iterations):
 npv = calculate_npv(cash_flows, rate)
 
 if abs(npv) < 0.0001:
 # NPV is very close to zero, we found the IRR
 return rate
 
 if npv > 0:
 # NPV is positive, increase the rate
 rate += step
 else:
 # NPV is negative, decrease the rate
 rate -= step
 
 # Reduce step size to improve accuracy
 step /= 2
 
 # Return best approximation after iterations
 return rate

# src/financial_tools/reporting.py

import datetime

def generate_summary_report(data, title="Financial Summary"):
 """
 Generate a simple text-based financial report
 
 Args:
 data: Dictionary of financial metrics
 title: Report title
 
 Returns:
 Formatted report as a string
 """
 now = datetime.datetime.now()
 
 # Create header
 report = f"{title}\n"
 report += f"{'=' * len(title)}\n"
 report += f"Generated: {now.strftime('%Y-%m-%d %H:%M')}\n\n"
 
 # Add metrics
 for key, value in data.items():
 # Format numbers nicely
 if isinstance(value, (int, float)):
 if abs(value) >= 1000:
 formatted_value = f"${value:,.2f}"
 else:
 formatted_value = f"${value:.2f}"
 else:
 formatted_value = str(value)
 
 report += f"{key}: {formatted_value}\n"
 
 return report


def format_as_percentage(value, decimal_places=2):
 """Format a decimal as a percentage string"""
 return f"{value * 100:.{decimal_places}f}%"

Using the Package

Once installed, users could easily import and use your financial toolkit:

from financial_tools.analysis import calculate_roi, calculate_npv
from financial_tools.reporting import generate_summary_report, format_as_percentage

# Calculate investment metrics
investment_cost = 50000
annual_returns = [-50000, 12000, 15000, 18000, 20000]

roi = calculate_roi(sum(annual_returns) + investment_cost, investment_cost)
npv = calculate_npv(annual_returns, 0.08)

# Generate report
report_data = {
 "Investment Amount": investment_cost,
 "Total Returns": sum(annual_returns[1:]),
 "ROI": format_as_percentage(roi),
 "NPV (8%)": npv,
 "Break-even": "Year 3"
}

report = generate_summary_report(report_data, "Investment Analysis")
print(report)

Conclusion

Virtual environments and proper packaging are essential skills for any Python developer, especially when working on financial applications where consistency and reproducibility are critical. By mastering these concepts, you’ll ensure your projects are well-organised, shareable, and isolated from potential dependency conflicts.

In the next post, we’ll look at code quality and collaboration tools that will help you write cleaner, more maintainable financial applications and work effectively with others.

Functions, Modules & File I/O in Python (Python for Finance, part 5)

michaelbrunger@gmail.com (Michael Brunger) — Fri, 30 May 2025 00:00:00 +0000

These next concepts incredibly useful for organising code and working with external data. Let’s explore how Python handles functions, modules, and file operations - all essential skills for financial analysis and reporting.

Defining and Calling Functions

Functions are reusable blocks of code that perform specific tasks. They help keep your code DRY (Don’t Repeat Yourself) and make it more maintainable.

Basic Function Syntax

def function_name(parameters):
 """Docstring explaining what the function does."""
 # Function body
 return result # Optional

Here’s a simple function that calculates compound interest:

def calculate_compound_interest(principal, rate, time, compounds_per_year=1):
 """
 Calculate compound interest.
 
 Args:
 principal: Initial investment amount
 rate: Annual interest rate (as decimal, e.g., 0.05 for 5%)
 time: Time period in years
 compounds_per_year: Number of times interest compounds per year (default=1)
 
 Returns:
 The final amount after compound interest
 """
 return principal * (1 + rate/compounds_per_year)**(compounds_per_year*time)

Let’s call this function:

# Calculate investment growth at 5% interest, compounded quarterly for 10 years
initial_investment = 10000
final_amount = calculate_compound_interest(
 principal=initial_investment, 
 rate=0.05, 
 time=10, 
 compounds_per_year=4
)
print(f"${initial_investment} will grow to ${final_amount:.2f} after 10 years")

Output:

$10000 will grow to $16470.09 after 10 years

Function Arguments

Python offers flexible ways to handle function arguments:

Positional vs. Keyword Arguments

# Positional arguments (order matters)
result1 = calculate_compound_interest(10000, 0.05, 10, 4)

# Keyword arguments (order doesn't matter)
result2 = calculate_compound_interest(
 rate=0.05,
 principal=10000,
 compounds_per_year=4,
 time=10
)

Default Parameter Values

In our function, compounds_per_year=1 provides a default value if not specified:

# Using the default compounds_per_year (annual compounding)
annual_result = calculate_compound_interest(10000, 0.05, 10)
print(f"With annual compounding: ${annual_result:.2f}")

Variable Number of Arguments

For functions that need to accept varying numbers of arguments:

# *args collects extra positional arguments as a tuple
def sum_all_values(*args):
 """Sum any number of values."""
 return sum(args)

# **kwargs collects extra keyword arguments as a dictionary
def create_financial_report(report_date, **kwargs):
 """Create a financial report with flexible data points."""
 report = {"date": report_date}
 report.update(kwargs)
 return report

# Example usage
total = sum_all_values(100, 250, 300, 75)
print(f"Total: ${total}")

report = create_financial_report(
 "2025-04-28",
 revenue=150000,
 expenses=95000,
 net_profit=55000,
 profit_margin=0.37
)
print(report)

Variable Scope and Namespaces

Understanding scope is crucial for debugging and writing clean code.

Local vs. Global Scope

total_assets = 1000000 # Global variable

def calculate_roi(profit):
 investment = 100000 # Local variable
 return profit / investment * 100

# investment is not accessible here
print(f"Total assets: ${total_assets}")

roi = calculate_roi(25000)
print(f"ROI: {roi}%")

Local variables exist only within their function. Global variables can be accessed inside functions, but to modify them, you need the global keyword:

balance = 5000 # Global variable

def deposit(amount):
 global balance # Tell Python we want to modify the global variable
 balance += amount
 return balance

def withdraw(amount):
 global balance
 if balance >= amount:
 balance -= amount
 return balance
 else:
 return "Insufficient funds"

print(f"Initial balance: ${balance}")
deposit(1000)
print(f"After deposit: ${balance}")
withdraw(2000)
print(f"After withdrawal: ${balance}")

Namespaces

Python uses namespaces to organise names and avoid conflicts. Each module, function, and class has its own namespace.

Organising Code into Modules and Packages

As your financial scripts grow, organising code becomes essential.

Modules

A module is simply a .py file containing code. Let’s create a financial utilities module:

# financial_utils.py
def calculate_roi(profit, investment):
 """Calculate Return on Investment as a percentage."""
 return (profit / investment) * 100

def calculate_npv(cash_flows, discount_rate):
 """
 Calculate Net Present Value of a series of cash flows.
 
 Args:
 cash_flows: List of cash flows, where index 0 is the initial investment (negative)
 discount_rate: Discount rate as decimal (e.g., 0.1 for 10%)
 """
 npv = 0
 for t, cash_flow in enumerate(cash_flows):
 npv += cash_flow / (1 + discount_rate) ** t
 return npv

To use this module:

# main.py
import financial_utils

# Calculate ROI
investment = 50000
profit = 12500
roi = financial_utils.calculate_roi(profit, investment)
print(f"ROI: {roi}%")

# Calculate NPV of a project
cash_flows = [-100000, 30000, 35000, 45000, 50000] # Initial investment + 4 years of returns
npv = financial_utils.calculate_npv(cash_flows, 0.08)
print(f"NPV: ${npv:.2f}")

You can also import specific functions:

from financial_utils import calculate_roi, calculate_npv

# Now use without the module prefix
roi = calculate_roi(12500, 50000)

Packages

Packages are directories containing multiple modules. They require an __init__.py file (which can be empty) to be recognised as packages.

finance_package/
├── __init__.py
├── analysis.py
├── reporting.py
└── utils.py

Using packages:

# Import specific modules from a package
from finance_package import analysis, reporting

# Import specific functions from a module in a package
from finance_package.utils import calculate_roi

Exploring the Standard Library

Python comes with a rich standard library. Here are some modules particularly useful for financial applications:

Math Module

import math

# Calculate loan payment using the PMT formula
principal = 250000
annual_rate = 0.04 # 4%
years = 30
monthly_rate = annual_rate / 12
num_payments = years * 12

# Monthly payment formula
payment = principal * (monthly_rate * math.pow(1 + monthly_rate, num_payments)) / (math.pow(1 + monthly_rate, num_payments) - 1)
print(f"Monthly mortgage payment: ${payment:.2f}")

Random Module

import random

# Simulate stock price movements (very simplified)
starting_price = 100
daily_volatility = 0.015 # 1.5%

prices = [starting_price]
for day in range(30):
 change = random.normalvariate(0, daily_volatility)
 new_price = prices[-1] * (1 + change)
 prices.append(new_price)

print(f"Starting price: ${starting_price:.2f}")
print(f"Ending price: ${prices[-1]:.2f}")
print(f"30-day return: {(prices[-1]/prices[0] - 1) * 100:.2f}%")

Datetime Module

from datetime import datetime, timedelta

# Calculate business days between dates
def business_days_between(start_date, end_date):
 """Count business days between two dates (excluding weekends)."""
 days = 0
 current_date = start_date
 while current_date <= end_date:
 # Monday = 0, Sunday = 6
 if current_date.weekday() < 5: # Only count weekdays (0-4)
 days += 1
 current_date += timedelta(days=1)
 return days

# Calculate days until fiscal year end
today = datetime.now()
fiscal_year_end = datetime(today.year, 12, 31)
if today > fiscal_year_end:
 fiscal_year_end = datetime(today.year + 1, 12, 31)

business_days = business_days_between(today, fiscal_year_end)
print(f"Business days until fiscal year end: {business_days}")

OS and Sys Modules

import os
import sys

# Get the current working directory (useful for file paths)
current_dir = os.getcwd()
print(f"Current directory: {current_dir}")

# List all Excel files in the current directory
excel_files = [file for file in os.listdir() if file.endswith(('.xlsx', '.xls'))]
print("Excel files found:")
for file in excel_files:
 print(f"- {file}")

# Get Python version and platform information
print(f"Python version: {sys.version}")
print(f"Platform: {sys.platform}")

Reading from/Writing to Text Files

File operations are essential for financial data analysis, reporting, and automation.

Opening and Closing Files

The basic pattern is:

# Open a file in read mode
file = open('data.txt', 'r')
# Do something with the file
content = file.read()
# Close the file
file.close()

However, this approach has problems if an error occurs before close(). The preferred way is using the with statement:

The with Statement

# Automatically handles proper closing of the file
with open('data.txt', 'r') as file:
 content = file.read()
 # File processing here

# File is automatically closed when the block ends

Reading Text Files

Let’s work with a sample CSV file containing financial transactions:

# Sample contents of transactions.csv:
# date,description,amount
# 2025-01-15,Office supplies,-129.99
# 2025-01-18,Client payment,1500.00
# 2025-01-22,Software subscription,-49.99
# 2025-01-30,Consulting fees,2750.00

with open('transactions.csv', 'r') as file:
 # Read the entire file as a single string
 content = file.read()
 print("File contents:")
 print(content)

Reading line by line:

with open('transactions.csv', 'r') as file:
 # Skip header
 header = file.readline()
 
 # Initialise counters
 total_income = 0
 total_expenses = 0
 
 # Process each transaction
 for line in file:
 # Remove whitespace and split by comma
 date, description, amount = line.strip().split(',')
 
 # Convert amount to float
 amount = float(amount)
 
 if amount >= 0:
 total_income += amount
 else:
 total_expenses += amount
 
 print(f"Total income: ${total_income:.2f}")
 print(f"Total expenses: ${total_expenses:.2f}")
 print(f"Net cash flow: ${total_income + total_expenses:.2f}")

Writing to Text Files

Let’s create a simple financial report:

# Sample transaction data
transactions = [
 {"date": "2025-01-15", "description": "Office supplies", "amount": -129.99},
 {"date": "2025-01-18", "description": "Client payment", "amount": 1500.00},
 {"date": "2025-01-22", "description": "Software subscription", "amount": -49.99},
 {"date": "2025-01-30", "description": "Consulting fees", "amount": 2750.00}
]

# Calculate summary statistics
total_income = sum(t["amount"] for t in transactions if t["amount"] > 0)
total_expenses = sum(t["amount"] for t in transactions if t["amount"] < 0)
net_cash_flow = total_income + total_expenses

# Write the report to a file
with open('financial_report.txt', 'w') as report_file:
 report_file.write("MONTHLY FINANCIAL REPORT\n")
 report_file.write("======================\n\n")
 
 report_file.write("TRANSACTION DETAILS:\n")
 report_file.write("-----------------\n")
 
 for t in transactions:
 amount_str = f"${abs(t['amount']):.2f}"
 if t["amount"] < 0:
 amount_str = f"-{amount_str}"
 
 report_file.write(f"{t['date']} | {t['description'].ljust(20)} | {amount_str}\n")
 
 report_file.write("\nSUMMARY:\n")
 report_file.write("--------\n")
 report_file.write(f"Total Income: ${total_income:.2f}\n")
 report_file.write(f"Total Expenses: ${total_expenses:.2f}\n")
 report_file.write(f"Net Cash Flow: ${net_cash_flow:.2f}\n")

print("Financial report generated: financial_report.txt")

Handling Different File Modes

'r': Read (default)
'w': Write (creates new file or truncates existing)
'a': Append (adds to end of file)
'r+': Read and write
'b': Binary mode (used with other modes, e.g., 'rb')

Working with CSV Files

While you can process CSV files manually as shown above, Python’s csv module makes it easier:

import csv

# Reading CSV
with open('transactions.csv', 'r') as file:
 csv_reader = csv.DictReader(file)
 
 # Process each row as a dictionary
 transactions = []
 for row in csv_reader:
 # Convert amount from string to float
 row['amount'] = float(row['amount'])
 transactions.append(row)
 
 print(f"Loaded {len(transactions)} transactions")

# Writing CSV
with open('budget_forecast.csv', 'w', newline='') as file:
 # Define column headers
 fieldnames = ['month', 'revenue', 'expenses', 'profit']
 
 # Create CSV writer
 csv_writer = csv.DictWriter(file, fieldnames=fieldnames)
 
 # Write header row
 csv_writer.writeheader()
 
 # Write data rows
 for month in range(1, 13):
 # Simple forecast model (for demonstration)
 revenue = 15000 + (month * 500) # Increasing monthly
 expenses = 10000 + (month * 200) # Increasing but slower
 profit = revenue - expenses
 
 csv_writer.writerow({
 'month': f"2025-{month:02d}",
 'revenue': revenue,
 'expenses': expenses,
 'profit': profit
 })

print("Budget forecast generated: budget_forecast.csv")

Practical Example: Expense Analyser

Let’s combine everything we’ve learned into a practical financial tool that:

Reads expense data from a CSV file
Categorises and analyses expenses
Generates a report with summary statistics

import csv
from datetime import datetime
import os

def load_expenses(filename):
 """Load expense data from a CSV file."""
 expenses = []
 
 with open(filename, 'r') as file:
 reader = csv.DictReader(file)
 for row in reader:
 # Convert amount to float and date to datetime
 row['amount'] = float(row['amount'])
 row['date'] = datetime.strptime(row['date'], '%Y-%m-%d')
 expenses.append(row)
 
 return expenses

def categorize_expenses(expenses):
 """Group expenses by category."""
 categories = {}
 
 for expense in expenses:
 category = expense['category']
 
 if category not in categories:
 categories[category] = []
 
 categories[category].append(expense)
 
 return categories

def calculate_category_totals(categories):
 """Calculate total amount for each expense category."""
 totals = {}
 
 for category, expenses in categories.items():
 totals[category] = sum(expense['amount'] for expense in expenses)
 
 return totals

def generate_expense_report(expenses, categories, totals, output_file):
 """Generate a detailed expense report."""
 total_expenses = sum(totals.values())
 
 with open(output_file, 'w') as file:
 # Write header
 file.write("EXPENSE ANALYSIS REPORT\n")
 file.write("======================\n\n")
 
 # Write summary
 file.write(f"Total Expenses: ${total_expenses:.2f}\n")
 file.write(f"Number of Transactions: {len(expenses)}\n")
 file.write(f"Date Range: {min(e['date'] for e in expenses).strftime('%Y-%m-%d')} to {max(e['date'] for e in expenses).strftime('%Y-%m-%d')}\n\n")
 
 # Write category breakdown
 file.write("EXPENSE BREAKDOWN BY CATEGORY\n")
 file.write("----------------------------\n")
 
 # Sort categories by total amount (descending)
 sorted_categories = sorted(totals.items(), key=lambda x: x[1], reverse=True)
 
 for category, amount in sorted_categories:
 percentage = (amount / total_expenses) * 100
 file.write(f"{category.ljust(20)} ${amount:.2f} ({percentage:.1f}%)\n")
 
 # Write transaction details for each category
 file.write("\nDETAILED TRANSACTIONS BY CATEGORY\n")
 file.write("--------------------------------\n\n")
 
 for category, amount in sorted_categories:
 file.write(f"{category.upper()}\n")
 file.write(f"{'-' * len(category)}\n")
 
 # Sort expenses by date
 sorted_expenses = sorted(categories[category], key=lambda x: x['date'])
 
 for expense in sorted_expenses:
 date_str = expense['date'].strftime('%Y-%m-%d')
 file.write(f"{date_str} | {expense['description'].ljust(30)} | ${expense['amount']:.2f}\n")
 
 # Add category subtotal
 file.write(f"{'SUBTOTAL:'.ljust(41)} ${amount:.2f}\n\n")

# Usage example (assuming we have an expenses.csv file)
def main():
 # Check if the input file exists
 input_file = 'expenses.csv'
 if not os.path.exists(input_file):
 print(f"Error: File '{input_file}' not found.")
 print("Creating a sample expense file for demonstration...")
 
 # Create a sample file for demonstration
 with open(input_file, 'w', newline='') as file:
 writer = csv.writer(file)
 writer.writerow(['date', 'category', 'description', 'amount'])
 writer.writerow(['2025-01-05', 'Office', 'Printer paper', 24.99])
 writer.writerow(['2025-01-10', 'Software', 'Accounting software', 89.99])
 writer.writerow(['2025-01-15', 'Office', 'Desk organiser', 32.50])
 writer.writerow(['2025-01-18', 'Travel', 'Client meeting transportation', 45.75])
 writer.writerow(['2025-01-22', 'Software', 'Cloud storage subscription', 9.99])
 writer.writerow(['2025-01-25', 'Meals', 'Team lunch', 87.50])
 writer.writerow(['2025-01-29', 'Office', 'Printer ink', 65.85])
 writer.writerow(['2025-02-03', 'Travel', 'Conference registration', 299.00])
 writer.writerow(['2025-02-07', 'Meals', 'Client dinner', 125.40])
 writer.writerow(['2025-02-15', 'Software', 'Data analysis tool', 149.99])
 
 print(f"Sample file '{input_file}' created.")
 
 # Process the expense data
 expenses = load_expenses(input_file)
 categories = categorize_expenses(expenses)
 totals = calculate_category_totals(categories)
 
 # Generate the report
 output_file = 'expense_report.txt'
 generate_expense_report(expenses, categories, totals, output_file)
 
 print(f"Expense report generated: {output_file}")

if __name__ == "__main__":
 main()

This script demonstrates:

Function definitions with docstrings
File I/O with the with statement
CSV processing
Module imports and usage
Error handling

Conclusion

Functions, modules, and file I/O form the backbone of most Python applications, especially for financial tasks. By mastering these concepts, you’ll be well-equipped to build tools for financial analysis, reporting, and automation.

In the next post, we’ll explore virtual environments and package management, which will help you manage dependencies for larger projects.

Practice Exercise: Try extending the expense analyser to calculate monthly trends or generate a simple visualisation of spending by category. This will help reinforce the concepts we’ve covered while building something useful for your financial toolkit.

Core Data Structures in Python (Python for Finance, part 4)

michaelbrunger@gmail.com (Michael Brunger) — Tue, 20 May 2025 00:00:00 +0000

Welcome to the fourth post in my Python learning journey. So far, we’ve installed Python, set up a development environment, and explored the basic syntax. Now it’s time to dive deeper into Python’s core data structures; the building blocks you’ll use to organise and manipulate data in your programs.

In this post, we’ll cover:

Lists: Python’s versatile sequence type
Tuples: Immutable collections
Dictionaries: Key-value mapping
Sets: Unique value collections
Choosing the right data structure

I’ve found these data structures similar to concepts we use every day; lists are like columns in spreadsheets, dictionaries resemble lookup tables, and sets are perfect for tracking unique items like account codes.

1. Lists

Lists are ordered, mutable (changeable) collections that can contain items of different types. They’re perhaps the most commonly used data structure in Python.

1.1 Creating Lists

# Empty list
empty_list = []

# List with initial values
numbers = [1, 2, 3, 4, 5]
mixed_data = [42, "hello", True, 3.14]

# Creating a list with the list() constructor
chars = list("Python") # ['P', 'y', 't', 'h', 'o', 'n']

# List of repeated values
zeros = [0] * 5 # [0, 0, 0, 0, 0]

1.2 Accessing List Elements

expenses = [1200, 450, 700, 95, 800]

# Indexing (zero-based)
first_expense = expenses[0] # 1200
last_expense = expenses[-1] # 800

# Slicing [start:end:step] - end index is exclusive
first_three = expenses[0:3] # [1200, 450, 700]
# Shorthand for starting from beginning
first_three = expenses[:3] # [1200, 450, 700]
# Shorthand for going to the end
last_three = expenses[2:] # [700, 95, 800]
# Negative indices count from the end
last_two = expenses[-2:] # [95, 800]
# Step value
every_other = expenses[::2] # [1200, 700, 800]
# Reverse a list
reversed_expenses = expenses[::-1] # [800, 95, 700, 450, 1200]

1.3 Modifying Lists

departments = ["Finance", "Marketing", "IT", "Operations"]

# Changing an element
departments[1] = "Digital Marketing"

# Adding elements
departments.append("HR") # Adds to the end
departments.insert(2, "Sales") # Inserts at specific position

# Removing elements
departments.remove("IT") # Removes first occurrence of value
popped_item = departments.pop() # Removes and returns last item
popped_item = departments.pop(1) # Removes item at index 1
del departments[0] # Removes item at index 0

# Extending lists
dept1 = ["Finance", "HR"]
dept2 = ["IT", "Operations"]
dept1.extend(dept2) # dept1 now contains ["Finance", "HR", "IT", "Operations"]
# Alternative: concatenation
all_depts = dept1 + dept2 # Creates a new list

# Finding elements
position = departments.index("HR") # Raises ValueError if not found
count = departments.count("Finance") # Counts occurrences of value

1.4 Useful List Operations

numbers = [5, 2, 8, 1, 9]

# Sorting
numbers.sort() # Modifies the list in-place: [1, 2, 5, 8, 9]
numbers.sort(reverse=True) # Descending order: [9, 8, 5, 2, 1]

# If you don't want to modify the original list
sorted_numbers = sorted(numbers) # Returns a new sorted list

# Reversing
numbers.reverse() # Modifies the list in-place

# Finding min/max
minimum = min(numbers)
maximum = max(numbers)

# Sum of all elements
total = sum(numbers)

# Checking membership
if 5 in numbers:
 print("Found 5 in the list!")

# List comprehension (filtering and transforming)
even_numbers = [x for x in numbers if x % 2 == 0]
doubled = [x * 2 for x in numbers]

1.5 Nested Lists (2D Lists)

# Quarterly expenses by department
quarterly_expenses = [
 [1200, 1500, 1100, 1800], # Finance
 [900, 950, 1025, 1150], # Marketing
 [850, 880, 920, 980] # IT
]

# Accessing elements
finance_q1 = quarterly_expenses[0][0] # 1200
marketing_q3 = quarterly_expenses[1][2] # 1025

# Looping through a 2D list
for department in quarterly_expenses:
 for expense in department:
 print(expense, end=" ")
 print() # New line after each department

2. Tuples

Tuples are similar to lists but are immutable (cannot be changed after creation). They’re commonly used for fixed collections of items.

2.1 Creating Tuples

# Empty tuple
empty_tuple = ()

# Tuple with values
coordinates = (10, 20)
person = ("John", 30, "Developer")

# Single-item tuple needs a comma
single_item = (42,) # Without comma, it's just a number in parentheses

# Tuple packing (no parentheses needed)
employee = "Jane", 35, "Manager"

# Creating with tuple() constructor
letters = tuple("abc") # ('a', 'b', 'c')

2.2 Accessing Tuple Elements

coordinates = (10, 20, 30, 40, 50)

# Similar to list indexing and slicing
x = coordinates[0] # 10
last = coordinates[-1] # 50
subset = coordinates[1:4] # (20, 30, 40)

2.3 Tuple Operations

employee = ("Jane", 35, "Manager", "HR")

# Count and index (like lists)
age_pos = employee.index(35)
count = employee.count("Manager")

# Concatenation
more_info = employee + ("Full-time",)

# Unpacking (very useful feature!)
name, age, role, department = employee

# Returning multiple values from a function (using tuple unpacking)
def get_employee_stats():
 return "Jane", 35, 85000

name, age, salary = get_employee_stats()

2.4 Why Use Tuples?

Immutability - Values can’t be changed accidentally
Hashable - Can be used as dictionary keys (lists cannot)
Slightly more efficient than lists for fixed data
Signal intent - Using a tuple indicates the data shouldn’t change

# Using tuples as dictionary keys (not possible with lists)
locations = {
 (40.7128, -74.0060): "New York",
 (34.0522, -118.2437): "Los Angeles"
}

3. Dictionaries

Dictionaries store data as key-value pairs, providing fast lookups by key. They’re unordered in Python versions before 3.7 and preserve insertion order in 3.7+.

3.1 Creating Dictionaries

# Empty dictionary
empty_dict = {}

# Dictionary with initial key-value pairs
employee = {
 "name": "Jane Smith",
 "age": 35,
 "department": "Finance",
 "salary": 75000
}

# Alternative creation with dict() constructor
employee = dict(name="Jane Smith", age=35, department="Finance")

# Creating from sequences of pairs
items = [("name", "Jane"), ("age", 35)]
employee = dict(items)

3.2 Accessing Dictionary Values

employee = {
 "name": "Jane Smith",
 "age": 35,
 "department": "Finance",
 "salary": 75000
}

# Access by key
name = employee["name"] # "Jane Smith"

# KeyError if key doesn't exist
# salary = employee["bonus"] # Raises KeyError

# Using get() method (safer, returns None or default value if key not found)
bonus = employee.get("bonus") # None
bonus = employee.get("bonus", 0) # Returns 0 if key not found

3.3 Modifying Dictionaries

employee = {"name": "Jane", "department": "Finance"}

# Adding or updating values
employee["age"] = 35 # Add new key-value pair
employee["name"] = "Jane Smith" # Update existing value

# Removing items
removed_value = employee.pop("age") # Removes and returns value
del employee["department"] # Removes key-value pair

# Clearing all items
employee.clear() # Empty dictionary {}

3.4 Useful Dictionary Operations

expenses = {
 "rent": 1200,
 "utilities": 250,
 "groceries": 400,
 "entertainment": 150
}

# Get all keys
keys = expenses.keys() # dict_keys(['rent', 'utilities', 'groceries', 'entertainment'])

# Get all values
values = expenses.values() # dict_values([1200, 250, 400, 150])

# Get all key-value pairs as tuples
items = expenses.items() # dict_items([('rent', 1200), ('utilities', 250), ...])

# Iterating over a dictionary
for key in expenses:
 print(f"{key}: ${expenses[key]}")

# Better way to iterate over keys and values
for category, amount in expenses.items():
 print(f"{category}: ${amount}")

# Check if key exists
if "rent" in expenses:
 print("Rent is accounted for")

# Merging dictionaries (Python 3.9+)
monthly = {"rent": 1200, "utilities": 250}
occasional = {"repairs": 100, "insurance": 80}
all_expenses = monthly | occasional # Python 3.9+

# Merging dictionaries (earlier versions)
all_expenses = {**monthly, **occasional} # Unpacking syntax

# Dictionary comprehension
doubled_expenses = {k: v * 2 for k, v in expenses.items()}
large_expenses = {k: v for k, v in expenses.items() if v > 200}

3.5 Nested Dictionaries

# Department budget by quarter and category
department_budget = {
 "Finance": {
 "Q1": {"salaries": 50000, "equipment": 10000, "travel": 5000},
 "Q2": {"salaries": 52000, "equipment": 8000, "travel": 6000}
 },
 "IT": {
 "Q1": {"salaries": 60000, "equipment": 20000, "travel": 3000},
 "Q2": {"salaries": 65000, "equipment": 15000, "travel": 2000}
 }
}

# Accessing nested values
finance_q1_salaries = department_budget["Finance"]["Q1"]["salaries"]

# Safely accessing nested values
import pprint # Pretty print module for better display of nested structures

# Loop through nested dictionary
for dept, quarters in department_budget.items():
 print(f"\n{dept} Department:")
 for quarter, categories in quarters.items():
 print(f" {quarter}:")
 for category, amount in categories.items():
 print(f" {category}: ${amount}")

4. Sets

Sets are unordered collections of unique elements. They’re perfect for removing duplicates and performing mathematical set operations.

4.1 Creating Sets

# Empty set (can't use {} as that creates an empty dictionary)
empty_set = set()

# Set with initial values
fruits = {"apple", "banana", "cherry"}

# Creating a set from a list (removes duplicates)
numbers = set([1, 2, 2, 3, 4, 4, 5]) # {1, 2, 3, 4, 5}
unique_chars = set("mississippi") # {'m', 'i', 's', 'p'}

4.2 Set Operations

employees_dept_a = {"Jess", "Bob", "Charlie", "David"}
employees_dept_b = {"Charlie", "David", "Eve", "Frank"}
candidates = {"Eve", "Grace", "Heidi"}

# Add and remove elements
employees_dept_a.add("Grace")
employees_dept_a.remove("Bob") # Raises KeyError if not found
employees_dept_a.discard("Bob") # No error if not found

# Set operations
# Union (all employees)
all_employees = employees_dept_a | employees_dept_b
# or
all_employees = employees_dept_a.union(employees_dept_b)

# Intersection (employees in both departments)
in_both_depts = employees_dept_a & employees_dept_b
# or
in_both_depts = employees_dept_a.intersection(employees_dept_b)

# Difference (employees in A but not in B)
only_in_a = employees_dept_a - employees_dept_b
# or
only_in_a = employees_dept_a.difference(employees_dept_b)

# Symmetric difference (employees in either dept but not both)
in_one_dept = employees_dept_a ^ employees_dept_b
# or
in_one_dept = employees_dept_a.symmetric_difference(employees_dept_b)

# Subset and superset
is_subset = employees_dept_a <= employees_dept_b # False
is_proper_subset = candidates < all_employees # True (candidates is a proper subset of all_employees)

4.3 Common Set Uses

# Removing duplicates from a list
transactions = [1001, 1002, 1001, 1003, 1002, 1004]
unique_transactions = list(set(transactions))

# Membership testing (very efficient for large datasets)
if "Jess" in employees_dept_a:
 print("Jess works in Department A")

# Finding common elements
customer_ids = {101, 102, 103, 104, 105}
premium_ids = {102, 104, 106}
common_ids = customer_ids & premium_ids

# Set comprehensions
even_numbers = {x for x in range(10) if x % 2 == 0} # {0, 2, 4, 6, 8}

5. Choosing the Right Data Structure

Selecting the appropriate data structure can make your code more efficient and readable. Here’s a quick guide:

5.1 When to Use Each Structure

Use Lists when:

You need an ordered collection
Items might need to be changed, added, or removed
You need to store duplicate values
You need to maintain insertion order

Use Tuples when:

You have a fixed collection that shouldn’t change
You want to return multiple values from a function
You need elements that can serve as dictionary keys
You want to ensure data integrity (immutability)

Use Dictionaries when:

You need key-value mapping (lookups by key)
You want fast lookups by a specific identifier
You’re working with named attributes or properties
You need to count occurrences of items

Use Sets when:

You only care about unique values (no duplicates)
You need to perform set operations (union, intersection)
You want to quickly check if an item exists
You’re removing duplicates from a collection

5.2 Performance Considerations

Data structure choice affects performance. In general:

Lists: O(1) for append/pop at end, O(n) for insert/delete elsewhere
Dictionaries: O(1) average for key lookups, insertions, and deletions
Sets: O(1) average for membership testing, adding, removing

# Example: Different approaches to counting word frequencies

text = "to be or not to be that is the question"
words = text.split()

# Using a list (inefficient for counting)
def count_with_list(words):
 counts = []
 for word in words:
 found = False
 for item in counts:
 if item[0] == word:
 item[1] += 1
 found = True
 break
 if not found:
 counts.append([word, 1])
 return counts

# Using a dictionary (efficient)
def count_with_dict(words):
 counts = {}
 for word in words:
 if word in counts:
 counts[word] += 1
 else:
 counts[word] = 1
 return counts

# Even more concise with collections.Counter
from collections import Counter
def count_with_counter(words):
 return Counter(words)

# Compare results
print(count_with_list(words))
print(count_with_dict(words))
print(dict(count_with_counter(words)))

Practice Exercise: Financial Portfolio Tracker

Let’s apply these data structures by creating a simple portfolio tracker:

def portfolio_tracker():
 # Initialise portfolio using a dictionary of dictionaries
 portfolio = {}
 transactions = []
 
 while True:
 print("\nPortfolio Tracker")
 print("1. Add stock")
 print("2. Record transaction")
 print("3. View portfolio")
 print("4. View transaction history")
 print("5. Top holdings")
 print("6. Exit")
 
 choice = input("Enter your choice (1-6): ")
 
 if choice == "1":
 ticker = input("Enter stock ticker symbol: ").upper()
 company = input("Enter company name: ")
 sector = input("Enter sector: ")
 
 portfolio[ticker] = {
 "company": company,
 "sector": sector,
 "shares": 0,
 "cost_basis": 0,
 "current_price": float(input("Enter current price: $"))
 }
 print(f"Added {ticker} to portfolio.")
 
 elif choice == "2":
 ticker = input("Enter stock ticker symbol: ").upper()
 if ticker not in portfolio:
 print(f"Error: {ticker} not in portfolio. Add it first.")
 continue
 
 transaction_type = input("Buy or sell? ").lower()
 shares = int(input("Number of shares: "))
 price = float(input("Price per share: $"))
 date = input("Date (YYYY-MM-DD): ")
 
 # Record transaction
 transaction = (date, ticker, transaction_type, shares, price)
 transactions.append(transaction)
 
 # Update portfolio
 if transaction_type == "buy":
 # Calculate new cost basis
 current_shares = portfolio[ticker]["shares"]
 current_basis = portfolio[ticker]["cost_basis"]
 new_shares = current_shares + shares
 
 if new_shares > 0: # Avoid division by zero
 new_basis = (current_shares * current_basis + shares * price) / new_shares
 else:
 new_basis = 0
 
 portfolio[ticker]["shares"] += shares
 portfolio[ticker]["cost_basis"] = new_basis
 
 elif transaction_type == "sell":
 if portfolio[ticker]["shares"] < shares:
 print("Error: Not enough shares.")
 transactions.pop() # Remove the last transaction
 continue
 portfolio[ticker]["shares"] -= shares
 
 print(f"Transaction recorded. You now have {portfolio[ticker]['shares']} shares of {ticker}.")
 
 elif choice == "3":
 if not portfolio:
 print("Portfolio is empty.")
 continue
 
 print("\nCurrent Portfolio:")
 print(f"{'Ticker':<6} {'Company':<20} {'Sector':<15} {'Shares':<8} {'Cost Basis':<12} {'Current':<9} {'Value':<12} {'Gain/Loss':<10}")
 print("-" * 100)
 
 total_value = 0
 for ticker, data in portfolio.items():
 shares = data["shares"]
 if shares > 0: # Only show stocks we still own
 cost_basis = data["cost_basis"]
 current = data["current_price"]
 value = shares * current
 gain_loss = value - (shares * cost_basis)
 
 print(f"{ticker:<6} {data['company'][:20]:<20} {data['sector'][:15]:<15} {shares:<8} ${cost_basis:<10.2f} ${current:<7.2f} ${value:<10.2f} ${gain_loss:<8.2f}")
 total_value += value
 
 print("-" * 100)
 print(f"Total Portfolio Value: ${total_value:.2f}")
 
 elif choice == "4":
 if not transactions:
 print("No transactions recorded.")
 continue
 
 print("\nTransaction History:")
 print(f"{'Date':<12} {'Ticker':<6} {'Type':<6} {'Shares':<8} {'Price':<8} {'Total':<12}")
 print("-" * 55)
 
 for date, ticker, trans_type, shares, price in transactions:
 total = shares * price
 print(f"{date:<12} {ticker:<6} {trans_type:<6} {shares:<8} ${price:<6.2f} ${total:<10.2f}")
 
 elif choice == "5":
 if not portfolio:
 print("Portfolio is empty.")
 continue
 
 # Use a list to sort holdings by value
 holdings = []
 for ticker, data in portfolio.items():
 if data["shares"] > 0:
 value = data["shares"] * data["current_price"]
 holdings.append((ticker, data["company"], value))
 
 # Sort by value (descending)
 holdings.sort(key=lambda x: x[2], reverse=True)
 
 print("\nTop Holdings:")
 print(f"{'Rank':<5} {'Ticker':<6} {'Company':<20} {'Value':<12}")
 print("-" * 45)
 
 for i, (ticker, company, value) in enumerate(holdings[:5], 1):
 print(f"{i:<5} {ticker:<6} {company[:20]:<20} ${value:<10.2f}")
 
 elif choice == "6":
 print("Thank you for using Portfolio Tracker!")
 break
 
 else:
 print("Invalid choice. Please try again.")

# Run the application
if __name__ == "__main__":
 portfolio_tracker()

This example demonstrates:

Dictionaries for storing portfolio data
Lists for transaction history
Tuples for individual transactions
Sorting and filtering data
Calculating values based on stored data

What’s Next?

Now that we’ve covered Python’s core data structures, the next post will explore functions, modules, and file I/O—essential tools for organising your code and working with external data.

Stay tuned for Post 5: Functions, Modules & File I/O!

This post is part of my journey learning Python. I’m a chartered accountant exploring programming to enhance my analytical toolkit. If you have questions or spot any errors, please reach out.

Python Syntax Fundamentals & Language Features (Python for Finance, part 3)

michaelbrunger@gmail.com (Michael Brunger) — Fri, 09 May 2025 00:00:00 +0000

Welcome to the third post in my Python learning journey. In the first two posts, we installed Python and set up a proper development environment. Now it’s time to dive into the language itself. This post covers the fundamental building blocks of Python code that I’ve been learning.

We’ll explore:

Variables and basic data types
Operators and expressions
Control flow with conditionals and loops
List comprehensions and lambdas
Iterators and generators
Error handling with try/except

This post is a bit longer than the previous ones, but these fundamentals form the foundation of everything else in Python, so it’s worth taking the time to understand them.

1. Variables and Basic Data Types

Python is dynamically typed, meaning you don’t need to declare variable types explicitly. Coming from Excel formulas where everything just works, I found this quite intuitive.

1.1 Variables and Assignment

Variables in Python are created when you first assign a value to them:

# Creating variables
name = "Alex"
age = 35
hourly_rate = 45.50
is_python_fun = True

Variable names:

Can contain letters, numbers, and underscores
Cannot start with a number
Are case-sensitive (rate and Rate are different variables)
Should follow the snake_case convention (lowercase with underscores)

1.2 Basic Data Types

Python has several built-in data types:

Numbers

# Integers (whole numbers)
count = 10
negative_number = -5

# Floating-point (decimals)
pi = 3.14159
discount_rate = 0.15

# Complex numbers
complex_number = 3 + 4j # Not often used in business applications

Strings

# Text enclosed in quotes (single or double)
first_name = "John"
last_name = 'Doe'

# Multi-line strings use triple quotes
address = """123 Main Street
Anytown, CA 12345"""

# String concatenation
full_name = first_name + " " + last_name # "John Doe"

# f-strings (Python 3.6+) - my preferred way to format strings
greeting = f"Hello, {first_name}! You are {age} years old."

Booleans

# True or False values
is_active = True
has_paid = False

# Boolean operations
is_valid_customer = is_active and has_paid # False
can_contact = is_active or has_paid # True
is_not_active = not is_active # False

None Type

# Represents absence of value (similar to NULL in databases)
result = None

1.3 Type Conversion

Python can convert between types:

# String to number
age_str = "35"
age_num = int(age_str) # 35 as integer
price_float = float("45.50") # 45.5 as float

# Number to string
count_str = str(10) # "10" as string

# Check type of a variable
print(type(age_num)) # <class 'int'>

2. Operators and Expressions

Python supports various operators for calculations and comparisons.

2.1 Arithmetic Operators

a = 10
b = 3

addition = a + b # 13
subtraction = a - b # 7
multiplication = a * b # 30
division = a / b # 3.3333... (always returns float)
floor_division = a // b # 3 (integer division, rounds down)
modulus = a % b # 1 (remainder of division)
exponent = a ** b # 1000 (10 raised to power of 3)

2.2 Comparison Operators

a = 10
b = 3

equal = a == b # False
not_equal = a != b # True
greater_than = a > b # True
less_than = a < b # False
greater_or_equal = a >= b # True
less_or_equal = a <= b # False

2.3 Assignment Operators

# Simple assignment
x = 10

# Combined operators
x += 5 # Same as x = x + 5 (x becomes 15)
x -= 3 # Same as x = x - 3 (x becomes 12)
x *= 2 # Same as x = x * 2 (x becomes 24)
x /= 4 # Same as x = x / 4 (x becomes 6.0)

3. Control Flow

Control flow determines the order in which code executes based on conditions and loops.

3.1 Conditional Statements (if/elif/else)

Python uses indentation (whitespace) to define code blocks:

age = 25

if age < 18:
 print("Minor")
elif age < 65:
 print("Adult")
else:
 print("Senior")

Multiple conditions:

income = 75000
years_employed = 3

if income > 50000 and years_employed >= 2:
 print("Loan approved")
elif income > 30000 or years_employed >= 5:
 print("Further review needed")
else:
 print("Loan denied")

3.2 Loops

For Loops

For loops iterate over sequences (lists, strings, etc.):

# Loop through a list
expenses = [1200, 450, 700, 95]
total = 0
for expense in expenses:
 total += expense

print(f"Total expenses: ${total}") # Total expenses: $2445

# Loop with a range
for i in range(5): # 0, 1, 2, 3, 4
 print(i)

# Loop with index and value using enumerate
for index, value in enumerate(expenses):
 print(f"Expense {index+1}: ${value}")

While Loops

While loops execute as long as a condition is true:

count = 0
while count < 5:
 print(count)
 count += 1 # Don't forget this or you'll create an infinite loop!

# Break and continue
number = 0
while True: # Infinite loop
 number += 1
 if number == 3:
 continue # Skip the rest of this iteration
 if number == 6:
 break # Exit the loop entirely
 print(number) # Prints 1, 2, 4, 5

4. List Comprehensions and Lambdas

These are more advanced features that make Python code concise and expressive.

4.1 List Comprehensions

List comprehensions provide a compact way to create lists:

# Traditional way
numbers = [1, 2, 3, 4, 5]
squares = []
for n in numbers:
 squares.append(n * n)
print(squares) # [1, 4, 9, 16, 25]

# With list comprehension
squares = [n * n for n in numbers]
print(squares) # [1, 4, 9, 16, 25]

# With conditional filtering
even_squares = [n * n for n in numbers if n % 2 == 0]
print(even_squares) # [4, 16]

4.2 Dictionary and Set Comprehensions

Similar syntax works for dictionaries and sets:

# Dictionary comprehension
number_to_square = {n: n * n for n in numbers}
print(number_to_square) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Set comprehension (eliminates duplicates)
values = [1, 2, 2, 3, 4, 4, 5]
unique_values = {v for v in values}
print(unique_values) # {1, 2, 3, 4, 5}

4.3 Lambda Functions

Lambdas are small anonymous functions defined with the lambda keyword:

# Traditional function
def add(a, b):
 return a + b

# Equivalent lambda function
add_lambda = lambda a, b: a + b

print(add(2, 3)) # 5
print(add_lambda(2, 3)) # 5

Lambdas are often used with functions like map(), filter(), and sorted():

# Map applies a function to each item in an iterable
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x * x, numbers))
print(squared) # [1, 4, 9, 16, 25]

# Filter creates a list of elements for which a function returns True
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # [2, 4]

# Sorted with a custom key function
employees = [
 {"name": "Alice", "salary": 60000},
 {"name": "Bob", "salary": 50000},
 {"name": "Charlie", "salary": 75000}
]
sorted_by_salary = sorted(employees, key=lambda emp: emp["salary"])
print(sorted_by_salary) # Sorts employees by salary

5. Iterators and Generators

These features help process data efficiently, especially when working with large datasets.

5.1 Iterators

An iterator is an object that can be iterated (looped) over. Python’s for loops work with iterators:

# Lists, tuples, dictionaries, and sets are all iterable
numbers = [1, 2, 3]
for num in numbers: # numbers.__iter__() is called implicitly
 print(num)

You can create your own iterator:

# Manual iteration with iter() and next()
numbers = [1, 2, 3]
iterator = iter(numbers)

print(next(iterator)) # 1
print(next(iterator)) # 2
print(next(iterator)) # 3
# print(next(iterator)) # Would raise StopIteration exception

5.2 Generators

Generators are functions that return an iterator using the yield keyword:

def count_up_to(max):
 count = 1
 while count <= max:
 yield count
 count += 1

# Using the generator
counter = count_up_to(5)
print(next(counter)) # 1
print(next(counter)) # 2

# Or in a loop
for number in count_up_to(3):
 print(number) # Prints 1, 2, 3

Generators are memory-efficient because they generate values on-demand rather than storing the entire sequence in memory. This is especially useful for large datasets.

6. Error Handling with try/except

Python uses exceptions to handle errors gracefully:

# Basic try/except
try:
 result = 10 / 0 # Division by zero raises an exception
 print(result)
except ZeroDivisionError:
 print("Cannot divide by zero!")

# Handling multiple exception types
try:
 number = int(input("Enter a number: "))
 result = 100 / number
 print(result)
except ValueError:
 print("That's not a valid number!")
except ZeroDivisionError:
 print("Cannot divide by zero!")

# Try/except/else/finally
try:
 file = open("data.txt", "r")
 content = file.read()
except FileNotFoundError:
 print("File not found!")
else:
 # Runs if no exception occurred
 print(f"File content: {content}")
finally:
 # Always runs, regardless of exception
 if 'file' in locals() and not file.closed:
 file.close()
 print("File closed!")

Practice Exercise: Financial Calculator

Let’s apply what we’ve learned to build a simple financial calculator:

Create a program that:

Asks the user for their monthly income and expenses
Calculates their monthly savings
Projects savings over time with compound interest
Handles invalid inputs gracefully with try/except

Here’s a starter template:

def calculate_savings_projection(monthly_savings, annual_interest_rate, years):
 # Convert annual interest rate to monthly and decimal
 monthly_rate = annual_interest_rate / 100 / 12
 months = years * 12
 
 # Project savings
 total = 0
 for month in range(1, months + 1):
 total = total + monthly_savings # Add monthly contribution
 interest = total * monthly_rate # Calculate interest
 total = total + interest # Add interest to total
 
 # Print yearly totals
 if month % 12 == 0:
 print(f"Year {month // 12}: ${total:.2f}")
 
 return total

try:
 income = float(input("Enter your monthly income: $"))
 expenses = float(input("Enter your monthly expenses: $"))
 
 monthly_savings = income - expenses
 if monthly_savings <= 0:
 print("Your expenses exceed your income. No savings to project.")
 else:
 interest_rate = float(input("Enter annual interest rate (%): "))
 years = int(input("Enter number of years to project: "))
 
 print(f"\nMonthly savings: ${monthly_savings:.2f}")
 print(f"Projecting growth over {years} years at {interest_rate}% annual interest:")
 
 final_amount = calculate_savings_projection(monthly_savings, interest_rate, years)
 print(f"\nFinal savings after {years} years: ${final_amount:.2f}")
 
except ValueError:
 print("Please enter valid numbers only.")

What’s Next?

Now that we’ve covered the syntax fundamentals, the next post will dive into Python’s core data structures in more detail. We’ll explore lists, tuples, dictionaries, and sets—and when to use each one.

Stay tuned for Post 4: Core Data Structures!

*This post is part of my journey learning Python. I’m a chartered accountant exploring programming to enhance my analytical toolkit. If you have questions or spot any errors, please reach out

Text Editors vs. IDEs for Python Development (Python for Finance, part 2)

michaelbrunger@gmail.com (Michael Brunger) — Thu, 01 May 2025 00:00:00 +0000

Welcome to the second post in my Python learning series. Last time, we got Python installed and ran our first code. Now it’s time to set up a proper coding environment. Working directly with .py files in Notepad gets tedious quickly, so let’s explore better options for writing Python code.

In this post, we’ll cover:

The difference between text editors and IDEs
Popular options for Python development
Setting up VS Code for Python (my personal choice)
Key productivity features that will save you time
Running and debugging Python code from your editor

1. Text Editors vs. IDEs: What’s the Difference?

When I started learning Python, I was confused about whether to use a “text editor” or an “IDE”. Here’s the simple breakdown:

Text Editors:

Lightweight applications primarily designed for editing text
Minimal features out of the box, but often extensible with plugins
Faster startup times and lower system resource usage
Examples: Notepad++, Sublime Text, Atom

Integrated Development Environments (IDEs):

Comprehensive software packages with built-in tools for development
Include code completion, debugging, testing, and version control features
More resource-intensive but offer productivity benefits
Examples: PyCharm, Visual Studio, Eclipse

Modern text editors with plugins can blur the line between these categories. For instance, VS Code is technically a text editor but can function like an IDE with the right extensions.

2. Popular Options for Python Development

Here are some commonly used tools for Python programming:

Text Editors

Notepad++ (Windows only)

Free and lightweight
Basic syntax highlighting for Python
Minimal Python-specific features
Good for quick edits but limited for larger projects

Sublime Text

Cross-platform (Windows, macOS, Linux)
Fast and responsive with large files
Package manager for extensions
Free to evaluate, $99 licence for continued use

Atom

Open-source and free
Highly customisable
Good Git integration
Can be slower with large projects

IDEs

Visual Studio Code (VS Code)

Free, open-source, cross-platform
Extensive extension library
Lightweight but powerful
Strong Python support through extensions
My personal choice and what we’ll focus on in this post

PyCharm

Python-specific IDE by JetBrains
Community (free) and Professional (paid) editions
Comprehensive tools designed specifically for Python
Steeper learning curve but powerful features

Jupyter Notebooks

Interactive coding environment
Great for data analysis and visualisation
Documents that combine code, output, and markdown text
We’ll cover this in detail in a later post

After trying several options, I settled on VS Code for its balance of performance and features. It’s lightweight enough to run smoothly on my machine but offers robust Python support.

3. Setting Up VS Code for Python Development

If you’re following along with me, let’s set up VS Code:

3.1 Download and Install VS Code

Go to https://code.visualstudio.com/
Download the installer for your operating system
Run the installer with default options

3.2 Install Essential Python Extensions

Launch VS Code
Click the Extensions icon in the left sidebar (or press Ctrl+Shift+X)
Search for and install these extensions:
- Python by Microsoft (essential)
- Pylance for improved language support
- Python Indent for automatic indentation

3.3 Configure Python Interpreter

Open a Python file or create a new one (File > New File, then save with .py extension)
Click on “Select Python Interpreter” in the bottom status bar
Choose the Python installation you installed in Post 1

3.4 Set Up Code Formatting and Linting

These tools help maintain code quality and consistent style:

Install the autopep8 formatter:
- Open a terminal in VS Code (Terminal > New Terminal)
- Run: pip install autopep8

Configure formatter settings:

Press Ctrl+Shift+P to open the command palette
Type “Preferences: Open Settings (JSON)”
Add these settings:

"python.formatting.provider": "autopep8",
"editor.formatOnSave": true,
"python.linting.enabled": true,
"python.linting.pylintEnabled": true

Install Pylint for code quality checking:
- In the terminal, run: pip install pylint

4. Key Productivity Features

Here are some features that have saved me hours of time while learning Python:

4.1 Code Highlighting and IntelliSense

VS Code automatically highlights Python syntax and provides IntelliSense (code completion):

Start typing a Python keyword or function name
VS Code shows suggestions as you type
Press Tab to complete the suggestion

Try it by typing pri and watching it suggest print().

4.2 Code Snippets

Snippets let you insert commonly used code patterns quickly:

Type if and press Tab
VS Code inserts the if statement structure
Fill in the condition and press Tab to move to the body

Other useful snippets: for, def, class, try

4.3 File Explorer and Multiple Files

Having a file explorer helps manage projects with multiple files:

Use File > Open Folder to open your project directory
The left sidebar shows all files in that folder
Create new files or folders directly in VS Code

4.4 Integrated Terminal

No need to switch between VS Code and Command Prompt:

Press Ctrl+` (backtick) or use Terminal > New Terminal
Run Python code, install packages, or use Git commands

5. Running and Debugging Python Code

5.1 Running Python Files

Method 1: Using the Play Button

Open a Python file
Click the Play icon in the top-right corner

Method 2: Using the Terminal

Open the integrated terminal (Ctrl+`)
Run: python your_file.py

5.2 Introduction to Debugging

Debugging helps you find and fix errors in your code:

Set a breakpoint by clicking in the margin to the left of a line number (a red dot appears)
Press F5 or click the Debug icon in the sidebar, then “Start Debugging”
Your code runs until it hits the breakpoint, then pauses
Examine variables in the “Variables” panel
Use the debug toolbar to step through code line by line

5.3 Print-Driven Debugging vs. Using a Debugger

When I first started coding, I relied heavily on print() statements to understand what was happening in my code:

def calculate_total(items):
 print(f"Items received: {items}") # Debug print
 total = sum(items)
 print(f"Calculated total: {total}") # Debug print
 return total

While this works, using the debugger is more powerful:

You can inspect all variables without modifying code
You can pause execution and examine the program state
You don’t need to remove debug code when you’re done

Practice Exercise

Let’s put your new environment to use:

Create a new file called calculator.py in VS Code
Write a simple function that takes two numbers and an operation (add, subtract, multiply, divide) and returns the result
Add proper error handling (e.g., division by zero)
Use print statements to test your function with various inputs

Example solution (try it yourself first!):

def calculate(a, b, operation):
 if operation == "add":
 return a + b
 elif operation == "subtract":
 return a - b
 elif operation == "multiply":
 return a * b
 elif operation == "divide":
 if b == 0:
 return "Error: Division by zero"
 return a / b
 else:
 return "Error: Unknown operation"

# Test the function
print(calculate(10, 5, "add")) # Should print 15
print(calculate(10, 5, "subtract")) # Should print 5
print(calculate(10, 5, "multiply")) # Should print 50
print(calculate(10, 5, "divide")) # Should print 2.0
print(calculate(10, 0, "divide")) # Should print error message

Try using the debugger to step through this code and watch how the variables change.

What’s Next?

Now that we have our Python development environment set up, we’re ready to dive deeper into Python syntax and language features. In the next post, we’ll explore variables, data types, control flow, and more fundamental Python concepts.

Stay tuned for Post 3: Python Syntax Fundamentals & Language Features!

This post is part of my journey learning Python. I’m a chartered accountant exploring programming to enhance my analytical toolkit. If you have questions or spot any errors, please leave a comment below.

Getting Started with Python on Windows (Python for Finance, part 1)

michaelbrunger@gmail.com (Michael Brunger) — Mon, 28 Apr 2025 00:00:00 +0000

Welcome to the first post in my Python learning series. As I learn Python myself, I’ll be documenting my journey here. This first post covers the essentials to get you up and running with Python on Windows:

What Python is and why it’s worth learning
Installing Python on Windows (with step-by-step instructions)
Quick install notes for macOS & Linux users
Writing your first “Hello, World!” program
Using the Python interactive shell

1. What Is Python (and Why Learn It)?

Python is a high-level, interpreted programming language that’s gained enormous popularity for good reason. After looking into various languages, I chose to learn Python because:

Readability: Its clean syntax uses indentation and fewer symbols than languages like C++ or Java, making code easier to understand
Versatility: It’s used across multiple domains from web development (Django, Flask) to data analysis (NumPy, pandas) and automation
Package ecosystem: PyPI (Python Package Index) hosts over 400,000 third-party packages that extend Python’s capabilities
Community support: Extensive documentation, forums, and tutorials make finding help straightforward

For me as a finance professional, Python’s data analysis capabilities are particularly valuable, but its applications stretch across many fields.

2. Installing Python on Windows

Here’s how to get Python installed on Windows 10/11:

2.1 Download the Installer

Visit the official Python download page: https://www.python.org/downloads/windows
Click the button for the latest stable release (currently Python 3.11.x)

2.2 Run the Installer

Locate and double-click the downloaded file (typically named python-3.x.x-amd64.exe)
IMPORTANT: Check the box that says “Add Python 3.x to PATH” at the bottom of the installer
- This allows you to run Python from any directory in Command Prompt
Click “Install Now” for the standard installation, or “Customise installation” if you want to change specific options

2.3 Verify the Installation

Open Command Prompt (press Win + R, type cmd, and hit Enter)
Type the following command and press Enter:
```
python --version
```
You should see output like:
```
Python 3.11.4
```
(Your version number might differ)

3. Quick Notes for macOS & Linux

macOS:
- Many Macs come with Python 2.7 preinstalled, but you’ll want Python 3
- The simplest approach is using Homebrew:
```
brew install python
```
- Alternatively, download the installer from python.org
Linux:
- Most Linux distributions include Python
- For Ubuntu/Debian:
```
sudo apt update
sudo apt install python3 python3-pip
```

For complete instructions, see the official Python documentation:

macOS: https://docs.python.org/3/using/mac.html
Linux: https://docs.python.org/3/using/unix.html

4. Your First “Hello, World!” Script

Time to write your first Python program:

In Command Prompt, navigate to a folder where you want to create your script:
```
cd C:\Users\YourUsername\Documents
```
Create a new file named hello.py using any text editor (Notepad, VS Code, etc.)
Type this line in the file:
```
print("Hello, World!")
```
Save the file, then run it by typing in Command Prompt:
```
python hello.py
```
You should see:
```
Hello, World!
```

Congratulations—you’ve written and executed your first Python program!

5. Exploring the Python Interactive Shell

Python comes with an interactive shell (also called a REPL—Read-Evaluate-Print Loop) that lets you test code snippets immediately:

In Command Prompt, simply type:
```
python
```

You’ll see the Python prompt (>>>) where you can type code directly:

>>> 2 + 2
4
>>> name = "Python"
>>> print(f"I'm learning {name}!")
I'm learning Python!

Try some basic math:
```
>>> 5 * 7
35
>>> 10 / 2
5.0
```
To exit, type:
```
>>> exit()
```
Or press Ctrl+Z followed by Enter on Windows.

The interactive shell is excellent for quick experiments and calculations without creating a file.

Practice Exercise

Before moving on, try this quick exercise:

Create a new Python file named greeting.py
Write code that:
- Assigns your name to a variable
- Prints a greeting that includes your name
Run the script to see the output

Example solution (don’t peek until you’ve tried!):

name = "Alex"
print(f"Nice to meet you, {name}!")

What’s Next?

Now that you have Python installed and have run your first code, you’re ready to:

Explore text editors and IDEs that will make coding more efficient (coming in Post 2)
Learn Python syntax fundamentals to build more complex programs
Begin solving real problems with your new skills

Stay tuned for Post 2: Text Editors vs. IDEs for Python Development!

Python Learning Path: From Fundamentals to Intermediate Applications (Python for Finance, introduction)

michaelbrunger@gmail.com (Michael Brunger) — Sun, 27 Apr 2025 00:00:00 +0000

My Python Learning Journey

Welcome to my Python learning series! As a finance professional exploring programming, I’m documenting my entire journey through 17 posts that take you from absolute beginner to building practical applications.

What to Expect from This Series

This series is designed for fellow finance professionals and beginners who want to learn Python in a practical, step-by-step manner. Each post builds on previous concepts while introducing new skills.

Series Overview

Here’s what we’ll cover throughout the 17 posts:

Foundations (Posts 1–6)

1. Getting Started with Python on Windows

What is Python, why learn it, and where it’s used
Installing Python (step‑by‑step Windows installer with screenshots)
Quick pointers for macOS/Linux installs
Your first “Hello, World!” script
Exploring the interactive REPL (shell)

2. Text Editors vs. IDEs for Python Development

Lightweight editors (Notepad++, Sublime) vs. full IDEs (VS Code, PyCharm)
Setting up VS Code for Python (extensions, linting, auto‑format)
Code highlighting, IntelliSense/autocomplete, and snippets
Running and debugging code from your editor
Quick intro to IDE‑based breakpoints vs. print‑driven debugging

3. Python Syntax Fundamentals & Language Features

Variables, data types (numbers, strings, booleans) and operators
Indentation and control flow (if/elif/else, loops)
Comprehensions & lambdas: list/dict/set comprehensions, map/filter, anonymous functions
Iterators & generators: the iterator protocol, writing your own with yield
Basic error handling: try/except, else/finally

4. Core Data Structures

Lists: creation, indexing, slicing, methods
Tuples: immutability, packing/unpacking
Dictionaries: key–value access, common methods
Sets: uniqueness, union/intersection/difference
Choosing the right structure for the task

5. Functions, Modules & File I/O

Defining and calling functions (def, return, positional vs. keyword args)
Variable scope and namespaces
Organising code into modules and packages
Exploring the Standard Library (math, random, datetime, os, sys)
Reading from/writing to text files with open() and the with statement

6. Virtual Environments & Packaging

Why virtual environments matter (avoiding dependency conflicts)
Creating/activating/deactivating venv on Windows (and notes for macOS/Linux)
Managing packages with pip: install, freeze, requirements.txt
Basic packaging: project structure, setup.py/pyproject.toml essentials
Publishing to PyPI with twine and versioning best practices

Professional Best Practices (Posts 7–9)

7. Code Quality & Collaboration

Version control fundamentals with Git & GitHub (clone, commit, push, pull requests)
Writing clean, PEP 8‑compliant code; linting with flake8
Auto‑formatting with black and organising imports with isort
Writing docstrings (Google vs. NumPy style) and auto‑generating docs (Sphinx overview)

8. Testing & Debugging

Unit testing basics with unittest and pytest (assertions, test discovery)
Fixtures in pytest and intro to TDD workflows
Raising and defining custom exceptions (raise, subclassing Exception)
Using the debugger: pdb commands and IDE‑based breakpoints
Structured logging with the logging module (levels, handlers, formatting)

9. Command‑Line Tools & Automation

Building CLI scripts with argparse: positional args, flags, help text
Packaging entry points (console_scripts) for installable commands
Automating file/folder tasks (os, shutil): renaming, organising, backups
Automating GUI interactions with PyAutoGUI (keyboard/mouse control)
Putting it all together in a sample automation project

Core Tools & Data (Posts 10–13)

10. The Python Ecosystem & Interactive Data Workflows

Clarify package vs. environment managers: pip vs. conda vs. Anaconda
When and why to choose each (lightweight vs. data‑science bundles)
Installing and exploring Anaconda Navigator
Jupyter Notebooks: installing via pip/Anaconda, notebook anatomy (code vs. Markdown), basic plots inline

11. NumPy Fundamentals for Numerical Data

Installing NumPy
The ndarray: creation, indexing, slicing
Vectorised operations and broadcasting rules
Performance comparison vs. pure Python lists

12. Data Analysis with pandas

Installing pandas
Understanding Series and DataFrame objects
Reading data (CSV, Excel), inspecting and summarising
Selection, filtering, grouping, transformation
Handling missing data

13. Data Visualisation Basics

Matplotlib core: line, scatter, bar, histogram plots
Customising labels, titles, legends
Seaborn intro: statistical plot types (boxplot, heatmap)
Saving figures to files for reports

Intermediate Applications (Posts 14–17)

14. Introduction to Object‑Oriented Programming (OOP)

Classes vs. objects, attributes vs. methods
The init constructor and self
Encapsulation, inheritance and polymorphism (simple examples)
Why OOP matters: organising and reusing code

15. Web Development Foundations

Option A: Flask (lightweight): setting up, routes, templates, serving static files
Option B: Django (full‑featured): project/app structure, admin interface, ORM intro
Option C: Web Scraping: requests + BeautifulSoup for HTML parsing
Deploying your first minimal web app on a free hosting platform (e.g., Heroku)

16. Building Simple GUI Applications with Tkinter

Installing/importing Tkinter (built‑in)
Creating windows, labels, buttons, entry widgets
Layout managers (pack, grid)
A hands‑on mini‑project: e.g., basic calculator or temperature converter

17. Next Steps & Advanced Topics

Concurrency & async: when to use threads vs. processes (threading, multiprocessing), intro to asyncio
End‑to‑end mini‑project ideas (combine web, data, GUI, testing)
Recommended books, courses, blogs, and community resources
Tips for staying sharp: code challenges, open‑source contribution, local meetups

Python for Finance on Michael Brunger

Next Steps & Advanced Python Topics (Python for Finance, part 17)

Concurrency & Asynchronous Programming

Threading vs. Multiprocessing

Threading (threading module)

Multiprocessing (multiprocessing module)

Asynchronous Programming with asyncio

End-to-End Financial Mini Projects

1. Personal Finance Dashboard

2. Stock Portfolio Analyser

3. Financial Statement Analyser

Learning Resources

Books

Online Courses

Blogs and Websites

GitHub Repositories to Follow

Community Engagement

Advanced Topics to Explore Next

1. Machine Learning for Finance

2. Cloud Deployment

3. Big Data Processing

4. Natural Language Processing for Finance

Conclusion

Building Simple GUI Applications with Tkinter (Python for Finance, part 16)

What is Tkinter?

Setting Up Your First Tkinter Application

Core Tkinter Widgets

Layout Management

1. Pack

2. Grid

3. Place

Adding Functionality with Event Handlers

Styling and Polish

Packaging Your Application

Building a Simple Expense Tracker

Advanced Tkinter Topics

1. Custom Styling with Themes

2. Canvas Widget for Custom Graphics

3. Multithreading for Long-Running Tasks

4. Creating a Portfolio Tracker with Multiple Windows

5. Best Practices for Tkinter Applications

Web Development Foundations with Python (Python for Finance, part 15)

Option A: Flask - Building a Lightweight Financial Dashboard

Setting Up Flask

Creating Templates

Adding CSS Styles

Running the Flask Application

Project Structure

Option B: Django - Building a Full-Featured Financial Application

Installing Django

Creating a New Django Project

Defining Models

Registering the App

Creating Migrations and Admin Interface

Creating Views

Setting Up URLs

Creating Templates

Adding Static Files

Running the Django Application

Option C: Web Scraping - Extracting Financial Data

Installing Required Libraries

Creating a Stock Price Scraper

Running the Web Scraper

Deploying Your Web Application

Deploying to Render (Free Alternative to Heroku)

For Flask Applications:

For Django Applications:

Conclusion

Introduction to Object-Oriented Programming (OOP) in Python (Python for Finance, part 14)

What is Object-Oriented Programming?

Key Concepts in OOP

1. Classes vs. Objects

2. The __init__ Method and self

3. Methods: Adding Behaviour to Our Objects

The Four Pillars of OOP

1. Encapsulation

2. Inheritance

3. Polymorphism

4. Abstraction

Practical Financial Application: Portfolio Management

Threading (`threading` module)

Multiprocessing (`multiprocessing` module)

Asynchronous Programming with `asyncio`

2. The `init` Method and `self`