Python, GPT-5.2 & LLMs: Build AI Agents & Reasoning Apps

Start and stop the Python 3 interpreter from the terminal, use interactive mode as a calculator, and write scripts that fetch bus stop predictions via http.

Learn to turn a hardwired Python script into a general tool by reading route and stop id from the command line, then debug with traceback messages and pdb.

Build a Python mortgage calculator from variables, while loops, and if statements, illustrating indentation and using Python as a calculator for principal, interest, and payments.

Format and align a Python output into a readable mortgage schedule table using print formatting, percent formatting and format method, and optionally write the results to a file.

Learn Python function definitions with def statements, return, and docstrings, then refactor a file-reading script into reusable functions and pattern-match files with glob.

Catch data errors in a Python function with try and except, report bad rows, show the error reason, and use enumerate to track row numbers for diagnostics.

Explore advanced function design in Python by handling errors with precise exceptions, avoiding catchall patterns, and introducing optional keyword arguments to control warnings and side effects.

Improve function readability and robustness by using the keyword style for optional arguments, defensively validating inputs, and choosing explicit error handling (silent, ignore, or raise) when appropriate.

Explore core Python data structures, including tuples, lists, sets, and dictionaries, covering packing and unpacking, immutability, modification, and fast lookups for data analysis.

Read a csv into a data structure, build a portfolio as a list of records, switch from tuples to dictionaries for readability, and encode with json for sharing.

Master data manipulation in python by iterating over a list of dictionaries with for loops, computing totals, building lists, and filtering holdings with list comprehension.

Learn to manipulate data in Python by extracting stock names and removing duplicates with sets. Build price lookups with zip and dictionary comprehensions to compute portfolio value.

Learn how to sort Python data with a key function and lambda expressions, then group by name and build dictionaries for lookup, including min and max with key.

Learn how the import statement loads a Python file as a module and executes it in isolation. Access contents via the module name or via from module import form syntax.

Python caches imported modules, so subsequent imports don't re-run code. Manage module paths, reloads, and protect code with if __name__ == '__main__' to avoid side effects.

Learn to generalize CSV parsing in Python by building a reader library that converts rows with a type list, maps headers to dictionaries, and supports import and main guard usage.

Learn how to create a Python package by turning modules into a directory, adding an init file, and managing imports with relative package imports to avoid name collisions.

Define a simple Python class called holding with an __init__ method to store name, date, shares, and price, and a cost method to compute total value.

Explore Python's object system, built on attribute operations: get, set, and delete. Access attributes with dot notation or getattr, setattr, and delattr, and see how methods rely on this machinery.

Discover how to implement alternate constructors with class methods in Python, using a date class to create instances from a string, or today’s date, without hardcoding the class name.

Explore how inheritance lets a child class borrow and extend a parent class in Python, including adding or overriding methods, wrapping them with super, and supporting multiple inheritance.

Explore how inheritance refactors a print table function into a table format class, enabling extensible table outputs like text, csv, and html by subclassing and implementing headings and row methods.

Explore common pitfalls in inheritance, including init and attribute handling, and how to design extensible, configurable table formatters with base classes, output file options, and multiple inheritance with mixins.

Explore defensive programming in inheritance by examining a print table function and a base table format class. Evaluate whether to consolidate functionality into a dedicated table printer and formatter.

Understand Python inheritance, including single and cooperative multiple inheritance, method resolution order, and how the super function moves to the next class in the MRO.

Learn how Python uses special methods to customize operators, implement container class methods like __add__ and __mul__, and use the repr and string conversion methods for clearer debugging output.

Explore building a Python portfolio class as a custom container, reading holdings from a file, and implementing magic methods like __len__, __getitem__, and iteration to enable intuitive indexing and looping.

Explore context managers in Python by implementing enter and exit to power the with statement for safe resource management, including acquiring, using, and releasing resources.

Learn to manage attributes in a python class by using getters and setters to validate price, and optionally hide with an underscore, while recognizing direct assignment can bypass checks.

