Advance Python : Part 1

Real-World Example: E-commerce System

class Product:
"""Encapsulates product information"""

def __init__(self, name, price, stock):
self.name = name
self._price = price # Protected from direct changes
self._stock = stock

def get_price(self):
"""Controlled access to price"""
return self._price

def apply_discount(self, percentage):
"""Business logic for discounts"""
if 0 < percentage < 100:
self._price *= (1 - percentage / 100)

def is_available(self, quantity=1):
return self._stock >= quantity

def reduce_stock(self, quantity):
if self.is_available(quantity):
self._stock -= quantity
return True
return Falseclass ShoppingCart:
"""Manages customer's shopping cart"""

def __init__(self):
self._items = {} # {product: quantity}

def add_item(self, product, quantity=1):
if product.is_available(quantity):
self._items[product] = self._items.get(product, 0) + quantity
return True
return False

def get_total(self):
return sum(product.get_price() * qty
for product, qty in self._items.items())

def checkout(self):
"""Process the order"""
for product, quantity in self._items.items():
if not product.reduce_stock(quantity):
return False, f"Insufficient stock for {product.name}"
self._items.clear()
return True, "Order placed successfully"# Usage
laptop = Product("Gaming Laptop", 1200, 5)
mouse = Product("Wireless Mouse", 25, 50)cart = ShoppingCart()
cart.add_item(laptop, 1)
cart.add_item(mouse, 2)print(f"Total: ${cart.get_total()}") # Total: $1250
success, message = cart.checkout()
print(message) # Order placed successfully

Example: The Power of Duck Typing

# We don't need to define a formal interface!
def process_payment(payment_method, amount):
"""
This function works with ANY object that has a charge() method
It doesn't care if it's CreditCard, PayPal, or Bitcoin
"""
result = payment_method.charge(amount)
return result# Different payment implementations
class CreditCard:
def __init__(self, card_number):
self.card_number = card_number

def charge(self, amount):
return f"Charged ${amount} to card ****{self.card_number[-4:]}"class PayPal:
def __init__(self, email):
self.email = email

def charge(self, amount):
return f"Charged ${amount} to PayPal account {self.email}"class Bitcoin:
def __init__(self, wallet_address):
self.wallet_address = wallet_address

def charge(self, amount):
btc_amount = amount / 50000 # Simplified conversion
return f"Charged {btc_amount:.4f} BTC to {self.wallet_address[:10]}..."# All work with the same function!
card = CreditCard("1234567890123456")
paypal = PayPal("user@example.com")
bitcoin = Bitcoin("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa")print(process_payment(card, 100))
print(process_payment(paypal, 100))
print(process_payment(bitcoin, 100))

Example: Making Objects "Iterable"

class Playlist:
"""A custom iterable container"""

def __init__(self):
self._songs = []

def add_song(self, song):
self._songs.append(song)

# Implement the iterator protocol
def __iter__(self):
return iter(self._songs)

# Implement the sized protocol
def __len__(self):
return len(self._songs)

# Implement the container protocol
def __contains__(self, song):
return song in self._songs# Now our Playlist behaves like a built-in collection!
playlist = Playlist()
playlist.add_song("Bohemian Rhapsody")
playlist.add_song("Stairway to Heaven")
playlist.add_song("Hotel California")# We can iterate over it
for song in playlist:
print(song)# We can check its length
print(f"Playlist has {len(playlist)} songs")# We can use 'in' operator
if "Bohemian Rhapsody" in playlist:
print("Found it!")

Example: File-like Objects

This is why Python's approach is powerful - any object that "quacks like a file" will work:

import iodef process_data(file_like):
"""Works with any object that has read() method"""
data = file_like.read()
return data.upper()# Real file
with open('data.txt', 'r') as f:
result = process_data(f)# String buffer (in-memory file)
string_buffer = io.StringIO("hello world")
result = process_data(string_buffer)# Network stream
import urllib.request
with urllib.request.urlopen('http://example.com') as response:
result = process_data(response)# Custom class
class DatabaseReader:
def read(self):
return "data from database"db_reader = DatabaseReader()
result = process_data(db_reader) # Works!

Example: Using Protocol for Type Safety

from typing import Protocol, runtime_checkable# Define a protocol (structural type)
@runtime_checkable
class Drawable(Protocol):
"""Anything with a draw() method is Drawable"""
def draw(self) -> str:
...def render(obj: Drawable) -> None:
"""Type checkers will verify obj has draw() method"""
print(obj.draw())# These classes don't explicitly inherit from Drawable
class Circle:
def draw(self):
return "○"class Square:
def draw(self):
return "□"class Text:
def draw(self):
return "ABC"# All work because they have draw() method!
render(Circle()) # ○
render(Square()) # □
render(Text()) # ABC# Runtime check
print(isinstance(Circle(), Drawable)) # True!

Example: Employee Hierarchy

class Employee:
"""Base class for all employees"""

