Built-in Collections

Python's foundational data structures provide efficient storage and retrieval mechanisms for different use cases.

Type	Syntax	Features
List	[]	Ordered, Mutable, Allows duplicates
Tuple	()	Ordered, Immutable, Hashable
Set	{}	Unique, Unordered, Fast lookup
Dict	{k:v}	Key-value pairs, O(1) access

Collections Module

High-performance container datatypes that extend Python's built-in collections:

namedtuple()

Create tuple subclasses with named fields for better code readability:

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(p.x, p.y)  # 11 22

deque

Double-ended queue with O(1) appends/pops from both ends:

from collections import deque

d = deque([1, 2, 3])
d.appendleft(0)
d.append(4)
# deque([0, 1, 2, 3, 4])

Counter

Count hashable objects efficiently:

from collections import Counter

words = ['red', 'blue', 'red', 'green', 'blue', 'blue']
counter = Counter(words)
print(counter.most_common(2))
# [('blue', 3), ('red', 2)]

defaultdict

Dictionary with default values for missing keys:

from collections import defaultdict

dd = defaultdict(list)
dd['colors'].append('red')
# No KeyError, creates empty list

Conditional Statements

Python's control flow structures enable decision-making in your code:

# Standard if-elif-else
score = 85

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
else:
    grade = 'F'

# Ternary operator
status = 'Pass' if score >= 60 else 'Fail'

match status_code:
    case 200:
        print("Success")
    case 404:
        print("Not Found")
    case _:
        print("Other status")

Loops & Iteration

For Loops

# Iterate over sequence
for item in [1, 2, 3]:
    print(item)

# With index using enumerate
for idx, value in enumerate(['a', 'b', 'c']):
    print(f"{idx}: {value}")

# Iterate over dictionary
for key, value in my_dict.items():
    print(f"{key} = {value}")

While Loops

count = 0
while count < 5:
    print(count)
    count += 1

Loop Control

• break - Exit loop immediately
• continue - Skip to next iteration
• else - Execute if loop completes normally

for num in range(10):
    if num == 3:
        continue  # Skip 3
    if num == 7:
        break  # Stop at 7
    print(num)
else:
    print("Loop finished")

Exception Handling

Gracefully handle errors and edge cases:

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
except Exception as e:
    print(f"Unexpected: {e}")
else:
    print("No errors")
finally:
    print("Always runs")

Custom Exceptions

class ValidationError(Exception):
    pass

def validate_age(age):
    if age < 0:
        raise ValidationError("Age cannot be negative")

The Anatomy of a Class

Classes are blueprints for creating objects with shared attributes and behaviors:

class ProjectManager:
    # Class variable (shared across instances)
    company = "TechCorp"
    
    def __init__(self, name, budget):
        # Instance variables
        self.name = name
        self.__budget = budget  # Private attribute
        self._projects = []  # Protected by convention
    
    # Property decorator for controlled access
    @property
    def budget(self):
        return self.__budget
    
    @budget.setter
    def budget(self, value):
        if value < 0:
            raise ValueError("Budget cannot be negative")
        self.__budget = value
    
    # Instance method
    def add_project(self, project):
        self._projects.append(project)
        return f"Added {project}"
    
    # Class method
    @classmethod
    def from_config(cls, config_dict):
        return cls(config_dict['name'], config_dict['budget'])
    
    # Static method
    @staticmethod
    def calculate_tax(amount):
        return amount * 0.15

Usage Example:

pm = ProjectManager("Alice", 50000)
print(pm.budget)  # 50000
pm.budget = 60000  # Using setter
pm.add_project("Website Redesign")

Access Modifiers & Encapsulation

Naming	Convention	Access Level
public_attr	No prefix	Fully accessible
_protected	Single underscore	Internal use (by convention)
__private	Double underscore	Name mangled (pseudo-private)

Data Classes (Python 3.7+)

Simplified class creation for data storage:

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    department: str
    salary: float
    active: bool = True
    
# Auto-generates __init__, __repr__, __eq__, etc.
emp = Employee("Bob", "Engineering", 75000)

Single Inheritance

Child classes inherit attributes and methods from parent classes:

class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
    
    def start(self):
        return f"{self.brand} {self.model} is starting"

class ElectricCar(Vehicle):
    def __init__(self, brand, model, battery_capacity):
        super().__init__(brand, model)
        self.battery_capacity = battery_capacity
    
    def charge(self):
        return f"Charging {self.battery_capacity}kWh battery"

tesla = ElectricCar("Tesla", "Model 3", 75)
print(tesla.start())  # Inherited method
print(tesla.charge())  # New method

Multiple Inheritance & MRO

Python supports multiple inheritance using the Method Resolution Order (MRO):

class Flyable:
    def fly(self):
        return "Flying in the sky"

class Swimmable:
    def swim(self):
        return "Swimming in water"

class Duck(Flyable, Swimmable):
    def quack(self):
        return "Quack!"

duck = Duck()
print(duck.fly())
print(duck.swim())
print(Duck.__mro__)  # View resolution order

Super() Deep Dive

The super() function is used to call methods from parent classes without naming them explicitly:

class Parent:
    def __init__(self, name):
        self.name = name
        print(f"Parent init: {name}")

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # Call parent __init__
        self.age = age
        print(f"Child init: {age}")

Cooperative Multiple Inheritance

class A:
    def method(self):
        print("A")
        super().method()  # Cooperative

class B:
    def method(self):
        print("B")

class C(A, B):
    def method(self):
        print("C")
        super().method()

c = C()
c.method()  # Output: C, A, B (follows MRO)

Abstract Base Classes

Define interfaces that subclasses must implement:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

# Cannot instantiate Shape directly
# shape = Shape()  # TypeError
rect = Rectangle(5, 3)

OS Module

Interface with the operating system for file and directory operations:

import os

# Directory operations
current_dir = os.getcwd()  # Get current directory
os.chdir('/path/to/dir')  # Change directory
os.mkdir('new_folder')  # Create directory
os.makedirs('path/to/nested/dir', exist_ok=True)

# File operations
os.remove('file.txt')  # Delete file
os.rename('old.txt', 'new.txt')  # Rename

# Path operations
print(os.path.exists('file.txt'))  # Check existence
print(os.path.isfile('data.csv'))  # Is it a file?
print(os.path.isdir('folder'))  # Is it a directory?
print(os.path.join('dir', 'file.txt'))  # Join paths

# Environment variables
home = os.environ.get('HOME')
os.environ['CUSTOM_VAR'] = 'value'

Listing Directory Contents

# List all files and folders
items = os.listdir('.')

# Walk directory tree
for root, dirs, files in os.walk('.'):
    for file in files:
        full_path = os.path.join(root, file)
        print(full_path)

Sys Module

System-specific parameters and functions:

import sys

# Python version info
print(sys.version)  # Full version string
print(sys.version_info)  # Version tuple

# Command line arguments
print(sys.argv)  # List of arguments
# Example: python script.py arg1 arg2
# sys.argv = ['script.py', 'arg1', 'arg2']

# Module search path
print(sys.path)  # List of import paths
sys.path.append('/custom/path')

# Standard streams
sys.stdout.write('Output\n')
sys.stderr.write('Error message\n')

# Exit program
sys.exit(0)  # Exit code 0 = success

Platform Information

print(sys.platform)  # 'linux', 'darwin', 'win32'
print(sys.maxsize)  # Largest integer
print(sys.executable)  # Python interpreter path