Python Programming: Comprehensive

Student Guide and Reference

CS 101: Introduction to Programming & Python Architecture | Course Study Notes

Computer Science & Software Engineering Academic

Student Reference Material & Comprehensive Study Guide

Student Reference Material

Chapter 1: Introduction to Python Architecture and Execution

Model

1.1 What is Python?

Python is a high-level, interpreted, dynamically typed, and multi-paradigm programming language created by
Guido van Rossum and first released in 1991. Designed with an explicit emphasis on code readability, Python
uses indentation rather than curly braces or keywords to delimit code blocks. Its standard library is vast, earning
it the reputation of being a 'batteries included' language for computer science students, web developers, data
scientists, and automation engineers.
In-Depth Student Note: When studying chapter 1: introduction to python architecture and execution model, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.
Python supports multiple programming paradigms out of the box, including procedural, object-oriented, and
functional programming. Its design philosophy prioritizes developer productivity, code clarity, and expressive
syntax that mirrors pseudocode. Because Python hides low-level memory allocation, pointer arithmetic, and
manual resource management, students can focus on core algorithmic problem-solving rather than boilerplate
mechanics.
In-Depth Student Note: When studying chapter 1: introduction to python architecture and execution model, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

Key Concept: Python code is compiled into bytecode (.pyc files) which is subsequently executed by the
Python Virtual Machine (PVM). This dual-phase execution makes Python platform-independent across
Windows, macOS, and Linux system architectures.

Key Takeaway: Always double check edge cases, error conditions, and resource cleanup when writing
production software. Clean, self-documenting code with clear variable names is always preferred over clever,
unreadable single-liners.

1.2 Python Architecture and CPython Virtual Machine

When executing a Python script (e.g., python [Link]), the standard CPython interpreter processes the source
code through three sequential pipeline stages:
In-Depth Student Note: When studying chapter 1: introduction to python architecture and execution model, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.
• Lexing and Parsing: Transforms raw source text into lexical tokens and constructs an Abstract Syntax Tree
(AST).
• Bytecode Compilation: Translates the AST into platform-independent stack-based bytecode instructions
stored in memory or cached in __pycache__ directories as .pyc files.

Computer Science & Software Engineering Page 2 of 21

Student Reference Material

• PVM Execution Loop: The Python Virtual Machine reads bytecode instructions sequentially and executes
corresponding native C instructions on the underlying CPU.

# Inspecting Python bytecode using the built-in 'dis' module

import dis

def add_numbers(a, b):

result = a + b
return result

# Disassemble the bytecode instructions

[Link](add_numbers)

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Execution Phase Input Artifact Output Artifact Key Component

Lexing & Parsing Source Code (.py) Abstract Syntax Tree (AST) Lexer / Parser Engine

Bytecode Compilation AST Bytecode (.pyc) CPython Compiler

PVM Execution Bytecode Instructions Native Memory/CPU Ops Python Virtual Machine
(PVM)

1.3 Memory Management and Global Interpreter Lock (GIL)

CPython uses automatic memory management combining reference counting with a generational cyclic
garbage collector. Furthermore, CPython features the Global Interpreter Lock (GIL), a mutex that prevents
multiple native threads from executing Python bytecodes simultaneously. While the GIL simplifies C-extension
integration and reference counting, CPU-bound multi-threaded programs often rely on the multiprocessing
module to achieve true parallel execution across multi-core processors.
In-Depth Student Note: When studying chapter 1: introduction to python architecture and execution model, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.
Understanding the CPython heap layout is vital for student performance optimization. Small integers between
-5 and 256 are pre-allocated (cached) by CPython at interpreter startup, meaning integer comparisons in this
range evaluate to the same memory identity address.
In-Depth Student Note: When studying chapter 1: introduction to python architecture and execution model, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

Chapter 1 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Computer Science & Software Engineering Page 3 of 21

Student Reference Material

Chapter 2: Variables, Memory Allocation, and Dynamic Typing

2.1 Dynamic Typing vs. Static Typing

In statically typed languages like C++ or Java, variable types are bound at compile-time and explicitly declared.
In Python, variables are named references pointing to objects stored in heap memory. Types are bound
dynamically to the objects themselves, not to the variable names. Variable assignment simply binds a name to
an object reference in the local symbol table.
In-Depth Student Note: When studying chapter 2: variables, memory allocation, and dynamic typing, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

