Quant Trading Accelerator - Part 1: Variables

Main ideas / lessons

Purpose of the course (“Quant Trading Accelerator”)

• It’s an “accelerator” because the course is designed to help learners progress from zero extremely fast.
• Core learning principle: learn by building (similar to learning guitar by playing).
• Only major prerequisite: intellectual curiosity (no required math/programming background).

What “quant trading” means (high-level pipeline)

Quant trading is model-based:

1. A model takes inputs.
2. It produces a prediction/forecast of the future.
3. A strategy converts the prediction into orders.
4. Orders are executed on a broker platform / exchange.

Course objectives (4 key goals)

• Develop research skills to build and quantify trading ideas.
• Build and backtest custom models and strategies.
• Combine everything and code/automate the full workflow.

What the course will build (libraries / components)

• Build a data analysis library first (even though tools like pandas exist) to understand what they do under the hood, improving programming and math intuition.
• Use that to support a research library for testing ideas and creating models.
• Build understanding of machine learning and econometrics to create and backtest ML models.
• Then build a strategy based on the model.

Skills emphasized

• Programming + mathematics (foundation for early projects).
• Econometrics + machine learning (learn these to become “dangerous”).

Course logistics / how to learn effectively

• Use Google Colab (no local installation needed).
• Videos are short (~20 minutes) and learning is incremental and “just in time.”
• Do not skip videos, because later parts build on earlier ones.
• Do the exercises—otherwise you aren’t actually building/learning.
• Using ChatGPT is okay for debugging, but not for generating full solutions.
• Comment / ask questions in the video’s comments when something is unclear so the creator can improve future content.

---

Lesson focus: Part 1 — Variables (and core Python basics)

Notebook execution concept

• Code can be run via:
  • Clicking the run button
  • Or using Shift+Enter
• When run, any output displayed appears below the cell.

Variables

• To create a variable:
  • Assign a value with a meaningful name, e.g. price = 10
• To print a variable’s value:
  • Use print functionality (demonstrated conceptually).
• Updating a variable:
  • Example idea: price = price + 0.5 (price increases by 50 cents)

Memory referencing / mutation vs reassignment (important concept)

• Key teaching point: when you update a number variable (like price), it creates a new memory allocation.
• Example outcome:
  • If you compute new_price from price, then later update price, the previously created new_price does not automatically change.
• Reasoning given:
  • Numbers are reassigned to a new location rather than “linked” by reference.
  • Later (in array-related videos), reference behavior becomes clearer/different.

---

Fundamental data types covered

Numbers

• float
  • Real-valued numbers (including decimals).
  • Example: a price can be a float.
• integer
  • Whole numbers only.
  • Example: “number of trades” is treated as an integer.

Conversions between numeric types

• int → float
  • Converts whole numbers into float form (e.g., becomes 100.0).
• float → int
  • Decimal places are lost; must be careful.
• string → numeric
  • Data from CSV/API may arrive as a string, and you may need to convert to float.

Arithmetic and operator precedence

• Arithmetic uses operators like + and *.
• Precedence rule:
  • Multiplication happens before addition (not strictly left-to-right).
• Parentheses can override precedence:
  • Use parentheses to force evaluation order.

Arithmetic with variables and percentages

• Demonstrated conceptual patterns:
  • Increase by 5% of current price: price * 1.05-type idea
  • Decrease by 10% of current price: price * 0.90-type idea

---

Strings (and why they matter for trading data)

Identifiers / symbols as strings

• A symbol is a unique identifier for a trading instrument (e.g., “Google” as an example).
• The type of symbol is a string.

String concatenation

• Combining strings is done via concatenation.
• Example concept: create a label like "Google price ...".

Type mismatch: string + float error

• Attempting to concatenate a string with a float causes an error.
• Fix: convert the float to string, or use formatting strings.

Prefix/suffix patterns

• Add text:
  • As a suffix (append at end)
  • As a prefix (prepend at start)

Replace (non in-place / immutability)

• Replacing underscores with dashes:
  • Uses a replace operation that returns a new string.
• Important: string operations are immutable
  • They do not modify the original variable unless you reassign the result.

Splitting strings into tokens

• Split a string by a delimiter (e.g., -).
• Splitting produces an array (introduced conceptually; arrays covered more in the next video).
• Accessing elements:
  • Example conceptual access: first token / second token.
• Slicing/subslice:
  • Demonstrated slicing behavior using indices (including logic around hyphen position and +1 offset).

---

Formatted strings (preferred approach)

• Formatting uses an F-string:
  • Add f before a string to interpolate variables cleanly.
• Benefit:
  • Automatically formats values (including converting numeric types to strings).
• The instructor mentions there’s no strict right/wrong, but preference is for formatted strings.

---

Exercises included in the video (instruction-style)

Exercise 1 — Calculate price delta

• Given:
  • price_today = 100
  • price_yesterday = 90
• Task:
  • Compute price delta = today − yesterday
  • Update a variable so that:
    • price_delta == 10
• Test condition:
  • A boolean check becomes true only when the computed value equals 10.

Exercise 2 — Calculate total P&L (P&L)

• Given:
  • A starting total_pnl = 0 (default value shown)
  • Example trades:
    • trade1 = -2.0
    • trade2 = 3.0
    • trade3 = 8.5
  • (The subtitle text shows example assignments like “trade3 PNL = 3.0” and “trade4 … 8.5”; overall goal is summing trade P&Ls.)
• Task:
  • Compute:
    • total_pnl = sum(of trade P&Ls)
  • Update the total variable.
• Test condition:
  • total_pnl == 10.7 must evaluate as correct.

Exercise 3 — Parse unstructured API-like string into fields (string processing)

• Scenario:
  • Data arrives as a single string, not well-structured.
  • Example string shown conceptually like:
    • "Apple the price is 26282" (format described in pieces)
• Task:
  • Extract:
    • symbol (initialize as empty string "")
    • price (initialize as 0.0)
  • Implement parsing (“passse” noted; intended meaning: string parsing) using techniques taught earlier:
    • converting strings to numbers
    • tokenizing/splitting
• Tests (two):
  1. symbol == "apple" (case expected as lowercase per test described)
  2. price == 26282
• Only proceed once both test booleans are true.

---

Speakers / sources

• Primary speaker/instructor: The video creator/instructor (name not clearly stated in the subtitles).
• Course/community source mentioned:
  • Patreon supporters: Dogit and Manx Sunny.
• Other named tool/service mentioned:
  • ChatGPT (used as an optional debugging aid; not a speaker).