Python Essentials for AI Agents – Tutorial

Course overview: “Python Essentials for AI Agents” (tutorial-style)

• The course is positioned as a practical path from Python fundamentals to building agentic systems using data handling, API integration, and LLMs.
• Main progression through modules:
  1. Python basics (syntax, variables, data types, functions).
  2. Files & databases (pandas, SQL, using databases from Python).
  3. APIs (REST principles, authentication, rate limits, JSON, handling errors).
  4. LLMs & agent building (OpenAI API, Hugging Face tools, prompt/LLM interaction).

Speaker / guide

• The instructor explains concepts and then demonstrates setup and code examples using Jupyter Lab/Notebook and Google Colab.

Key setup & environments (tutorial steps)

Anaconda installation (Windows-focused)

• Download Anaconda from the web, run the installer, choose “Just me”, keep default paths, and optionally add to PATH.
• Launch Anaconda Navigator and confirm installed components: JupyterLab/Jupyter Notebook.

JupyterLab usage

• Create folders and new notebooks.
• Select a Python kernel (the notebook kernel = interpreter used to run code).
• Execute cells using Shift+Enter / Ctrl+Enter.

Google Colab usage

• Create notebooks saved to Google Drive.
• Connect to a remote runtime (free-tier limitation: only one active notebook runtime at a time).

Core Python concepts demonstrated

Variables, data types, naming rules

• Variables don’t require explicit declaration keywords.
• Data types covered: int, float, string, boolean, None, plus collections (list, tuple, dict, set).
• Naming constraints:
  • Case-sensitive
  • Must start with a letter or underscore (not a digit)
  • Avoid reserved keywords (if, else, def, return, etc.)
• Demonstrated:
  • type() to inspect types
  • Type casting via int() (e.g., float→int truncation)
  • String→int casting to enable arithmetic

Operators (analysis/implementation)

• Arithmetic: + - * / % ** and “floor division” (quotient-like behavior).
• Comparison: == != < <= > >= returning boolean.
• Logical: and, or, not using truth-table reasoning.
• Hands-on practice with variables and compound expressions.

Conditionals

• if, if-else, elif / multi-branch logic, and nested if.
• Emphasizes indentation as a syntactic requirement.
• Best practices:
  • keep conditions readable
  • avoid deep nesting
  • use comments for complex logic
• Demonstrated examples:
  • Even/odd using modulo (n % 2 == 0)
  • Grading bands (A/B/fail) using chained conditions
  • input() returning strings; cast to int()

Loops and control flow

• Loop types:
  • for loops (known iteration counts; range() generator semantics)
  • while loops (unknown iteration count until condition fails)
  • nested loops
• Loop control statements:
  • break to exit loop early
  • continue to skip to the next iteration
  • pass as a placeholder “no-op”
• Demonstrations include:
  • password trial logic (break on correct password)
  • OTP retry logic (continue behavior)
  • skipping elements based on conditions

Functions & scope

• Functions via def, reusable blocks (“recipe” analogy).
• Covers:
  • return vs no return (None when no explicit return)
  • parameters (positional vs keyword args)
  • default argument values and missing required args errors
• Explains scope:
  • global variables accessible inside functions
  • local variables shadowing globals
  • using global keyword for read/write global access

Modules & packages

• Modules: .py files containing reusable code.
• Packages: folder + __init__.py.
• Demonstrates importing nested module paths conceptually (e.g., from package.subpackage.module import ...).

Coding style guidance (best practices)

• Uses PEP 8 and PEP 257:
  • meaningful variable/function names (snake_case)
  • avoid single-letter names
  • proper spacing around operators
  • consistent indentation (4 spaces)
  • line length guidance (~79 chars)
  • blank lines between top-level definitions
  • avoid unused imports/modules
• Documentation strings:
  • docstrings shown with interactive help using Shift+Tab
  • docstrings should describe purpose, inputs, outputs

NumPy (data processing foundations)

Concepts & features

• NumPy arrays (ndarray) replace Python lists for efficiency.
• Vectorization: element-wise operations without explicit loops.
• Universal functions (ufuncs) for arithmetic and transformations:
  • arithmetic ops, exp, log, trig/hyperbolic, rounding (round/floor/ceil/trunc)
  • boolean mask creation via comparisons/logical operations
• Shape manipulation and core operations:
  • create arrays (array, zeros, ones, arange, linspace)
  • indexing/slicing for 1D and 2D
  • fancy indexing and boolean indexing
  • reshape, flatten, transpose
  • type casting with astype
• Broadcasting:
  • adding scalar or arrays with compatible shapes (automatic replication)
• Linear algebra via numpy.linalg:
  • dot product/matmul (np.dot, @)
  • solve linear systems (e.g., solve)
  • inverse/determinant, eigenvalues, SVD
  • norms