Replace basic getters and setters with properties to own and validate attributes like price and shares, intercept bad input, and create computed attributes such as cost while preserving existing code.

Discover how descriptors replace verbose properties by intercepting dot notation with get and set, enabling type validation and controlled attribute access in Python classes.

Define a point class with class-level integer descriptors to supervise x and y attributes, enforce types, catch errors, and illustrate how to build a mini type system for Python.

Learn how Python treats functions as first-class objects, passing and storing them like data, using lambdas and closures for delayed evaluation and flexible higher-order code.

Discover how to use Python functions to create reusable typed properties that enforce type checks for attributes like price and shares, reducing repetitive code with a Typekit property factory.

Explains how functions accept any number of positional or keyword arguments using *args and **kwargs, how to mix them, and how wrappers enable pass-through calls, with decorators coming next.

Discover how repetitive code for logging prompts a maintenance nightmare, and learn how decorators wrap functions to centralize logging with a single, reusable wrapper.

Explore how decorators wrap functions to add features like logging, using the @ syntax, and preserve metadata with wraps for proper signatures and the documentation string.

Learn to build Python decorators with arguments using an outer function to capture a log format and an inner decorator to wrap functions, enabling reusable, configurable logging.

Explore class decorators that wrap all methods, enabling logging and brain-surgery like transformations, and even automatic type validation and attribute filling on class definitions.

Learn how Python treats every object as having a type, how types create classes and instances, and how a better class can supervise a whole object hierarchy.

Explains how to use a metaclass to manage and auto register table format classes within a table printing system, replacing manual registration with automatic discovery.

Explore how metaclasses fill in class details by inheriting from type, auto apply decorators, and enforcing a Typekit-based attribute system to reduce boilerplate and clarify data models.

Explore Python's iteration protocol by using for loops, iterators, and the stop iteration mechanism; build custom generators with yield, generator functions, and generator expressions for efficient one-pass data processing.

Watch real-time data sources with a Python generator that yields lines from the end of a file. Use yield to follow a log or stock data and process new events.

Learn to create data processing pipelines with Python generators, piping output between functions, filtering for specific stock names, applying type conversions, and detecting negative changes in streaming stock data.

Introduce coroutines by defining async def functions and using await to run them under an event loop. Show that these code routine objects require a runner to execute until complete.

Write a Python echo server with socket, then scale it with threading and asyncio coroutines to handle thousands of concurrent connections efficiently.

Explore how coroutines power async programming in Python, revealing how async functions, await, and generators work under the hood with yield and stop iteration to drive asynchronous I/O.

Explore how coroutines drive asynchronous programming with generators and yield, showing an event loop coordinating socket operations and code routines in an echo handler.

Master the core of Python to navigate standard library modules, third-party extensions, and larger frameworks for day-to-day coding, organize data with functions, and define objects and classes for reuse.

Explore foundational principles of transformative llms, from transformers and tokenization to model structures. Learn to go deep inside and, on top, manage vast applications through project management skills.

Explore the evolutionary trajectory of large language models, from transformers and GPT to discriminative and generative distinctions, and master tokenization and embeddings for practical management.

Explore how transformers use tokens and embeddings, compare encoder, decoder, and encoder-decoder designs, and reveal that these systems rely on empirical statistics rather than true intelligence, highlighting prompt design.

Explore the inner workings of large language models by examining attention head matrix multiplications, Q, K, V operations, softmax, embeddings, and positional encoding, demystifying the motor behind AI.

Explain how eight-headed multi-head attention and transformers break down tokens into 96 views to reveal inter-word relationships, producing a single next-token with downstream softmax, top-k, and top-p processing.

Explore how transformers underpin modern AI, from prompt design to automated prompts, and assess implications for enterprises and data privacy.

Master transformer mathematics to see how tokenization, embedding, and processing power LLMs, while leveraging advanced data analysis and enforcing management to coordinate AI teams.

Explore strategies for customizing LLMs for specific tasks, with case studies on customer support and content generation. Evaluate frameworks, platforms, costs, data, and team roles to guide management decisions.