def __init__(self, name, employee_id, salary):
self.name = name
self.employee_id = employee_id
self._salary = salary

def get_details(self):
return f"{self.name} (ID: {self.employee_id})"

def calculate_bonus(self):
"""Base bonus calculation - 5% of salary"""
return self._salary * 0.05class Developer(Employee):
"""Developer extends Employee with programming skills"""

def __init__(self, name, employee_id, salary, programming_languages):
# Call parent constructor
super().__init__(name, employee_id, salary)
self.programming_languages = programming_languages

def get_details(self):
"""Override to add language info"""
base_details = super().get_details()
langs = ", ".join(self.programming_languages)
return f"{base_details} | Languages: {langs}"

def code_review(self, code):
"""New method specific to developers"""
return f"{self.name} is reviewing code..."class Manager(Employee):
"""Manager extends Employee with team management"""

def __init__(self, name, employee_id, salary, team_size):
super().__init__(name, employee_id, salary)
self.team_size = team_size
self._team_members = []

def calculate_bonus(self):
"""Managers get higher bonus based on team size"""
base_bonus = super().calculate_bonus()
team_bonus = self.team_size * 1000
return base_bonus + team_bonus

def add_team_member(self, employee):
self._team_members.append(employee)

def get_details(self):
base_details = super().get_details()
return f"{base_details} | Team Size: {self.team_size}"# Usage
dev = Developer("Alice", "D001", 80000, ["Python", "JavaScript"])
mgr = Manager("Bob", "M001", 100000, 5)print(dev.get_details())
print(f"Developer bonus: ${dev.calculate_bonus()}")print(mgr.get_details())
print(f"Manager bonus: ${mgr.calculate_bonus()}")

Example: Mixins for Reusable Functionality

# Mixins provide reusable functionality
class LoggerMixin:
"""Adds logging capability to any class"""

def log(self, message):
print(f"[LOG] {self.__class__.__name__}: {message}")class TimestampMixin:
"""Adds timestamp tracking"""

def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
from datetime import datetime
self.created_at = datetime.now()

def get_age(self):
from datetime import datetime
return (datetime.now() - self.created_at).secondsclass SerializableMixin:
"""Adds JSON serialization"""

def to_dict(self):
"""Convert object to dictionary"""
return {
key: value for key, value in self.__dict__.items()
if not key.startswith('_')
}# Now combine them!
class User(LoggerMixin, TimestampMixin, SerializableMixin):
"""User class with logging, timestamps, and serialization"""

def __init__(self, username, email):
super().__init__() # Calls TimestampMixin.__init__
self.username = username
self.email = email
self.log(f"Created user: {username}")

def update_email(self, new_email):
old_email = self.email
self.email = new_email
self.log(f"Email changed from {old_email} to {new_email}")# Usage
user = User("alice", "alice@example.com")
user.update_email("alice.smith@example.com")print(f"User data: {user.to_dict()}")
print(f"User age: {user.get_age()} seconds")

Real-World Example: Game Character

# Components (composition)
class HealthComponent:
def __init__(self, max_health):
self.max_health = max_health
self.current_health = max_health

def take_damage(self, amount):
self.current_health = max(0, self.current_health - amount)

def heal(self, amount):
self.current_health = min(self.max_health, self.current_health + amount)

def is_alive(self):
return self.current_health > 0class InventoryComponent:
def __init__(self, capacity):
self.capacity = capacity
self.items = []

def add_item(self, item):
if len(self.items) < self.capacity:
self.items.append(item)
return True
return False

def remove_item(self, item):
if item in self.items:
self.items.remove(item)class CombatComponent:
def __init__(self, attack_power, defense):
self.attack_power = attack_power
self.defense = defense

def attack(self, target):
damage = self.attack_power - target.combat.defense
target.health.take_damage(max(0, damage))
return damage# Character composed of components
class Character:
def __init__(self, name, health, inventory_size, attack, defense):
self.name = name
self.health = HealthComponent(health)
self.inventory = InventoryComponent(inventory_size)
self.combat = CombatComponent(attack, defense)

def get_status(self):
return f"{self.name}: {self.health.current_health}/{self.health.max_health} HP"# Different character types with same components
warrior = Character("Conan", health=150, inventory_size=10, attack=25, defense=10)
mage = Character("Gandalf", health=80, inventory_size=15, attack=30, defense=5)# Easy to add/remove components!
warrior.inventory.add_item("Sword")
warrior.combat.attack(mage)print(warrior.get_status())
print(mage.get_status())

Example: Shape Hierarchy

import mathclass Shape:
"""Base class for all shapes"""

def area(self):
raise NotImplementedError("Subclasses must implement area()")

def perimeter(self):
raise NotImplementedError("Subclasses must implement perimeter()")class Circle(Shape):
def __init__(self, radius):
self.radius = radius

def area(self):
return math.pi * self.radius ** 2

def perimeter(self):
return 2 * math.pi * self.radiusclass 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)class Triangle(Shape):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c