• Random module:
  • reproducibility via RNG seed (example uses seed 42)
  • sampling from distributions, shuffle/permutation

Hands-on section

• Demonstrates array creation, indexing/slicing, boolean masking, reshaping, broadcasting, and stats:
  • mean, std, var, min/max/argmin/argmax, quartiles/median
• Shows element-wise vs matrix multiplication distinction.

Data visualization (Matplotlib basics)

• Installation mention: pip install matplotlib (often preinstalled in Anaconda/Colab).
• Imports:
  • import matplotlib.pyplot as plt
  • import numpy as np
• Plot types covered:
  • line plots with customization (title, axis labels, legend, colors, linestyle/linewidth, markers)
  • scatter plots (including alpha and grid control)
  • bar plots for categorical data
  • histograms for continuous distributions (bins)
  • box plots (quartiles, whiskers, outliers)
  • pie charts (labels, explode, startangle, shadow)
• Advanced/custom:
  • axis limits and tick label formatting (including math text like $\pi$)
  • multiple subplots via plt.subplots
  • styling themes (ggplot, seaborn, bmh, etc.)
  • annotations (plt.annotate) and text boxes
  • saving figures: savefig(..., dpi=300) and tight_layout
• Emphasizes readability: legends, axis labels, marker visibility, consistent figure management.

Pandas (data manipulation & analysis)

Structures & IO

• Introduces pandas:
  • DataFrame = 2D tabular structure (rows/columns)
  • Series = 1D (single column or row)
• CSV ingestion using pd.read_csv.
• Also shows CSV writing with to_csv(index=False).

DataFrame operations demonstrated

• Creation of example DataFrame from dictionaries/lists.
• Summary stats:
  • df.describe() (numeric)
  • df.describe(include='object') (categorical)
  • df.info() for datatypes and non-null counts
• Selection & filtering:
  • selecting columns as Series
  • selecting multiple columns by passing a list
  • conditional row filtering (e.g., df[df['marks'] > 80])
• Indexing:
  • .loc (label-based)
  • .iloc (integer-position-based)
• Column transformations:
  • creating new columns (e.g., double_marks)
  • applying lambda functions (apply with lambda)
  • renaming columns
  • dropping columns (drop(..., axis=1))
• Missing values:
  • inserting NaNs (and observing dtype changes int→float)
  • detecting missingness with boolean masks
  • fillna() using mean
  • astype(int) to revert dtype (with potential precision loss)
  • dropna() to remove rows/columns containing NaNs
• Duplicates:
  • drop_duplicates()
• String transformations:
  • converting subject to lowercase via .str.lower()
• Sorting:
  • sort_values(..., ascending=...)
  • multi-column sorting (primary/secondary keys)
  • sorting index and resetting index (reset_index)
• Merging/joining:
  • merge with inner/outer join behavior implied by matching keys
• Concatenation:
  • concat along axis=0 (vertical) vs axis=1 (horizontal)
• Aggregation and reshaping:
  • groupby summaries (mean/sum style)
  • pivot_table for multi-dimensional summaries
• Mapping and encoding:
  • mapping categorical values to numeric labels using .map() (e.g., gender encoding)
• Datetime handling:
  • converting string dates with pd.to_datetime
  • extracting date parts (month, year, etc.)

Databases & SQL (concepts + Python integration)

Database types

• Relational DBs: tables/rows/columns (examples: MySQL, PostgreSQL, SQLite).
• NoSQL: document/key-value/graph structures (examples referenced: MongoDB/Cassandra/Redis).

SQL basics

• Commands: CREATE TABLE, INSERT, UPDATE, DELETE, SELECT.

Connecting Python to databases

• Libraries mentioned:
  • SQLite: sqlite3
  • MySQL: mysql-connector-python, PyMySQL
  • PostgreSQL: psycopg2
  • ORM options: SQLAlchemy, SQLModel
• Pandas integration:
  • pd.read_sql_query(...) to fetch query results into a DataFrame.

Raw SQL vs ORM

• Raw SQL concerns:
  • complexity/maintainability
  • security risk (SQL injection) → recommends parameterization
• ORM advantages:
  • abstraction using Python classes/objects
  • easier refactoring
  • easier switching DB backends

In-memory SQLite

• Uses the concept sqlite3.connect(":memory:"):
  • fast, volatile, great for testing
  • data disappears after connection ends
• Typical flow:
  • create table → insert → query → update/delete → commit → close connection

MySQL + PostgreSQL on AWS (hands-on style)

• Shows connecting to remote DBs using credentials (host/user/password/dbname/port).
• Warns against hardcoding sensitive credentials; suggests using environment variables (noted as an upcoming follow-up).
• Demonstrates query execution:
  • MySQL: row results as dictionaries via cursor fetch style
  • Postgres: similar flow via psycopg2 (with commit and close)
