Python 3: Deep Dive (Part 1 - Functional)

Explore how to build and use Python classes, initialize with __init__, and define properties like width and height. Implement area, perimeter, string representations, equality, and rich comparisons using Pythonic conventions.

Explore how Python uses reference counting to manage object lifetimes and track references. Inspect counts with get_ref_count and ctypes to see memory references in action.

Demonstrate function arguments and mutability in Python, highlighting how strings stay immutable and safe, while lists and mutable tuple elements may change via passed references.

Understand shared references and mutability in Python: how strings are immutable, how lists are mutable, and how passing references to functions can cause in place changes and side effects.

Explore how Python compares values and identity using the is and == operators, differentiate memory addresses, None handling, and how lists, numbers, and strings may share or differ in identity.

Explore how Python uses string interning to speed up identifier lookups and reduce memory, and learn when to force interning and when to use is versus == in string comparisons.

Explore peephole optimizations in Python, focusing on compile-time constant expressions that get pre-calculated, short sequences, and converting lists to tuples and sets to frozen sets for faster membership tests.

Explore truncation, floor, and ceiling in Python by using math.trunc (or trunk), the int constructor, floor, and ceil to convert floats to integers; understand differences with negative numbers.

Construct decimals with the decimal module's Decimal class using integers, strings, or tuples, avoiding floats for exact values. Context precision affects arithmetic, not construction, with global and local contexts.

Explore how the decimal constructor accepts integers, strings, tuples, or another decimal, yields zero with no input, and how global and local contexts affect arithmetic precision and float inaccuracies.

Learn complex numbers in Python using the built-in complex class, real and imaginary parts, literals with j, and polar-rectangular conversions with cmath, plus the is close method for Euler's identity.

Explore the boolean data type in Python, its inheritance from int, and how true and false behave as singleton bool objects alongside integer operations, truth values, and type conversions.

Discover how Python boolean operators work, including short-circuiting with or and and. Apply these concepts to set default values, handle truthy and falsy inputs, and use not to negate truth values.

Master positional and keyword arguments in a three-parameter function by mapping A, B, and C. See how default values make parameters optional and how keyword arguments must match parameter names.

Explore extended unpacking in Python, comparing slicing and start expressions, with practical examples for lists, strings, sets, and dictionaries. Learn nested unpacking and combining iterables to write clearer, flexible code.

Dive into Python keyword arguments, including positional versus named parameters, using star and star args, and enforcing mandatory and optional keyword arguments for robust function calls.

Document functions with docstrings and annotations to attach metadata, stored in __annotations__ and dunder doc, enabling external tools like Sphinx to generate documentation.

Explore lambda expressions as anonymous Python functions, created with the lambda keyword and a single expression body, assignable as function objects, passable as arguments, and comparable to def functions.

Explore function introspection by defining a Python function, inspecting its annotations, defaults, and docstring, and using inspect to examine code, signature, and parameter kinds.

Explore Python callables: what makes an object callable, how to test with callable(), and how functions, methods, classes, and instances can be invoked with the call operator.

Explore map, filter, zip, and list comprehensions in Python, handling generators, deferred calculations, and combining iterables with two lists, lambdas, and factorial examples.

Explore closures in Python, including free variables, non-local variables, and cells. Learn how closures capture outer scope, how memory cells work, and how nested closures behave.

Explore closures that implement counters and track function calls by capturing non-local state. Learn to pass functions, use inner closures, and store call counts in a dictionary.

Explore decorators in Python 3, using closures and higher-order functions to wrap functions, maintain state, and inspect metadata with wraps for proper naming and docs.

Learn how class instances become callable to decorate functions, implement a decorator factory, and compare closures and dunder call based decorators for function decoration.

Explore implementing a single dispatch generic function in Python using a decorator, a registry, and a type-based dispatch mechanism, including a register decorator and closures.

Explore Python tuples as immutable sequence records, distinguish them from lists, and learn how order matters and positions carry meaning. See how named tuples give names to positions for records.

Compare tuples with lists and strings as sequence types, and explore their container nature, immutability, and fixed length; learn how to use tuples for data records and unpacking data.

Explore using tuples as data structures in Python, including indexing, slicing, unpacking (extended with star), immutability nuances, and practical city tuples and function returns.

Explore named tuples, their docstrings, and how to set default values with prototype and dunder defaults. Learn to create 2d vectors with origin x and y defaults using underscore replace.

Explore modules, packages, and package namespaces in Python. Learn how Python loads modules and the various import variants, including caching and reloading safety.

Explore how Python packages and modules are created and imported, including dunder init files and nested packages. Learn how Python resolves paths and dot notation to access modules.

Preserve insertion order in Python 3.6 dictionaries when iterating keys, values, and items, making them comparable to ordered dicts. Note caveats about 3.6 versus 3.7 official status.

Python 3.6 preserves the order of keyword arguments, enabling a defaulted named tuple factory that defines fields and defaults, illustrated by a vector2d with zero origins.