What even is Python?

Let's start from absolute zero.

Your computer is a machine that only understands one language: electricity. On or off. 1 or 0. That is it. Everything your computer does — playing music, showing a webpage, running Excel — is just billions of tiny switches flipping on and off, millions of times per second.

Obviously, no human wants to write instructions in 1s and 0s. So over the decades, people invented programming languages — ways to write instructions in something closer to English, which then get translated into those 1s and 0s automatically.

Python is one of those languages. And it happens to be the one the entire finance, data science, and machine learning world converged on over the last 15 years.

Analogy

Think of your computer as a very obedient but very literal employee. They will do exactly what you tell them — no more, no less. If you say 'print the report' they print it. If you say 'print the report 500 times' they do that too, without complaining. Python is the language you use to give that employee their instructions.

Why Python specifically? Three reasons:

It reads like English. Python code is closer to reading a sentence than most other languages. This makes it faster to learn and easier to debug.
It has an enormous library ecosystem. Someone has already written Python tools for almost everything — downloading stock prices, building neural networks, solving optimisation problems. You import their work and use it.
The entire quant finance industry uses it. Goldman Sachs, BlackRock, Citadel, Two Sigma, AQR — all run on Python. If you want to work in quant finance, Python is not optional.

Setting up Python

The best way to install Python for finance or data science work is Anaconda. It is not just Python — it is Python plus 250 pre-installed libraries that quants use every day, all in one installer.

Go to anaconda.com/download
Download Anaconda Individual Edition for your operating system
Run the installer with all default settings
Open Anaconda Navigator
Click Launch under Jupyter Notebook
In the browser that opens, navigate to a folder and click New → Python 3

What is a Jupyter Notebook? A document where you write code in cells, run each cell one at a time, and see output directly below it. Perfect for learning and financial analysis. Every quant analyst uses Jupyter for exploratory work.

Your very first Python program

Click on the first empty cell in your Jupyter Notebook, type this, and press Shift + Enter:

python

print("Hello, quant finance world!")

You should see:

text

Hello, quant finance world!

That is it. You just ran your first Python program. The print() function takes whatever you put inside the parentheses and displays it on screen.

python

print("I am learning Python for quant finance.")
print("My MBA is from IIM Trichy.")
print("Soon I will be pricing derivatives.")

Python reads your code from top to bottom, one line at a time, in order. This is the most important mental model: your code is a list of instructions executed in sequence.

Variables: giving names to things

Imagine you are analyzing Apple stock with a price of 182.50. You could type 182.50 every time you need it. But that is tedious, error-prone, and if the price changes you have to find and update every occurrence. Instead, use a variable — a named container that holds a value.

python

stock_price = 182.50

Read this as: create a container called stock_price and put 182.50 inside it. Now whenever you type stock_price, Python uses 182.50.

python

stock_price = 182.50
number_of_shares = 100
portfolio_value = stock_price * number_of_shares

print(portfolio_value)

text

18250.0

Analogy

A variable is like a labeled box. You write a name on the outside, put a value inside, and refer to it by label whenever you need it. You can also replace what is inside at any time — the label stays the same but the contents change.

Rules for naming variables

Names can contain letters, numbers, and underscores
Names cannot start with a number
Names cannot contain spaces — use underscores instead
Names are case-sensitive: Price and price are two different variables
You cannot use Python reserved words like for, if, print, return

python

# Good variable names
stock_price = 182.50
annual_return = 0.12
company_name = "Apple"
is_profitable = True

# Lines starting with # are comments -- Python ignores them
# They are notes for humans reading your code. Use them generously.

Data types: what kind of thing is in the box?

Not all values are the same kind of thing. Python tracks what kind of value each variable holds, because different types support different operations.

Integers: whole numbers

python

number_of_shares = 100
trading_days_per_year = 252

print(type(number_of_shares))

text

<class 'int'>

Integers are whole numbers with no decimal point. In finance: number of shares, number of trading days, position sizes in whole units.

Floats: numbers with decimals

python

stock_price = 182.50
daily_return = 0.0072
annual_volatility = 0.2341

print(type(stock_price))

text

<class 'float'>

Almost everything in finance is a float — prices, returns, volatilities, betas, Sharpe ratios.

