Python Foundations

The problem: A computer does not guess what a person meant. It needs precise instructions, yet writing those instructions directly as machine code would be painfully difficult. Python gives us a readable way to express each operation and see its result.

What you will learn: You will follow how Python stores and combines values, accepts input, and produces output. These are not isolated syntax rules; they are the raw materials later used to construct prompts, read model settings, process AI responses, and build agents or RAG pipelines.

---

1. Introduction to Python

Before learning individual keywords, see the journey of one instruction:

You describe a task in Python
            ↓
Python checks the grammar
            ↓
Python executes the instructions in order
            ↓
The program reads input, changes data, and produces output

For example, print(2 + 3) contains data (2 and 3), an operation (+), and output (print). Larger AI programs use the same pattern; they simply have more steps and may send some data to a trained model.

Python in One Sentence

Python is a programming language — a way of writing instructions that a computer can execute step by step. Unlike English, Python has strict rules (a syntax) so the computer never has to guess what you meant.

The Problem Python Solves

Computers only understand binary (0s and 1s). Nobody wants to write that by hand. Python exists to let humans write instructions in something close to plain English, which Python then translates into something the machine can run.

Picture It as a Translator

Think of Python as a translator standing between you and the computer. You speak relatively human-friendly sentences; Python converts them into machine instructions.

🤖 How Is This Used in AI?

Almost every major AI tool exposes a Python interface:

• OpenAI, Anthropic, Google — official Python SDKs
• PyTorch, TensorFlow — written with Python front-ends
• LangChain, LangGraph, Hugging Face — Python-first frameworks

You’re not just learning “a language.” You’re learning one of the main languages used to build modern AI systems. Some low-level model code runs in C++ or CUDA, and many web interfaces use JavaScript, but Python commonly joins the data, model, API, and evaluation pieces.

✅ Key Takeaway: Python is the common tongue between you and almost every AI tool you’ll ever use.

---

2. Why Python Is Important for AI

Three reasons, concretely:

Reason	What it means in practice
Readability	AI code is already conceptually hard (math, models, pipelines). Python’s simple syntax means you fight the language less, and the problem more.
Ecosystem	NumPy, Pandas, PyTorch, Pydantic, FastAPI, LangChain — the entire AI toolchain is Python-native.
Glue power	AI apps aren’t just “the model.” They’re: read a file → clean data → call an API → validate the response → store the result. Python is exceptional at gluing these steps together.

Real-World Analogy: If AI models are the engine of a car, Python is the chassis, wiring, and dashboard — the thing that connects the engine to something a human can actually drive.

---

3. Python Installation and Setup

You don’t need to memorize this — just know what’s happening.

1. Install Python from python.org (or use a version manager like pyenv).
2. Verify it installed correctly:

On Windows:

py -3 --version

On macOS or Linux:

python3 --version

Expected output:

Python 3.14.x

Your exact version may be different. The important part is that it starts with Python 3. Inside an activated virtual environment, the command is normally just python on every operating system.

3. Install an editor — VS Code is the standard choice; it has excellent Python and AI-tooling support.

⚠️ Common Beginner Mistake: Installing Python but running a command that points to another installation. Use py -3 on Windows or python3 on macOS and Linux while checking your setup. Later, a virtual environment gives the project its own reliable python command.

---

4. Running Python Programs

There are two everyday ways to run Python:

A. Script file (what real AI projects use)

python3 app.py

B. Interactive shell / REPL (great for quick experiments)

python3
>>> print("hello")
hello

🤖 How Is This Used in AI? Real AI services (a RAG API, an agent backend) run as scripts (python3 main.py) or behind a server process. The REPL is what you’ll use constantly to quickly test “does this API call actually return what I think it returns?” before wiring it into a full application.

---

5. Variables

Python in One Sentence

A variable is a name that refers to a value stored in memory.

model_name = "gpt-4"

The Problem Python Solves

