Python Memory Management Architecture

Python manages memory through three primary mechanisms: Reference Counting, Mark-and-Sweep, and Generational Garbage Collection.

Reference Counting

This is the primary mechanism. Every object tracks how many references point to it. When a reference is created, the count increments; when deleted, it decrements. Once the count hits zero, memory is immediately reclaimed. This provides real-time deallocation and a deterministic object lifecycle but fails to handle circular references.

Mark-and-Sweep

To resolve circular references (where objects reference each other but are otherwise unreachable), Python uses Mark-and-Sweep. It targets container objects like lists and dictionaries. The algorithm traverses the object graph, 'marking' reachable objects and 'sweeping' those that are unreachable into deallocation.

Generational Garbage Collection

Based on the observation that most objects die young, Python categorizes objects into three generations (0, 1, and 2). New objects start in Generation 0. If they survive a GC cycle, they move to older generations. Frequency of scanning decreases for older generations, optimizing performance by focusing on short-lived objects.

Data Copying: Shallow vs. Deep

• Shallow Copy (copy.copy): Creates a new collection object but populates it with references to the items found in the original. Changes to nested mutable objects affect both.
• Deep Copy (copy.deepcopy): Recursively creates new instances of all objects found within the original, resulting in a completely independent clone.

Closures

A closure occurs when a nested function references a variable from its outer (enclosing) scope. Even after the outer function finishes execution, the inner function retains access to that scope.

Concurrency Models

• Process: The smallest unit of resource allocation by the OS. Each process has its own memory space.
• Thread: The smallest unit of execution/scheduling. Threads within a process share the same memory.
• Coroutine: User-managed lightweight execution units. They utilize cooperative multitasking, allowing the developer to control when execution switches.

Inter-Process Communication (IPC)

1. Pipes: Half-duplex communication between related processes.
2. Message Queues: Linked lists of messages stored in the kernel.
3. Semaphores: Counters used to synchronize access to shared resources.
4. Shared Memory: A memory segment accessible by multiple processes; the fastest IPC method.
5. Sockets: Used for communication across different machines over a network.

Execution Paradigms

• Concurrency: Multiple tasks making progress over time (interleaving on one CPU).
• Parallelism: Multiple tasks running at the exact same instant (multi-core).
• Synchronous: The caller waits for the operation to complete.
• Asynchronous: The caller continues execution and is notified when the operation completes.
• Blocking: The execution flow is halted until an I/O event occurs.
• Non-blocking: The function returns immediately, even if data isn't ready.

I/O Multiplexing: Select vs. Epoll

• select: Polls all file descriptors to check for readiness. Complexity is O(n), and it has a hard limit on the number of descriptors.
• epoll: Uses a callback mechanism in the kernel. It only notifies the application about active descriptors, making it O(1) and highly scalable for high-concurrency environments like Nginx.

Database Integrity (ACID)

• Atomicity: Transactions are "all or nothing."
• Consistency: The database moves from one valid state to another.
• Isolation: Concurrent transactions do not interfere with eachother.
• Durability: Once committed, data remains saved even during system failure.

Functional Tools and Protocols

Context Managers

Require the implementation of __enter__ and __exit__. Used for resource management (e.g., file handling).

Decorators

Wrappers that modify the behavior of a function or class without changing its source code. Common for logging, auth, and caching.

Iterators and Generators

• Iterators: Objects implementing __iter__ and __next__.
• Generators: Functions using the yield keyword. They maintain state between executions and are memory-efficient because they produce items one at a time.

def sequence_generator(limit):
    current = 0
    while current < limit:
        yield current
        current += 1

# Usage
gen = sequence_generator(5)
for val in gen:
    print(val)

Network Communication

• HTTP vs. HTTPS: HTTPS adds an SSL/TLS layer for encryption and identity verification. HTTP uses port 80; HTTPS uses 443.
• GET vs. POST: GET retrieves data via URL parameters (limited size, less secure). POST sends data in the request body (larger payloads, more secure for sensitive data).
• TCP vs. UDP: TCP is connection-oriented and reliable (3-way handshake). UDP is connectionless, faster, but allows packet loss.

Framework Architectures: MVC and MVT

• MVC (Model-View-Controller): Separates data logic, UI logic, and input control.
• MVT (Model-View-Template): Used by Django. The 'View' in MVT acts like the 'Controller' in MVC, while the 'Template' handles the presentation layer.

Key Differences: Python 2 vs. Python 3

1. Print: print is a statement in 2.x, a function print() in 3.x.
2. Division: In 3.x, / performs float division by default.
3. Strings: 3.x uses Unicode (UTF-8) for strings by default; 2.x uses ASCII.
4. Ranges: xrange in 2.x is replaced by range in 3.x (both return iterators).
5. Input: raw_input() in 2.x is renamed to input() in 3.x.

Data Structures and Algorithms

Linked Lists

Non-contiguous storage where elements (nodes) point to the next.

• Single: Forward pointers only.
• Double: Pointers to both next and previous nodes.
• Circular: The last node points back to the first.

Core Machine Learning Algorithms

• Naive Bayes: Classification based on probabilistic independence.
• Decision Trees: Model uses a tree-like graph of decisions.
• Random Forest: An ensemble of decision trees to improve accuracy.
• Logistic Regression: Used for binary classification by mapping output to a probability between 0 and 1 via the Sigmoid function.