Warning about floats: Computers cannot represent every decimal exactly. Type 0.1 + 0.2 in Python and you get 0.30000000000000004. This is not a bug — it is a fundamental limitation of binary arithmetic. For financial calculations this tiny error is never a practical problem, but you should know it exists.

Strings: text

python

company_name = "Apple Inc"
ticker_symbol = "AAPL"
sector = 'Technology'    # single quotes work too

print(type(company_name))

text

<class 'str'>

Strings hold text. Wrap them in single or double quotes — Python treats them identically. In finance: ticker symbols, company names, sector labels, news headlines.

python

ticker = "AAPL"
price = 182.50

# f-strings: the cleanest way to mix text and numbers
message = f"The price of {ticker} is ${price:.2f}"
print(message)

print(ticker.lower())       # aapl
print("apple".upper())      # APPLE
print(len("Apple"))         # 5

text

The price of AAPL is $182.50
aapl
APPLE
5

f-strings explained: Put an f before the opening quote. Then put variable names inside curly braces. The :.2f means 'format as a float with 2 decimal places.' You will use f-strings in almost every script you ever write.

Booleans: True or False

python

is_profitable = True
is_bankrupt = False

print(type(is_profitable))

text

<class 'bool'>

Booleans can only be True or False — note the capital letters. In finance: is the market open, is the position long or short, did the backtest pass its risk checks.

Arithmetic

python

price = 150.0
shares = 200

# Basic operations
portfolio_value = price * shares
print(f"Portfolio value: {portfolio_value}")

# Daily return formula
price_today = 152.30
price_yesterday = 150.00
daily_return = (price_today - price_yesterday) / price_yesterday
print(f"Daily return: {daily_return:.4f}")
print(f"Daily return: {daily_return:.2%}")

# Compounding: 8% per year for 10 years
initial = 100_000     # underscores make big numbers readable
final = initial * (1 + 0.08) ** 10
print(f"Final value: ${final:,.2f}")

text

Portfolio value: 30000.0
Daily return: 0.0153
Daily return: 1.53%
Final value: $215,892.50

Key points: ** means 'to the power of'. :.2% multiplies by 100 and adds a percent sign. :,.2f adds comma separators to large numbers. Underscores in numbers like 100_000 are ignored by Python but make the code more readable.

Making decisions: if statements

Real programs need to make decisions. If the stock has dropped more than 5%, send an alert. If the Sharpe ratio is above 1.0, include this strategy. Python handles decisions with if statements.

python

daily_return = -0.032    # down 3.2%

if daily_return < -0.05:
    print("Alert: stock dropped more than 5%")
elif daily_return < 0:
    print("Stock is down but within normal range")
elif daily_return == 0:
    print("No change today")
else:
    print("Stock is up today")

text

Stock is down but within normal range

Indentation is not optional. The code inside an if block must be pushed to the right by 4 spaces. Python uses indentation to know what belongs inside the block. Press Tab in Jupyter and it inserts 4 spaces automatically.

python

# Comparison operators
price = 150.0
target = 160.0

print(price < target)    # True
print(price > target)    # False
print(price == target)   # False  (two equals signs = comparison)
print(price != target)   # True
print(price <= 150.0)    # True

Common mistake: Using one equals sign (=) when you mean two (==). One equals assigns a value. Two equals checks whether two things are equal. This error will trip you up at least once — everyone makes it.

python

sharpe = 1.4
max_drawdown = -0.08

# Both conditions must be true
if sharpe > 1.0 and max_drawdown > -0.10:
    print("Strategy passes risk filters")

# At least one condition must be true
volatility = 0.35
beta = 1.8
if volatility > 0.30 or beta > 1.5:
    print("High risk warning")

Lists: storing many values

In finance you rarely work with one number at a time. You work with a year's worth of daily prices, a portfolio of 50 stocks, 200 ticker symbols. A list stores many values in one variable.

python

prices = [182.50, 184.20, 181.30, 185.60, 183.90]

print(prices)
print(type(prices))
print(len(prices))    # number of items

text

[182.50, 184.20, 181.30, 185.60, 183.90]
<class 'list'>
5

Accessing items

Python counts from zero, not one. The first item is at index 0.

python

prices = [182.50, 184.20, 181.30, 185.60, 183.90]
#  index:    0       1       2       3       4

