Python Foundations for AI Agents: Master Data Types, Loops & Functions

AI Agent Engineer Roadmap Series: Foundations

Why does Python feel easy… until it suddenly isn’t? You start learning Python, and everything feels smooth: variables, loops, functions… all intuitive. Then suddenly, your loop behaves weirdly, a function returns something unexpected, a list changes “by itself”. And you’re left thinking: “Wait… what just happened?” That’s the moment fundamentals start to matter.

Data Types, Loops & Functions

Why do people struggle, and why does it matter?

Most beginners memorize syntax without understanding behavior, don’t fully grasp how data flows through code, and treat loops and functions as “magic blocks”. This becomes a serious issue when building AI agents, because Agents rely heavily on state (data types), they run iterations (loops) for reasoning, and they depend on modular logic (functions).

Weak fundamentals = fragile systems.

By the end of this article, you will understand how Python stores and handles data, use loops confidently without unexpected bugs, write clean, reusable functions, predict how your code behaves (not guess), avoid common beginner mistakes, and be ready to apply this in AI agent workflows.

Think Like a System, Not a Coder

Let’s simplify everything with an analogy.

Think of Python like a factory:

DATA TYPES → Raw materials (numbers, text, lists) LOOPS → Conveyor belts (repeat tasks) FUNCTIONS → Machines (process & transform)

Data types = what you work with Loops = how you repeat work *** Functions = how you organize work**

Let’s deep dive.

• Data Types: Your Building Blocks

Working with Basic Data Types

What just happened?

Python dynamically assigns types. Each variable holds a different kind of data. No explicit type declaration needed.

• Lists & Dictionaries (Core for AI Agents)

Managing Structured Data

Lists store ordered items. Dictionaries store key-value pairs. You accessed nested data.

• For Loops: Controlled Iteration

Loop Through Tasks

Loop iterates over each element. No manual index needed. Clean and readable iteration.

• While Loops: Conditional Execution

Run Until Condition Changes

Loop runs until the condition becomes false. Risk of infinite loops if not handled carefully.

• Functions: Reusable Logic

Create a Function

Function encapsulates logic. Takes input, does the process and returns output. Reusable and modular.

• *Advanced Functions (args, kwargs)

Flexible Inputs

*args allows multiple inputs. Useful for dynamic AI workflows.

*args collects positional arguments into a tuple, while **kwargs collects keyword arguments into a dictionary.

• REAL-WORLD EXAMPLE: Mini AI Agent Loop

Simple Task Execution Agent

Loop controls execution flow. Function processes each step. List stores results (state).

This is the core pattern of AI agents.

COMMON MISTAKES

Mistake 1: Modifying Lists Unexpectedly

tasks = ["a", "b"]
new_tasks = tasks
new_tasks.append("c")

Problem: Both variables point to the same list. Python uses reference assignment, not copying by default. So both variables reflect the change.

Fix:

new_tasks = tasks.copy()

Mistake 2: Infinite While Loop

while True:
    print("Running...")

Problem: True is always true; the condition never becomes false. No break or exit condition is present. Loop runs forever (infinite loop). The CPU keeps executing the same block repeatedly.

Fix:

while condition:#breaks loop when condition is false
    print("Running...")

Mistake 3: Mutable Default Arguments

def add_item(item, lst=[]):
    lst.append(item)
    return lst

Problem: Default arguments are evaluated once at function definition time. The same ‘lst’ object is reused across multiple function calls. Each call keeps modifying the same list.

Fix:

def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

Mistake 4: Forgetting Return

def add(a, b):
    a + b

Problem: The expression ‘a+b’ is computed but not returned. Python functions return None by default if no return value is used.

Fix:

return a + b

You now understand how Python stores data, how loops control execution, and how functions organize logic. This trio forms the backbone of every AI agent system.

Cheatsheet

Practice Challenge: You can try to build a mini agent that takes a list of user queries, processes each query using a function, stores results in a dictionary, and prints a summary.

Watch YouTube video: https://youtu.be/pbXNPK70dGw?si=8Gmjn3py_A98A9fj

You can access all the stories in this series through the links below.

**https://medium.com/@aryanbkrishnan/list/ai-agent-engineer-d801cd8de5a3**

**https://medium.com/@aryanbkrishnan/list/ai-agent-engineer-series-foundations-2a07a7214e66**

Enjoy exploring and learning!

References

1. https://docs.python.org/3/tutorial/index.html
2. https://docs.python.org/3/library/stdtypes.html
3. https://docs.python.org/3/reference/index.html