• Notes about pandas:
  • read_sql works best with SQLAlchemy connectable
  • direct psycopg2 usage may work but is “not safe/supported” per notes.

File handling: CSV & JSON

• Built-in CSV and JSON modules:
  • CSV: csv.reader / csv.writer
  • JSON: json.load / json.dump (and json.loads / json.dumps for strings)
• Pandas option: read CSV into DataFrames and write DataFrames back to CSV.
• JSON example includes modifying structured data and writing back with indentation.

APIs for AI agents & LLM integration

REST + HTTP fundamentals (analysis)

• API definition and role in system interoperability.
• REST concepts:
  • statelessness
  • client-server separation
  • uniform interface
  • cacheability
• HTTP methods:
  • GET, POST, PUT, DELETE
• Status codes:
  • 200 success, 404 not found, 500 server error (and more later)

Python API access

• Libraries:
  • requests emphasized
  • urllib mentioned as an alternative
• Response parsing:
  • check response.status_code
  • parse JSON via response.json()

Operational best practices

• Handle errors gracefully (check status code, raise exceptions).
• Rate limit awareness:
  • read rate limit info from headers
  • delays and exponential backoff strategies
• Authentication:
  • API keys (store securely, preferably environment variables)
  • OAuth2 (authorization code flow) mentioned conceptually
• Validation:
  • validate inputs/outputs
• Logging:
  • track requests/responses for debugging

API to LLMs/agents

• A prompt is sent to an LLM API → the model returns generated text.
• Mentions:
  • latency, cost, privacy concerns.

Building REST APIs: Flask vs FastAPI

Flask

• Micro-framework; routing via decorators.
• Examples:
  • GET endpoints returning JSON/HTML
  • POST endpoint:
    • parsing form data vs JSON (request.get_json())
• Demonstrates:
  • testing via browser, curl, Postman
  • HTTP status interpretation (200 vs 404)
  • URL encoding for spaces/special characters
  • try/except handling for invalid inputs (division by zero, negative sqrt, missing parameters)
• Mentions an end-to-end example:
  • templates (home.html, form.html, results.html)
  • static CSS (static/)
  • 304 Not Modified shown as caching behavior.

FastAPI (high-level comparison)

• Emphasizes:
  • type hints for validation/serialization
  • async support
  • automatic documentation
• Comparison summary:
  • Flask: simpler/less setup for small projects
  • FastAPI: modern, faster development for robust APIs with validations/docs

LLM hands-on with hosted APIs

OpenAI + Google Gemini

• Shows:
  • creating API keys
  • storing keys in environment variables
  • making model calls with prompt/messages
  • extracting returned message content
• Supports switching model names (GPT-4 vs Gemini Pro) and outlines an error for unknown model names.

Hugging Face serverless inference APIs (prompt engineering)

• Uses:
  • Hugging Face inference API with requests.post
  • authentication via Bearer token header
  • payload parameters like:
    • max_new_tokens
    • temperature
• Models used:
  • Mistral 7B Instruct
  • Gemma 2B IT
• Includes exercises:
  • zero-shot prompting (“explain X to a fifth grader”)
  • summarization with a prompt template (limit to N lines)
  • sentiment + topic extraction from a customer review
• Notes:
  • gated model access may require license acceptance.

Running open-source LLMs locally (GPU + Transformers)

• Uses Hugging Face Transformers:
  • requires GPU (example uses Google Colab T4 GPU setup)
  • installs transformers, restarts runtime
  • logs in with Hugging Face token
• Downloads model weights (large memory use; ~5GB scale mentioned).
• Demonstrates:
  • tokenizer apply_chat_template and tokenization/decoding workflow
  • pipeline-based generation alternative
  • prompt configuration:
    • temperature
    • max_new_tokens
• Repeats exercises locally:
  • Q&A prompt
  • summarization
  • sentiment/topic extraction

Agent frameworks overview (comparison)

• Introduces four tools for building autonomous AI agents:

  1. LangChain: LLM app framework; integrations, document handling, memory, tools for chatbots and “reasoning + action” agents.
  2. LangGraph: workflow/state management using DAGs/cyclic graphs; advanced memory/error handling; integrates with LangChain; caching.
  3. CrewAI: role-based multi-agent systems; dynamic task allocation; progress monitoring; useful for research/education/customer support/coding assistance.
  4. AutoGen: conversation-based agent workflows; modular design; supports asynchronous messaging, containerized code execution; cross-language operations.

Main speakers / sources

• Primary speaker/instructor: Prashant Sahu (course host and guide throughout the tutorial).
• No other specific named external speakers appear in the subtitles (framework/library documentation is referenced conceptually, but not as separate speakers).