What is Python? Why is it widely used in AI?

import numpy as np

# This loop runs in pure Python — slow (~1 second for 10M elements)
total = 0
data = list(range(10_000_000))
for x in data:
    total += x

# This runs in C — fast (~10ms for 10M elements)
data_np = np.arange(10_000_000)
total_np = np.sum(data_np)   # C loop, not Python loop

# The core stack for AI engineering:

import numpy as np           # Numeric arrays, linear algebra
import pandas as pd          # Tabular data, DataFrames
import matplotlib.pyplot as plt  # Plotting

import torch                 # Deep learning (neural networks)
import torch.nn as nn
import torchvision           # Computer vision datasets and transforms

import sklearn               # Classical ML (classification, regression, clustering)
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

from transformers import AutoTokenizer, AutoModelForCausalLM  # Hugging Face LLMs

import langchain             # LLM application framework
import openai                # OpenAI API client

# All installable with pip:
# pip install numpy pandas matplotlib torch scikit-learn transformers langchain openai

# A typical ML workflow — end to end in Python

# 1. Load and explore data
import pandas as pd
df = pd.read_csv("clinical_trials.csv")
print(df.head())
print(df.describe())

# 2. Preprocess
from sklearn.preprocessing import StandardScaler
X = df[["age", "weight_kg", "egfr"]].values
y = df["responded_to_drug"].values
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Train
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_scaled, y)

# 4. Evaluate
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2)
model.fit(X_train, y_train)
print(classification_report(y_test, model.predict(X_test)))

# 5. Deploy (as an API endpoint)
import pickle
with open("model.pkl", "wb") as f:
    pickle.dump(model, f)

import sys
print(sys.version)
# 3.11.x or 3.12.x — these are the versions supported by PyTorch, JAX, and LangChain

# Type hints: Python 3.10+ syntax used throughout the AI stack
def embed_text(text: str, model: str = "text-embedding-3-small") -> list[float]:
    """Return embedding vector for the given text."""
    ...

# Pattern matching (Python 3.10+): increasingly used in LLM output parsing
def parse_llm_output(output: dict) -> str:
    match output.get("type"):
        case "text":
            return output["content"]
        case "tool_call":
            return f"Calling tool: {output['name']}"
        case _:
            return "Unknown output type"

# The GIL: why threading doesn't help CPU-bound AI tasks
import threading

# CPU-bound (embedding generation): threading gives NO speedup due to GIL
threads = [threading.Thread(target=compute_embedding, args=(text,)) for text in texts]

# Use multiprocessing instead — each process has its own GIL
from multiprocessing import Pool
with Pool(processes=4) as pool:
    embeddings = pool.map(compute_embedding, texts)

# Or use async for I/O-bound tasks (API calls are I/O-bound)
import asyncio
async def embed_batch(texts: list[str]) -> list[list[float]]:
    tasks = [async_embed(t) for t in texts]
    return await asyncio.gather(*tasks)