def area(self):
# Heron's formula
s = (self.a + self.b + self.c) / 2
return math.sqrt(s * (s - self.a) * (s - self.b) * (s - self.c))

def perimeter(self):
return self.a + self.b + self.c# Polymorphism in action!
def print_shape_info(shape):
"""Works with ANY shape - that's polymorphism!"""
print(f"{shape.__class__.__name__}:")
print(f" Area: {shape.area():.2f}")
print(f" Perimeter: {shape.perimeter():.2f}")# Different shapes, same interface
shapes = [
Circle(5),
Rectangle(4, 6),
Triangle(3, 4, 5)
]for shape in shapes:
print_shape_info(shape)
print()

Example: Custom Vector Class

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

# Addition: v1 + v2
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)

# Subtraction: v1 - v2
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)

# Multiplication by scalar: v * 2
def __mul__(self, scalar):
return Vector(self.x * scalar, self.y * scalar)

# Equality: v1 == v2
def __eq__(self, other):
return self.x == other.x and self.y == other.y

# String representation: str(v)
def __str__(self):
return f"Vector({self.x}, {self.y})"

# Representation: repr(v)
def __repr__(self):
return f"Vector({self.x}, {self.y})"

# Length: abs(v)
def __abs__(self):
return math.sqrt(self.x**2 + self.y**2)# Now we can use natural syntax!
v1 = Vector(2, 3)
v2 = Vector(1, 1)v3 = v1 + v2 # Vector(3, 4)
v4 = v1 * 2 # Vector(4, 6)
print(v1 == v2) # False
print(abs(v1)) # 3.605...
print(v3) # Vector(3, 4)

Example: Data Serializer Interface

from abc import ABC, abstractmethod
import json
import csv
import xml.etree.ElementTree as ETclass DataSerializer(ABC):
"""Abstract base class for data serializers"""

@abstractmethod
def serialize(self, data):
"""Convert data to string format"""
pass

@abstractmethod
def deserialize(self, string):
"""Convert string back to data"""
passclass JSONSerializer(DataSerializer):
def serialize(self, data):
return json.dumps(data, indent=2)

def deserialize(self, string):
return json.loads(string)class CSVSerializer(DataSerializer):
def serialize(self, data):
"""data should be a list of dictionaries"""
if not data:
return ""

import io
output = io.StringIO()
writer = csv.DictWriter(output, fieldnames=data[0].keys())
writer.writeheader()
writer.writerows(data)
return output.getvalue()

def deserialize(self, string):
import io
reader = csv.DictReader(io.StringIO(string))
return list(reader)class XMLSerializer(DataSerializer):
def serialize(self, data):
"""data should be a dict"""
root = ET.Element("root")
for key, value in data.items():
child = ET.SubElement(root, key)
child.text = str(value)
return ET.tostring(root, encoding='unicode')

def deserialize(self, string):
root = ET.fromstring(string)
return {child.tag: child.text for child in root}# Polymorphic function works with ANY serializer
def save_and_load(serializer, data):
"""Test serialization round-trip"""
print(f"\n{serializer.__class__.__name__}:")

# Serialize
serialized = serializer.serialize(data)
print(f"Serialized:\n{serialized}")

# Deserialize
deserialized = serializer.deserialize(serialized)
print(f"Deserialized: {deserialized}")# Test with different serializers
data = {"name": "Alice", "age": 30, "city": "NYC"}serializers = [
JSONSerializer(),
XMLSerializer()
]for serializer in serializers:
save_and_load(serializer, data)

Example: Plugin Architecture

from abc import ABC, abstractmethodclass Plugin(ABC):
"""Base class for all plugins"""

@abstractmethod
def execute(self, data):
"""Process the data"""
pass

@property
@abstractmethod
def name(self):
"""Plugin name"""
passclass PluginManager:
"""Manages and executes plugins"""

def __init__(self):
self._plugins = {}

def register(self, plugin):
"""Register a new plugin"""
if not isinstance(plugin, Plugin):
raise TypeError("Must be a Plugin instance")
self._plugins[plugin.name] = plugin
print(f"Registered plugin: {plugin.name}")

def execute_all(self, data):
"""Execute all plugins in sequence"""
result = data
for plugin in self._plugins.values():
print(f"Executing {plugin.name}...")
result = plugin.execute(result)
return result# Example plugins
class UppercasePlugin(Plugin):
@property
def name(self):
return "uppercase"

def execute(self, data):
return data.upper()class RemoveSpacesPlugin(Plugin):
@property
def name(self):
return "remove_spaces"

def execute(self, data):
return data.replace(" ", "")class ReversePlugin(Plugin):
@property
def name(self):
return "reverse"

def execute(self, data):
return data[::-1]# Usage
manager = PluginManager()
manager.register(UppercasePlugin())
manager.register(RemoveSpacesPlugin())
manager.register(ReversePlugin())result = manager.execute_all("hello world")
print(f"Final result: {result}")