Microsoft Python Interview Questions 2026

Lists are mutable (can be changed after creation) and defined with square brackets []. Tuples are immutable (cannot be changed) and defined with parentheses (). Tuples are generally faster and use less memory. Use tuples for fixed data like coordinates or function return values, and lists for collections that need modification.

A decorator is a function that wraps another function to extend its behavior without modifying the original function. Example: A @timing decorator that measures execution time. In FastAPI, @app.get("/") is a decorator that registers a function as a route handler. In production AI systems, decorators are used for caching, logging, rate limiting, and retry logic.

A generator is a function that yields values one at a time using the yield keyword instead of returning all at once. For AI workloads, generators are critical for streaming large datasets without loading everything into memory. Example: Reading a 10GB embeddings file in chunks, or streaming LLM responses token by token in a FastAPI endpoint using StreamingResponse.

asyncio is Python's async I/O framework for concurrent non-blocking operations. Use async/await when your code is I/O-bound: calling APIs, reading from databases, or making HTTP requests. In AI systems, async is essential for FastAPI endpoints that call LLM APIs concurrently — a single request may call OpenAI + Pinecone + PostgreSQL simultaneously, reducing latency from 3s to 1s.

The Global Interpreter Lock (GIL) prevents multiple Python threads from executing Python code simultaneously. For ML workloads, this is largely irrelevant because NumPy, PyTorch, and most ML libraries release the GIL during C extensions. Use multiprocessing (not multithreading) for CPU-bound Python code. For production AI APIs, use async I/O for I/O-bound tasks and worker processes (Gunicorn + Uvicorn) for parallelism.

Python uses reference counting as the primary memory management strategy, plus a cyclic garbage collector for circular references. Each object has a reference count; when it reaches 0, memory is freed. For large ML models, explicitly delete objects (del model) and call gc.collect() to free GPU/CPU memory. Use context managers (with statements) to ensure resources are released.

*args allows a function to accept any number of positional arguments as a tuple. **kwargs allows any number of keyword arguments as a dictionary. In AI tooling, **kwargs is extensively used for passing model parameters: model.fit(**training_config). Both are essential for writing flexible wrapper functions around LLM APIs and model training loops.

List comprehensions create the entire list in memory: [embed(text) for text in docs]. Generator expressions are lazy and process one at a time: (embed(text) for text in docs). For large AI datasets (e.g., processing 100k documents for embedding), always use generator expressions or batch processing to avoid OOM errors. Generators are also ideal for streaming predictions from a model.

Use specific exception types, not bare except. Structure: try/except with specific exceptions (OpenAIError, PineconeException), add retry logic with exponential backoff using tenacity library, log errors with context (request_id, user_id, model params), and raise HTTPException with appropriate status codes in FastAPI. Never swallow exceptions silently in production — every error should be logged and alerted.

Pydantic is a Python library for data validation using type annotations. It is the foundation of FastAPI and ensures that all incoming API data matches expected types. In AI systems, Pydantic models validate LLM responses (structured outputs), ensure prompt templates receive correct inputs, and define schema for tool/function calling. Without Pydantic, production AI APIs are brittle and fail silently on bad data.