Without variables, you’d have to retype "gpt-4" every time you needed it, and if it changed, you’d have to hunt down every occurrence. Variables let you name a value once and reuse/update it from a single place.

Picture It as a Translator

A variable is a label on a box. The box holds a value; the label is how you refer to it.

In Python, variables are actually references (or pointers) that point to where the value resides in memory:

graph LR
    subgraph Memory Reference
        label[model_name] -->|points to| obj[("String: 'gpt-4o-mini'")]
    end

Real-World Analogy

Think of a variable as a labeled storage box in a warehouse. You don’t care exactly where the box physically sits — you just ask for it by its label (“give me the box labeled model_name”) and Python finds it.

Syntax

variable_name = value

Example

# Storing basic AI configuration in variables
model_name = "gpt-4o-mini"      # which model to call
temperature = 0.7               # how "creative" the output should be
max_tokens = 500                # response length limit
api_key = "your_api_key_here"   # placeholder — never hardcode real keys

print(model_name)
print(temperature)

Expected Output:

gpt-4o-mini
0.7

[!IMPORTANT] Production Key Management: Never Hardcode API Keys In real-world AI applications, you should never write your API keys directly into your code as strings. If you upload that code to GitHub, anyone can see and steal your key!

Instead, store secrets in a local .env file:

OPENAI_API_KEY="your-actual-api-key"

And load them inside Python using the standard library os module:

import os
api_key = os.getenv("OPENAI_API_KEY")

(Module 8 covers modules, packages, and environment loading in detail, but get into the habit of thinking about configuration variables versus secrets from day one!)

How It Works

• model_name = "gpt-4o-mini" creates a variable named model_name and points it at the text "gpt-4o-mini".
• Python figures out the type automatically (you didn’t say “this is text”) — this is called dynamic typing.

🤖 How Is This Used in AI?

Every AI script starts by defining configuration as variables:

• which model to call
• how “creative” the output should be (temperature)
• how long the response can be (max_tokens)
• which API key to authenticate with

When you later see:

response = client.messages.create(model=model_name, max_tokens=max_tokens)

…that’s just variables being passed into a function. Nothing mysterious.

⚠️ Common Beginner Mistakes

Model_Name = "gpt-4"
print(model_name)   # NameError: model_name is not defined

Python is case-sensitive — Model_Name and model_name are two different variables entirely.

✅ Key Takeaway: A variable is a named reference to a value. Almost every AI script begins with a block of variables describing what to run and how.

---

6. Data Types

What Is It?

Every value in Python has a type — a category that determines what you can do with it (add numbers, but not “add” two sentences the same way).

Type	Example	Used for
int	5	counts, token limits
float	0.7	temperature, similarity scores
str	"hello"	prompts, model names
bool	True	flags (stream=True)
list	[1, 2, 3]	collections of documents/tokens
dict	{"role": "user"}	JSON-like structured data
None	None	“no value yet”

💡 Type Hinting (PEP 484)

While Python is dynamically typed (meaning you don’t have to declare what type a variable is), modern production codebases (especially in AI development, using libraries like Pydantic and FastAPI) use Type Hints to explicitly annotate variables.

It looks like this:

model_name: str = "gpt-4o-mini"
temperature: float = 0.7
max_tokens: int = 500
is_streaming: bool = True

This tells the editor and other developers what type of value this variable is expected to hold, providing better autocomplete and highlighting type mismatches before the code runs.

print(type(5))        # <class 'int'>
print(type(0.7))      # <class 'float'>
print(type("hi"))     # <class 'str'>
print(type(True))     # <class 'bool'>

🤖 How Is This Used in AI? LLM API responses arrive as JSON, which Python converts into a mix of exactly these types — strings for text, floats for scores, lists for message history, dicts for structured fields. Recognizing types is how you know what you’re allowed to do with a piece of data you just received.

---

7. Numbers (int and float)

🧠 Intuition

int = whole numbers. float = numbers with decimals. Python treats them differently because computers store them differently in memory.

