Python Full Stack Web Developer Course

Practical Examples: Real-World Module Usage

Example 1: Building a Weather App

Let's see how modules can be used in a simple weather application:

# File: weather_app/weather_service.py

import requests
import json
from datetime import datetime

API_KEY = "your_api_key_here"
BASE_URL = "https://api.openweathermap.org/data/2.5/weather"

def get_weather(city_name):
    """Get current weather for a city."""
    params = {
        "q": city_name,
        "appid": API_KEY,
        "units": "metric"
    }
    
    response = requests.get(BASE_URL, params=params)
    
    if response.status_code == 200:
        return response.json()
    else:
        return None

def format_weather_data(weather_data):
    """Format the weather data for display."""
    if weather_data is None:
        return "Unable to retrieve weather data."
    
    city = weather_data["name"]
    country = weather_data["sys"]["country"]
    temp = weather_data["main"]["temp"]
    feels_like = weather_data["main"]["feels_like"]
    description = weather_data["weather"][0]["description"]
    humidity = weather_data["main"]["humidity"]
    wind_speed = weather_data["wind"]["speed"]
    timestamp = weather_data["dt"]
    
    # Convert timestamp to readable date/time
    date_time = datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
    
    formatted_data = f"""
Weather for {city}, {country} at {date_time}:
Temperature: {temp}°C (Feels like: {feels_like}°C)
Conditions: {description.capitalize()}
Humidity: {humidity}%
Wind Speed: {wind_speed} m/s
"""
    return formatted_data

Now we can use this module in our main application:

# File: weather_app/app.py

from weather_service import get_weather, format_weather_data

def main():
    print("Welcome to the Weather App!")
    city = input("Enter a city name: ")
    
    weather_data = get_weather(city)
    formatted_weather = format_weather_data(weather_data)
    
    print(formatted_weather)

if __name__ == "__main__":
    main()

Example 2: Data Processing Application

Here's how you might use modules in a data processing application:

# File: data_processor/data_loader.py

import csv
import json
import os

def load_csv(file_path):
    """Load data from a CSV file into a list of dictionaries."""
    if not os.path.exists(file_path):
        raise FileNotFoundError(f"File not found: {file_path}")
    
    data = []
    with open(file_path, 'r', newline='', encoding='utf-8') as csvfile:
        reader = csv.DictReader(csvfile)
        for row in reader:
            data.append(row)
    
    return data

def load_json(file_path):
    """Load data from a JSON file."""
    if not os.path.exists(file_path):
        raise FileNotFoundError(f"File not found: {file_path}")
    
    with open(file_path, 'r', encoding='utf-8') as jsonfile:
        data = json.load(jsonfile)
    
    return data

def save_csv(data, file_path, fieldnames=None):
    """Save a list of dictionaries to a CSV file."""
    if not fieldnames and data:
        fieldnames = data[0].keys()
    
    with open(file_path, 'w', newline='', encoding='utf-8') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(data)
    
    return True

def save_json(data, file_path):
    """Save data to a JSON file."""
    with open(file_path, 'w', encoding='utf-8') as jsonfile:
        json.dump(data, jsonfile, indent=4)
    
    return True

# File: data_processor/data_analyzer.py

def calculate_stats(data, numeric_field):
    """Calculate basic statistics for a numeric field in the data."""
    values = []
    for item in data:
        try:
            values.append(float(item[numeric_field]))
        except (ValueError, KeyError):
            continue
    
    if not values:
        return {
            "count": 0,
            "min": None,
            "max": None,
            "avg": None,
            "sum": None
        }
    
    return {
        "count": len(values),
        "min": min(values),
        "max": max(values),
        "avg": sum(values) / len(values),
        "sum": sum(values)
    }

def filter_data(data, field, value, comparison="equals"):
    """Filter data based on criteria."""
    result = []
    
    for item in data:
        if field not in item:
            continue
            
        if comparison == "equals" and item[field] == value:
            result.append(item)
        elif comparison == "contains" and value in item[field]:
            result.append(item)
        elif comparison == "greater_than" and float(item[field]) > float(value):
            result.append(item)
        elif comparison == "less_than" and float(item[field]) < float(value):
            result.append(item)
    
    return result

# File: data_processor/app.py

from data_loader import load_csv, save_json
from data_analyzer import calculate_stats, filter_data

def main():
    # Load sales data from CSV
    try:
        sales_data = load_csv("sales.csv")
        print(f"Loaded {len(sales_data)} sales records")
        
        # Calculate statistics on the amount field
        amount_stats = calculate_stats(sales_data, "amount")
        print(f"Sales Statistics:")
        print(f"  Total: ${amount_stats['sum']:.2f}")
        print(f"  Average: ${amount_stats['avg']:.2f}")
        print(f"  Min: ${amount_stats['min']:.2f}")
        print(f"  Max: ${amount_stats['max']:.2f}")
        
        # Filter for high-value sales
        high_value_sales = filter_data(sales_data, "amount", 1000, "greater_than")
        print(f"Found {len(high_value_sales)} high-value sales")
        
        # Save high-value sales to JSON
        save_json(high_value_sales, "high_value_sales.json")
        print("High-value sales saved to high_value_sales.json")
        
    except FileNotFoundError as e:
        print(f"Error: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

if __name__ == "__main__":
    main()