# Dynamic typing demonstration in Python

x = 42 # x references an integer object
print(type(x)) # Output: <class 'int'>

x = 'Hello CS' # x now references a string object

print(type(x)) # Output: <class 'str'>

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Key Concept: Everything in Python is an object! Integers, floating-point numbers, functions, modules,
classes, and booleans are all instances of classes inheriting from the base 'object' type.

Key Takeaway: Always double check edge cases, error conditions, and resource cleanup when writing
production software. Clean, self-documenting code with clear variable names is always preferred over clever,
unreadable single-liners.

2.2 Mutability, Object Identity, and Garbage Collection

Python objects are categorized into two fundamental memory behavior classes:
In-Depth Student Note: When studying chapter 2: variables, memory allocation, and dynamic typing, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.
• Immutable Objects: Integers, Floats, Strings, Tuples, FrozenSets, Booleans. Modifications create brand
new objects in memory with new identity addresses.
• Mutable Objects: Lists, Dictionaries, Sets, ByteArrays, User-Defined Classes. Modifications update internal
object state in-place without altering object memory ID.

Computer Science & Software Engineering Page 4 of 21

Student Reference Material

# Tracking memory address identities using id()

a = [1, 2, 3]
print('Initial List Address:', hex(id(a)))
[Link](4)
print('Post-Append Address (Same):', hex(id(a)))

s = 'Python'
print('Initial String Address:', hex(id(s)))
s += ' 3'
print('New String Address (Different):', hex(id(s)))

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.
CPython tracks object lifespans using reference counts. When an object's reference count drops to zero, its
memory is deallocated immediately. To detect self-referential cyclic structures (e.g., list A containing list B, and
list B containing list A), Python runs a background generational garbage collector split into Generation 0,
Generation 1, and Generation 2 tiers.
In-Depth Student Note: When studying chapter 2: variables, memory allocation, and dynamic typing, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

2.3 Shallow Copying vs Deep Copying

When working with nested mutable structures, understanding the difference between shallow and deep copies
is critical to prevent accidental side effects.
In-Depth Student Note: When studying chapter 2: variables, memory allocation, and dynamic typing, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

import copy

original = [[1, 2], [3, 4]]

shallow = [Link](original)
deep = [Link](original)

# Modifying inner list affects shallow copy but not deep copy
original[0][0] = 99
print('Shallow Copy Result:', shallow) # [[99, 2], [3, 4]]
print('Deep Copy Result:', deep) # [[1, 2], [3, 4]]

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 2 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.

Computer Science & Software Engineering Page 5 of 21

Student Reference Material

• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 3: Primitive Data Types, Operators, and Expressions

3.1 Core Primitive Types Breakdown

Python features four fundamental primitive data types optimized for high-level operations:
In-Depth Student Note: When studying chapter 3: primitive data types, operators, and expressions, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

Data Type Syntax Example Description Memory Mutability

int 42, -100, 10**100 Arbitrary-precision signed Immutable

integer

float 3.14159, 1.5e-4 64-bit double-precision IEEE Immutable

754 float

bool True, False Boolean true/false (subclass Immutable

of int)

str 'hello', "world" Immutable sequence of Immutable

Unicode characters

3.2 Operators, Bitwise Ops, and Operator Precedence