Example

max_tokens: int = 500
temperature: float = 0.7
similarity_score: float = 0.8432

# Basic math
tokens_used: int = 120
tokens_remaining: int = max_tokens - tokens_used
print(tokens_remaining)

Expected Output:

380

🤖 How Is This Used in AI?

• int → token counts, batch sizes, number of retries
• float → temperature, embedding similarity scores, probabilities, confidence values

⚠️ Common Beginner Mistake:

print(5 / 2)    # 2.5  (always returns a float)
print(5 // 2)   # 2    (floor division — drops the remainder)

Using / when you meant // (or vice versa) silently produces wrong numbers — dangerous when you’re computing things like batch counts.

---

8. Strings

What Is It?

A string is text — any sequence of characters wrapped in quotes.

prompt: str = "Explain quantum computing in simple terms"

🧠 Intuition

A string is a sequence of characters you can measure, slice, and combine — much like a sentence written on a strip of paper you can cut and tape together.

Example

system_prompt: str = "You are a helpful assistant."
user_question: str = "What is Python?"

# String concatenation — building a full prompt from pieces
full_prompt: str = system_prompt + " " + user_question
print(full_prompt)

# f-strings — the standard way to inject variables into text
model: str = "gpt-4o-mini"
message: str = f"Calling model: {model} with prompt: '{user_question}'"
print(message)

# Useful string methods
print(user_question.lower())
print(len(user_question))

Expected Output:

You are a helpful assistant. What is Python?
Calling model: gpt-4o-mini with prompt: 'What is Python?'
what is python?
16

How It Works

• + joins strings together.
• An f-string (f"...") lets you embed variables directly inside text using { } — this is the standard, modern way to build strings in Python.
• .lower() and len() are string methods/functions — built-in tools for working with text.

🤖 How Is This Used in AI?

Strings are the primary unit of AI work:

• prompts sent to an LLM are strings
• LLM responses come back as strings
• f-strings are how you dynamically build prompts:

context = "Paris is the capital of France."
question = "What is the capital of France?"

prompt = f"""Answer the question using only this context.

Context: {context}
Question: {question}
"""

This exact pattern — injecting retrieved context into a template — is the core mechanic behind RAG (Retrieval-Augmented Generation).

✅ Key Takeaway: If you understand strings and f-strings well, you already understand how most prompts are built in real AI code.

---

9. Boolean Values

What Is It?

A boolean is one of exactly two values: True or False.

is_streaming: bool = True
has_error: bool = False

🧠 Intuition

A boolean is a light switch — on or off, nothing in between.

Example

response_received: bool = True
tokens_available: int = 200
max_tokens: int = 500

can_generate: bool = response_received and tokens_available > 0
print(can_generate)

Expected Output:

True

🤖 How Is This Used in AI?

Booleans control flags all over AI code:

stream: bool = True        # should the API stream tokens back one at a time?
verbose: bool = False       # should debug logs print?
use_cache: bool = True      # should we reuse a previous embedding?

And they drive decisions: “if the response is valid, save it; otherwise, retry.”

---

10. Type Conversion

What Is It?

Converting a value from one type to another — e.g., text "5" into the number 5.

Why Does It Exist?

Data doesn’t always arrive in the type you need. User input from a keyboard, for instance, is always text — even if the user typed a number.

Example

max_tokens_input: str = "500"       # this came in as text
max_tokens: int = int(max_tokens_input)   # convert text -> integer

print(max_tokens + 100)
print(type(max_tokens))

Expected Output:

600
<class 'int'>

⚠️ Common Beginner Mistake:

max_tokens_input = "500"
print(max_tokens_input + 100)
# TypeError: can only concatenate str (not "int") to str

You cannot mix a string and a number with + — one side must be converted first.

🤖 How Is This Used in AI?

• Reading config values from a .env file (they always arrive as strings) and converting them to int/float before use.
• Converting model confidence scores (often strings inside JSON) into floats you can actually compare or sort.

---

11. Input and Output

What Is It?

print() sends output to the screen. input() pauses the program and waits for the user to type something.

Example

user_question: str = input("Ask the AI something: ")
print(f"You asked: {user_question}")

Expected Output (after typing What is RAG?):

Ask the AI something: What is RAG?
You asked: What is RAG?

🤖 How Is This Used in AI?

Every command-line AI chatbot you’ve ever seen (while True: input(...)) is built on exactly this pair of functions — read what the user typed, send it to the model, print what comes back.

---

12. Operators

Category	Examples	Notes
Arithmetic	+ - * / // % **	% = remainder, ** = power
Comparison	== != > < >= <=	always returns a boolean
Logical	and or not	combine boolean conditions
Assignment	= += -= *=	+= means “add and reassign”

tokens_used: int = 100
tokens_used += 50          # same as: tokens_used = tokens_used + 50
print(tokens_used)         # 150

score: float = 0.82
is_confident: bool = score >= 0.8
print(is_confident)        # True

🤖 How Is This Used in AI? Comparison and logical operators are how you filter results: “keep this document only if similarity_score >= 0.75.” That single pattern is the backbone of retrieval filtering in RAG systems.

---

13. Comments and Code Style

# This is a comment — Python ignores this line entirely.
# Comments explain WHY, not just what the code does.

temperature: float = 0.7  # lower = more focused, higher = more creative

🤖 How Is This Used in AI? AI codebases are read by teammates (and by you, six months later) far more often than they’re written. A comment explaining why temperature = 0.2 was chosen for a factual-answering bot is often more valuable than the code itself.

---

What Happens After You Press Enter?

Python does more than read the file like a person reading a page. A simplified execution flow is:

Your .py text
     ↓ parse: "Does this follow Python grammar?"
Python bytecode
     ↓ execute one instruction after another
Python virtual machine
     ↓
Visible result or an error

If the grammar is broken, Python stops before running that part. If the grammar is valid but an operation fails—such as dividing by zero—the program starts and then raises an exception at that operation.

Names Point to Objects

The box analogy is useful, but Python variables behave more like sticky-note labels attached to objects. Two names can point to the same mutable object:

first = ["document A"]
second = first
second.append("document B")

print(first)  # ['document A', 'document B']

second = first did not make another list. It made a second name for the same list. This matters when functions receive lists or dictionaries.

Treat User Input as Untrusted

input() always returns text, even when the user types digits. Validate and convert that text before using it:

raw_age = input("How old are you? ")

try:
    age = int(raw_age)
    if age < 0:
        print("Age cannot be negative.")
    else:
        print(f"Next year you will be {age + 1}.")
except ValueError:
    print("Please enter a whole number.")

The same rule applies to an AI prompt, uploaded file, or tool argument: it came from outside your program and must not be trusted automatically.

Module Summary

You now know how Python stores (variables), categorizes (data types), and manipulates (operators) information, how it talks to a human (input/output), and the basic mechanics of running a program at all.

AI Connection

Every AI script — from a two-line API call to a full agent framework — starts with exactly this: variables holding configuration, strings holding prompts, numbers controlling behavior, and print statements showing you what happened. This module is the alphabet; later modules teach you to write sentences and paragraphs with it.

Mini Practice

1. Create variables for model_name, temperature, and max_tokens, then print an f-string summarizing all three in one sentence.
2. Take a user’s name and favorite topic using input(), then build a prompt string like: "Write a short poem about {topic} for {name}."
3. Given similarity_score = "0.83" (a string), convert it to a float and check whether it’s >= 0.75.
4. Write a boolean expression that’s True only when tokens_used < max_tokens and has_error is False.
5. Explain, in your own words (one sentence each), why AI code uses so many f-strings, and why config values are almost always stored as variables at the top of a script.

---

Next: Module 2 — Collections (Lists, Tuples, Sets, Dictionaries) — how AI applications actually hold documents, tokens, and structured data.