Python Programming I

Module 1: Core Fundamentals & Memory Architecture

Variables and Memory

Variables in Python are dynamically typed and act merely as references to objects in memory, rather than containers of data types. Everything in Python is an object, meaning an assignment like $x = 42$ binds the identifier $x$ to an integer object with the value $42$ . When executing code, assignments evaluate from right to left, e.g., $x = a + b.$

Built-in Data Types & Mathematical Representations

Python includes primary types such as boolean, integer, float, and string.

Integer: Arbitrary size variable-length objects representing integral numbers with absolute precision.
Float: Represents floating-point numbers using an approximated bit pattern format. The stored value is evaluated via the formula:

$value = significand \times base^{exponent}$

where the $significand$ and $exponent$ are integers extracted from the memory bit pattern, and the $base$ is fixed.
Boolean: Subtype of integer evaluated as $0$ (False) or $1$ (True).
String: Characters mapped to bit patterns (e.g., UTF-8).

Module 2: Control Flow & Logic

Conditions and Branching

Python evaluates boolean expressions using short-circuit logic for $or$ and $and$ operators. Truth value testing natively interprets empty sequences, $0$ , and None as False, while all other objects default to True. Branching relies on if, elif, and else statements parsed top-to-bottom, executing exclusively one matched block.

Loops

While loops: Execute continuously until a given boolean condition is evaluated as False.
For loops: Iterate sequentially over iterables (like strings or lists).
Loop behavior can be interrupted utilizing $break$ (exits the loop entirely) or $continue$ (forces the next iteration).

Module 3: Data Structures and Mutability

Core Collections

Lists: Mutable sequences defining an ordered collection of mixed types.
Tuples: Immutable sequences.
Sets: Unordered collections of unique, hashable elements supporting mathematical operations like union and intersection.
Dictionaries: Mutable, ordered mapping structures comprised of key-value pairs where keys must be hashable.

Indexing and Slicing

Sequence types allow range selection through a specific slicing syntax yielding a new view or copy:

$sequence[start:end:step]$

where indices start at $0$ , $start$ is inclusive, $end$ is exclusive, and negative integers evaluate backwards.

The Alias Effect

When assigning a mutable object (like a list) to multiple variables, $x = y$ , both variables reference the identical memory object. Changes made through $x$ explicitly alter the object, rendering the mutation visible when accessing $y$ .

Module 4: Functions & Program Structure

Arguments and Parameters

Functions provide modularization to eliminate code duplication. They ingest data via formal parameters (definition) and actual parameters/arguments (invocation). Variable-length arguments are collected in tuples ( $*args$ ) and dictionaries ( $**kwargs$ ).

Namespaces and Scope

Variables are resolved hierarchically across nested dictionaries mapping names to objects. Python searches scopes sequentially:

Local namespace
Enclosing namespace
Global namespace
Built-in namespace

Recursion & Generators

A recursive function continuously invokes itself to solve decreasingly complex sub-problems until triggering a base case. For example, a power function computing $x^y$ breaks down into the mathematical subtask:

$x^y = x \cdot x^{y-1}$

and terminates when reaching the base recursion anchor:

$x^1 = x$

where $x$ is returned directly.
Generators return elements lazily to conserve memory using the yield keyword, suspending their state between iterations.

Module 5: Exceptions & Debugging

Exceptions govern error handling. Python evaluates try, except, else, and finally blocks.

except: Intercepts specific exception types passed upwards via the calling hierarchy.
else: Executes exclusively if no exception is raised.
finally: Executes unconditionally for cleanup routines.
Breakpoints and the call stack allow developers to pause execution and analyze hierarchical variable states across namespaces.

Module 6: Object-Oriented Programming (OOP)

Classes and Objects

Classes operate as architectural blueprints generating uniquely instanced objects. Objects combine state/data ( $attributes$ ) and behavioral functions ( $methods$ ). The special instantiation method __init__(self) initializes instance-specific attributes natively bound to the calling object.

Inheritance & Advanced Object Mapping

Subclasses extend base classes, explicitly inheriting all parent attributes and methods. All Python classes derive implicitly from the root object class.
If an invoked method requires resolution, Python determines the exact execution path through the Method Resolution Order (MRO) via a bottom-up hierarchy search.

Python supports syntactic operator overloading by overriding inherited dual-underscore "dunder" methods natively implemented within the object class. E.g., altering the $==$ operator's behavior demands overriding:

$\_\_eq\_\_(self, other)$

Module 7: Libraries and Ecosystem

File I/O & Modules

The open() function handles disk streams via relative or absolute paths, configured for binary (rb, wb) or string/text environments (r, w, a). The with statement serves as a context manager ensuring resource closure. Code structures are grouped logically within isolated files (modules) and hierarchical directories containing an __init__.py file (packages).

NumPy and Fast Computations

NumPy bypasses slow Python looping architectures by processing contiguous, uniformly-typed data blocks via multidimensional arrays implemented in C. For an $n$ -dimensional array flattened into a fast 1D array using row-major order, the memory offset address of an element located at row $r$ and column $c$ , given $nr$ representing the total number of elements per row, is determined mathematically via:

$nr \cdot r + c$