Python includes standard arithmetic operators (+, -, *, /) along with floor division (//), modulo (%), exponentiation
(**), and matrix multiplication (@). Bitwise operators operate on binary integer representations.
In-Depth Student Note: When studying chapter 3: primitive data types, operators, and expressions, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

# Arithmetic, Bitwise, and Logical Operators

floor_div = 17 // 3 # Returns 5 (truncates decimal)
power = 2 ** 10 # Returns 1024 (exponentiation)
bitwise_and = 5 & 3 # 0101 & 0011 -> 0001 (1)
bitwise_shift = 1 << 4 # Left shift by 4 bits -> 16
logical_eval = (10 > 5) and (not (3 == 4)) # True

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

3.3 Type Casting and String Manipulation

Strings in Python support extensive slicing syntax string[start:stop:step], immutability guarantees, f-string
interpolation, and built-in methods like split(), join(), strip(), replace(), and find().

Computer Science & Software Engineering Page 6 of 21

Student Reference Material

In-Depth Student Note: When studying chapter 3: primitive data types, operators, and expressions, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

# String manipulation techniques

text = ' Python Programming Class '
clean_text = [Link]().upper()
words = clean_text.split()
formatted = ' -> '.join(words)
print('Formatted:', formatted)

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 3 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 4: Control Flow Structures and Comprehensions

4.1 Conditional Branching and Structural Pattern Matching

Python handles conditional logic via if, elif, and else statements. Python 3.10 introduced structural pattern
matching using match and case keywords, offering powerful destructuring and type matching.
In-Depth Student Note: When studying chapter 4: control flow structures and comprehensions, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

# Structural pattern matching example

def process_event(event):
match event:
case {'type': 'click', 'x': x, 'y': y}:
return f'Mouse click at coordinates ({x}, {y})'
case {'type': 'keypress', 'key': key}:
return f'Key pressed: {key}'
case [first, *rest]:
return f'List event starting with {first}'
case _:
return 'Unknown event format'

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Computer Science & Software Engineering Page 7 of 21

Student Reference Material

4.2 Loops, Iterators, and Comprehensions

Python loops iterate directly over iterable objects (lists, tuples, strings, dictionaries, generators).
Comprehensions provide concise, functional syntax for constructing new sequences.
In-Depth Student Note: When studying chapter 4: control flow structures and comprehensions, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

# List, Dictionary, and Set Comprehensions

numbers = list(range(1, 11))

# List comprehension with filtering

even_squares = [x**2 for x in numbers if x % 2 == 0]

# Dictionary comprehension mapping number to factorial/square

square_map = {x: x**2 for x in range(1, 6)}

# Set comprehension extracting unique word lengths

words = ['apple', 'banana', 'cherry', 'date', 'apple']
unique_lengths = {len(w) for w in words}

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 4 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 5: Modular Functions, Scope, Decorators, and

Generators

5.1 Function Definitions, Positional and Keyword Arguments

Functions are first-class objects defined using the def keyword. Parameters can include standard positional
arguments, default values, variable-length positional arguments (*args), keyword-only arguments, and
variable-length keyword arguments (**kwargs).
In-Depth Student Note: When studying chapter 5: modular functions, scope, decorators, and generators, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

Computer Science & Software Engineering Page 8 of 21

Student Reference Material

def build_user_profile(username, email, *roles, is_active=True, **metadata):

profile = {
'username': username,
'email': email,
'roles': list(roles),
'status': is_active,
'meta': metadata
}
return profile

user = build_user_profile('alice_dev', 'alice@[Link]', 'admin', 'editor', department='CS')

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

5.2 Variable Scope (The LEGB Rule)

Python resolves variable identifiers sequentially through four scope tiers:
In-Depth Student Note: When studying chapter 5: modular functions, scope, decorators, and generators, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.
• L (Local): Variables declared directly inside the current function body.
• E (Enclosing): Variables in enclosing outer function scopes (for nested functions/closures).
• G (Global): Module-level variables defined at the top of the .py script.
• B (Built-in): Built-in module functions and constants (len, range, ValueError).

5.3 First-Class Functions, Decorators, and Generators

Because functions are first-class objects, they can be passed as arguments, returned from other functions, and
stored in data structures. Decorators wrap functions to extend functionality. Generators yield items lazily,
minimizing memory usage.
In-Depth Student Note: When studying chapter 5: modular functions, scope, decorators, and generators, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

Computer Science & Software Engineering Page 9 of 21

Student Reference Material

# Custom execution timing decorator

import time
from functools import wraps

def performance_timer(func):
@wraps(func)
def wrapper(*args, **kwargs):
start_time = time.perf_counter()
result = func(*args, **kwargs)
elapsed = time.perf_counter() - start_time
print(f'[PERF] Function {func.__name__} executed in {elapsed:.6f}s')
return result
return wrapper

@performance_timer
def calculate_sum(n):
return sum(range(n))

# Generator function producing infinite Fibonacci sequence

def fibonacci_generator():
a, b = 0, 1
while True:
yield a
a, b = b, a + b

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 5 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 6: Core Built-in Data Structures

6.1 Lists, Tuples, Dictionaries, and Sets Overview

Structure Literal Syntax Ordering Mutability Duplicates Allowed?

List [1, 2, 'a'] Ordered (Sequence) Mutable Yes

Tuple (1, 2, 'a') Ordered (Sequence) Immutable Yes

Dictionary {'key': 'value'} Ordered (Insertion Mutable Keys: No, Values:

order 3.7+) Yes

Set {1, 2, 3} Unordered (Hash Mutable No

table)

Computer Science & Software Engineering Page 10 of 21

Student Reference Material

# Essential data structure manipulations

# List Slicing [start:stop:step]
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
reversed_even = nums[8:0:-2]

# Safe dictionary retrieval and default values

config = {'theme': 'dark', 'font_size': 14}
language = [Link]('language', 'English') # Returns 'English' fallback

# Set mathematical operations

set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}