print(prices[0])    # 182.50 -- FIRST item is index 0
print(prices[1])    # 184.20
print(prices[-1])   # 183.90 -- negative counts from the end
print(prices[0:3])  # [182.50, 184.20, 181.30] -- slice

Why count from zero?

Imagine standing at the start of a street. Your house is 0 steps away from where you stand. The index tells you how many steps from the beginning. The first item is 0 steps from the start. This convention comes from early computing and is now standard in almost every major language.

python

portfolio = ["AAPL", "GOOGL", "MSFT"]

portfolio.append("AMZN")      # add to end
portfolio.remove("GOOGL")     # remove by value
portfolio[0] = "NVDA"         # replace item

print(portfolio)
print("MSFT" in portfolio)    # True
print("GOOGL" in portfolio)   # False

Dictionaries: data with labels

Lists access data by position number. Dictionaries access data by a meaningful name — perfect for looking up a stock's price by its ticker symbol.

python

stock_prices = {
    "AAPL": 182.50,
    "GOOGL": 141.80,
    "MSFT": 378.90,
    "NVDA": 621.44
}

print(stock_prices["AAPL"])     # 182.50

stock_prices["TSLA"] = 245.60   # add new entry
stock_prices["AAPL"] = 185.00   # update existing entry

print("MSFT" in stock_prices)   # True
print("META" in stock_prices)   # False

Dictionaries are everywhere in finance code. Ticker to price, strategy name to parameters, date to portfolio value. Get comfortable with them early.

Loops: doing things many times

A loop runs the same block of code many times — once for each item in a collection. This is how you process 500 stocks without writing 500 lines of code.

python

prices = [182.50, 184.20, 181.30, 185.60, 183.90]
returns = []

for i in range(1, len(prices)):
    daily_return = (prices[i] - prices[i-1]) / prices[i-1]
    returns.append(daily_return)

for r in returns:
    print(f"  {r:.4f}  ({r:.2%})")

text

  0.0093  (0.93%)
 -0.0157  (-1.57%)
  0.0237  (2.37%)
 -0.0091  (-0.91%)

python

# while loop: keep running as long as condition is true
capital = 100_000
target = 200_000
years = 0

while capital < target:
    capital = capital * 1.08
    years += 1

print(f"Doubles in {years} years at 8% annual return")

text

Doubles in 10 years at 8% annual return

Functions: reusable blocks of logic

Write logic once, call it as many times as you need. In finance you write functions for Sharpe ratios, drawdowns, backtests, and dozens of other repeated calculations.

python

def calculate_sharpe(returns, risk_free_rate=0.05):
    daily_rf = risk_free_rate / 252
    excess = [r - daily_rf for r in returns]
    n = len(excess)
    mean = sum(excess) / n
    variance = sum((r - mean)**2 for r in excess) / (n - 1)
    std_dev = variance ** 0.5
    sharpe = (mean / std_dev) * (252 ** 0.5)
    return sharpe

daily_returns = [0.009, -0.016, 0.024, -0.009, 0.011, 0.003]
result = calculate_sharpe(daily_returns)
print(f"Sharpe Ratio: {result:.2f}")

The def keyword defines a function. The name follows. Inputs go in parentheses. risk_free_rate=0.05 means 0.05 is the default if you do not provide it. The indented block is the body. return sends the result back.

Reading error messages

You will get errors. All the time. Even after years of coding. Learn to read them instead of panicking.

python

prices = [182.50, 184.20, 181.30]
print(prices[5])    # index 5 does not exist

text

IndexError: list index out of range

Always read two things: the error type (IndexError, TypeError, NameError...) and the message after the colon. Together they tell you exactly what went wrong and where.

When stuck: Copy the exact error message and search it online. Stack Overflow has the answer to almost every Python error you will ever encounter. This is not cheating — it is how professional developers work every single day.

Summary

You now understand the complete foundation of Python: what it is and why finance uses it, how to install it, variables and all four basic data types, arithmetic for financial calculations, if statements for decisions, lists and dictionaries for storing data, loops for automation, and functions for reusable logic. The Theory tab goes deeper into how Python actually works under the hood. The Python tab builds a complete financial analysis tool with real market data.

From Zero to Quant.One topic at a time.

From Zero to Quant.
One topic at a time.