Python Basics

The Building Blocks of Python

Python is a programming language known for its clear, readable syntax. It’s often compared to writing in plain English, which makes it an excellent choice for beginners and a powerful tool for experts. In algorithmic trading, speed of development is key, and Python’s simplicity helps you turn strategies into code quickly.

Let's start with the most basic concept: variables. A variable is just a name you give to a piece of data so you can refer to it later. Think of it as a labeled box where you store information.

Python has several fundamental data types:

Integers: Whole numbers, like 10, -5, or 1000.
Floats: Numbers with a decimal point, like 99.95 or 3.14. Stock prices are a perfect example.
Strings: Text, enclosed in single ' ' or double " " quotes. For example, 'AAPL' or "Buy signal".
Booleans: Represent truth values. There are only two: True and False. They are crucial for making decisions in your code.

# Variable assignments
stock_symbol = "GOOG"  # A string
price = 2841.23       # A float
shares_owned = 15     # An integer
is_profitable = True  # A boolean

# You can print them to see their values
print(stock_symbol)
print(price)

Storing Collections of Data

Often, you need to work with groups of data, not just single values. Python provides powerful data structures for this. The two most common are lists and dictionaries.

A list is an ordered collection of items. You can store anything in a list, and the items will always stay in the same order. Think of it as a to-do list for your trading day.

A dictionary is an unordered collection of key-value pairs. Instead of accessing items by their position, you access them using a unique key. This is like a real dictionary, where you look up a word (the key) to find its definition (the value). In trading, you might use a dictionary to store information about a particular stock.

# A list of tech stocks
watchlist = ["AAPL", "MSFT", "AMZN", "TSLA"]

# Accessing an item by its index (starts at 0)
first_stock = watchlist[0]  # This is "AAPL"
print(first_stock)

# A dictionary for a single stock's data
stock_data = {
    "ticker": "AAPL",
    "price": 172.26,
    "sector": "Technology"
}

# Accessing a value by its key
current_price = stock_data["price"]
print(current_price)

Controlling the Flow

Your trading algorithm needs to make decisions. Should it buy? Should it sell? This is handled with control flow statements. The most common is the if statement, which runs a block of code only if a certain condition is true.

You can chain conditions together using elif (else if) and else to handle various scenarios. For example: if the price is below your target, buy. Else if the price is above your target, sell. Else, do nothing.

price = 150
buy_target = 145
sell_target = 155

if price < buy_target:
    print("Execute Buy Order")
elif price > sell_target:
    print("Execute Sell Order")
else:
    print("Hold Position")

Repeating actions is another core part of programming. A for loop is used to iterate over a sequence, like a list. You could use a for loop to check the price of every stock in your watchlist.

A while loop runs as long as a certain condition remains true. For instance, a trading bot might run in a while loop that continues as long as the market is open.

# A for loop to iterate through a list
watchlist = ["AAPL", "MSFT", "AMZN"]
for stock in watchlist:
    print("Checking price for:", stock)

# A simple while loop example
alerts_sent = 0
while alerts_sent < 3:
    print("Sending price alert...")
    alerts_sent = alerts_sent + 1

Functions and Modules

As your programs get more complex, you'll want to organize your code into reusable blocks. This is done with functions. A function is a named piece of code that performs a specific task. You can give it data (called parameters) and it can return a result.

For example, you could write a function that calculates the potential profit for a trade. This keeps your main code clean and makes it easy to perform the same calculation multiple times.

def calculate_profit(buy_price, sell_price, shares):
    profit = (sell_price - buy_price) * shares
    return profit

# Call the function with some data
trade_profit = calculate_profit(150.50, 155.75, 100)
print("The profit for this trade is: 💲", trade_profit)

Python also has a concept of modules. A module is simply a file containing Python code. You can bring the code from one module into another using the import statement. This allows you to tap into a vast ecosystem of pre-written code, saving you from reinventing the wheel.

Handling the Unexpected

Code doesn't always run perfectly. You might try to connect to a data feed that's down, or perform a calculation that's impossible, like dividing by zero. These events cause errors, or exceptions.

A robust program doesn't crash when an error occurs. Instead, it handles it gracefully. In Python, you can prepare for potential errors using a try...except block. You put the risky code in the try block, and the code to run if an error occurs in the except block.

data = {"price": 100, "volume": 0}

try:
    # This might cause a ZeroDivisionError
    price_per_volume = data["price"] / data["volume"]
    print(price_per_volume)
except ZeroDivisionError:
    print("Cannot calculate: volume is zero.")

print("Program continues...")

This is vital for trading bots, which need to stay running even when they encounter unexpected data or network issues. Now, let's test your understanding of these core concepts.

Quiz Questions 1/6

In algorithmic trading, a stock's price, like 150.75, would be best represented by which Python data type?

Quiz Questions 2/6

You want to store data for a single stock: its ticker ('AAPL'), current price (175.50), and 52-week high (198.23). Which Python data structure is most suitable for storing this related information using descriptive labels?

With these building blocks—variables, data structures, control flow, functions, and error handling—you have the foundation needed to start writing simple trading logic in Python.

Python Algorithmic Trading Strategies