intersection = set_a & set_b # {4, 5}

union = set_a | set_b # {1, 2, 3, 4, 5, 6, 7, 8}
difference = set_a - set_b # {1, 2, 3}

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 6 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 7: Advanced Collections Module

7.1 Defaultdict, Counter, and Deque Containers

The collections standard library module provides high-performance container types beyond primitive lists and
dictionaries.
In-Depth Student Note: When studying chapter 7: advanced collections module, it is essential to trace how data
flows through system memory and CPU registers. Real-world applications require careful consideration of both
computational time complexity and space overhead. Practicing these concepts with hands-on code examples
ensures a deep mastery of the underlying engineering principles.

Computer Science & Software Engineering Page 11 of 21

Student Reference Material

from collections import defaultdict, Counter, deque, namedtuple

# Defaultdict automatically initializes missing keys

graph = defaultdict(list)
graph['A'].append('B')

# Counter calculates frequency counts

word_counts = Counter(['apple', 'banana', 'apple', 'cherry'])
print('Most Common:', word_counts.most_common(1))

# Deque provides O(1) double-ended operations

q = deque([1, 2, 3])
[Link](0)
[Link]()

# Namedtuple provides readable tuple records

Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(f'Point at ({p.x}, {p.y})')

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 7 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 8: Object-Oriented Programming (OOP) Fundamentals

8.1 Classes, Instance Methods, and Special (Dunder) Methods

Classes combine state and behavior into encapsulated blueprints. Special double-underscore ('dunder')
methods allow custom objects to interact seamlessly with Python built-ins like len(), str(), +, and ==.
In-Depth Student Note: When studying chapter 8: object-oriented programming (oop) fundamentals, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

Computer Science & Software Engineering Page 12 of 21

Student Reference Material

class Vector2D:
def __init__(self, x: float, y: float):
self.x = x
self.y = y

def __add__(self, other):

if not isinstance(other, Vector2D):
return NotImplemented
return Vector2D(self.x + other.x, self.y + other.y)

def __eq__(self, other):

if not isinstance(other, Vector2D):
return False
return self.x == other.x and self.y == other.y

def __repr__(self):
return f'Vector2D(x={self.x}, y={self.y})'

# Usage of Vector2D
v1 = Vector2D(3.0, 4.0)
v2 = Vector2D(1.0, 2.0)
v3 = v1 + v2
print(v3) # Vector2D(x=4.0, y=6.0)

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

8.2 Class Methods, Static Methods, and Property Decorators

@classmethod receives the class reference (cls) as its first argument, useful for alternative constructor
factories. @staticmethod functions independently of class instance state. @property creates clean getter/setter
interfaces.
In-Depth Student Note: When studying chapter 8: object-oriented programming (oop) fundamentals, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

class Temperature:
def __init__(self, celsius=0.0):
self._celsius = celsius

@property
def fahrenheit(self):
return (self._celsius * 9/5) + 32

@[Link]
def fahrenheit(self, value):
self._celsius = (value - 32) * 5/9

@classmethod
def from_fahrenheit(cls, f_val):
return cls((f_val - 32) * 5/9)

Computer Science & Software Engineering Page 13 of 21

Student Reference Material

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 8 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 9: Advanced OOP Mechanics and Metaclasses

9.1 Method Resolution Order (MRO) and Abstract Classes

Python supports multiple inheritance. CPython calculates MRO using the C3 Linearization algorithm. Abstract
Base Classes (ABCs) enforce interface contracts.
In-Depth Student Note: When studying chapter 9: advanced oop mechanics and metaclasses, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

from abc import ABC, abstractmethod

class DataStore(ABC):
@abstractmethod
def save(self, key: str, data: dict) -> bool:
pass

class RedisStore(DataStore):
def save(self, key: str, data: dict) -> bool:
print(f'Saving key {key} to Redis DB')
return True

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 9 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 10: Input/Output, Context Managers, and Files

10.1 Safe File Handling and Context Managers

The with statement uses the Context Manager protocol (__enter__ and __exit__) to ensure resources like open
file descriptors are closed safely, even when runtime exceptions occur.

Computer Science & Software Engineering Page 14 of 21

Student Reference Material

In-Depth Student Note: When studying chapter 10: input/output, context managers, and files, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

# Safe text file reading and writing

file_path = '[Link]'
with open(file_path, 'w', encoding='utf-8') as f:
[Link]('Line 1: Python Data Stream\nLine 2: Class Study Notes')

with open(file_path, 'r', encoding='utf-8') as f:

for line_num, line in enumerate(f, 1):
print(f'Line {line_num}: {[Link]()}')

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 10 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 11: Serialization with JSON, CSV, and Pathlib

11.1 Working with JSON, CSV, and Object-Oriented Paths

Python native modules simplify file parsing and structural serialization.
In-Depth Student Note: When studying chapter 11: serialization with json, csv, and pathlib, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

import json
import csv
from pathlib import Path

# Pathlib object-oriented path manipulation

base_dir = Path('./student_data')
base_dir.mkdir(exist_ok=True)
json_file = base_dir / '[Link]'

# JSON serialization
data = {'course': 'CS101', 'students': ['Alice', 'Bob']}
json_file.write_text([Link](data, indent=2))

# Reading JSON back

loaded_data = [Link](json_file.read_text())
print('Loaded:', loaded_data)

Computer Science & Software Engineering Page 15 of 21

Student Reference Material

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 11 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 12: Exception Handling and Custom Exceptions

12.1 Exception Handling Architecture

Exceptions are handled using try, except, else, and finally blocks. Custom exception classes inherit from the
built-in Exception base class.
In-Depth Student Note: When studying chapter 12: exception handling and custom exceptions, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

class InsufficientBalanceError(Exception):
def __init__(self, amount, balance):
super().__init__(f'Cannot withdraw ${amount}. Current balance is ${balance}.')

def withdraw_funds(balance, amount):

if amount > balance:
raise InsufficientBalanceError(amount, balance)
return balance - amount

try:
new_balance = withdraw_funds(50, 100)
except InsufficientBalanceError as err:
print(f'[ERROR]: {err}')
else:
print(f'Transaction successful. New balance: ${new_balance}')
finally:
print('Audit transaction completed.')

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 12 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Computer Science & Software Engineering Page 16 of 21

Student Reference Material

Chapter 13: Functional Programming: Itertools and Functools

13.1 High-Performance Functional Iterators

Python supports functional concepts via map(), filter(), reduce(), and standard library modules itertools and
functools.
In-Depth Student Note: When studying chapter 13: functional programming: itertools and functools, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

import itertools
import functools

# Infinite counting and combinatorics

counter = [Link](start=10, step=2)
combos = list([Link](['A', 'B', 'C'], 2))
print('Combinations:', combos)

# Functional reduce for factorial computation

product = [Link](lambda x, y: x * y, range(1, 6))
print('Factorial 5!:', product)

# Memoization decorator with lru_cache

@functools.lru_cache(maxsize=128)
def fib_memo(n):
if n < 2: return n
return fib_memo(n-1) + fib_memo(n-2)

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 13 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 14: Concurrency: Multithreading, Multiprocessing, and

Asyncio

14.1 Concurrency Models in Python

Understanding when to use Multithreading (I/O-bound tasks), Multiprocessing (CPU-bound parallel tasks), or
Asyncio (asynchronous event loop I/O).
In-Depth Student Note: When studying chapter 14: concurrency: multithreading, multiprocessing, and asyncio,
it is essential to trace how data flows through system memory and CPU registers. Real-world applications
require careful consideration of both computational time complexity and space overhead. Practicing these

Computer Science & Software Engineering Page 17 of 21

Student Reference Material

concepts with hands-on code examples ensures a deep mastery of the underlying engineering principles.

# Asyncio Asynchronous Event Loop Example

import asyncio

async def fetch_data_task(task_id, delay):

print(f'Task {task_id} starting...')
await [Link](delay)
print(f'Task {task_id} completed!')
return f'Result {task_id}'

async def main_async():

results = await [Link](
fetch_data_task(1, 1.0),
fetch_data_task(2, 0.5)
)
print('All results:', results)

# Run event loop

[Link](main_async())

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 14 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 15: Unit Testing with PyTest and Unittest

15.1 Test-Driven Development (TDD)

Unit testing verifies code correctness automatically. Python provides the unittest module in standard library and
supports third-party frameworks like PyTest.
In-Depth Student Note: When studying chapter 15: unit testing with pytest and unittest, it is essential to trace
how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

# PyTest unit test function

def test_vector_addition():
v1 = Vector2D(1.0, 2.0)
v2 = Vector2D(3.0, 4.0)
assert v1 + v2 == Vector2D(4.0, 6.0)

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each

Computer Science & Software Engineering Page 18 of 21

Student Reference Material

line with a debugger to observe variable state changes in real time.

Chapter 15 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 16: PEP 8 Conventions, Type Hinting, and Tooling

16.1 Professional Python Tooling and Type Annotations

Type hints enhance code clarity and allow static tools like mypy to catch potential type mismatches before
execution.
In-Depth Student Note: When studying chapter 16: pep 8 conventions, type hinting, and tooling, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

from typing import List, Dict, Optional, Union

def calculate_averages(grades: Dict[str, List[float]]) -> Dict[str, float]:

averages = {}
for student, scores in [Link]():
averages[student] = sum(scores) / len(scores) if scores else 0.0
return averages

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 16 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 17: Regular Expressions (Regex) and Text Processing

17.1 Pattern Matching with the 're' Module

Regular expressions allow powerful search, extraction, and replacement operations on string payloads.
In-Depth Student Note: When studying chapter 17: regular expressions (regex) and text processing, it is
essential to trace how data flows through system memory and CPU registers. Real-world applications require
careful consideration of both computational time complexity and space overhead. Practicing these concepts
with hands-on code examples ensures a deep mastery of the underlying engineering principles.

Computer Science & Software Engineering Page 19 of 21

Student Reference Material

import re

text = 'Contact student support at support@[Link] or admin@[Link]'

emails = [Link](r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', text)
print('Extracted Emails:', emails)

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 17 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Chapter 18: Student Practice Exercises and Solutions

18.1 Practice Questions with Walkthroughs

Q1: Write a function to check if two strings are anagrams of each other.
In-Depth Student Note: When studying chapter 18: student practice exercises and solutions, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

# Solution to Q1 using [Link]

from collections import Counter

def is_anagram(s1: str, s2: str) -> bool:

clean_s1 = [Link]().replace(' ', '')
clean_s2 = [Link]().replace(' ', '')
return Counter(clean_s1) == Counter(clean_s2)

print(is_anagram('Listen', 'Silent')) # True

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.
Q2: Implement an LRU (Least Recently Used) cache decorator or class using [Link].
In-Depth Student Note: When studying chapter 18: student practice exercises and solutions, it is essential to
trace how data flows through system memory and CPU registers. Real-world applications require careful
consideration of both computational time complexity and space overhead. Practicing these concepts with
hands-on code examples ensures a deep mastery of the underlying engineering principles.

Computer Science & Software Engineering Page 20 of 21

Student Reference Material

# Solution to Q2
from collections import OrderedDict

class LRUCache:
def __init__(self, capacity: int):
[Link] = capacity
[Link] = OrderedDict()

def get(self, key: int) -> int:

if key not in [Link]:
return -1
[Link].move_to_end(key)
return [Link][key]

def put(self, key: int, value: int) -> None:

if key in [Link]:
[Link].move_to_end(key)
[Link][key] = value
if len([Link]) > [Link]:
[Link](last=False)

Code Walkthrough & Execution Step: Notice how the code snippet above encapsulates the core logic cleanly.
In class assignments, try running this snippet in your local Python environment or IDE, stepping through each
line with a debugger to observe variable state changes in real time.

Chapter 18 Summary & Review Checklist

• Review core theoretical concepts and definitions covered in this chapter.
• Practice executing and modifying the code examples locally.
• Complete end-of-unit review exercises to reinforce problem-solving skills.

Computer Science & Software Engineering Page 21 of 21