40. Scrivere codice pulito e leggibile

# ATTENZIONE: stile scadente - solo a scopo dimostrativo
def c(l):
    t=0
    for i in l:
        t=t+i
    return t/len(l)
 
data=[85,92,78,90,88]
result=c(data)
print(result)  # Output: 86.6

def calculate_average(numbers):
    """Calculate the arithmetic mean of a list of numbers."""
    total = 0
    for number in numbers:
        total = total + number
    return total / len(numbers)
 
test_scores = [85, 92, 78, 90, 88]
average_score = calculate_average(test_scores)
print(average_score)  # Output: 86.6

# Difficile da sottoporre a debugging - cosa rappresentano queste variabili?
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
def process(x, y):
    if x > y:
        return x * (1 - y)
    return x
 
result = process(100, 0.1)

# Facile da sottoporre a debugging - è chiaro cosa sta succedendo
def apply_discount(price, discount_rate):
    """Calculate price after applying discount rate (0.0 to 1.0)."""
    discount_amount = price * discount_rate
    final_price = price - discount_amount
    return final_price
 
original_price = 100
discount = 0.1  # sconto del 10%
final_price = apply_discount(original_price, discount)
print(f"Final price: ${final_price}")
# Output: Final price: $90.0

# Nomi scarsi - non è chiaro cosa rappresentino
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
# Cos'è 'n'? Un numero? Un nome? Un nodo?
# Cos'è 'd'? Una data? Una distanza? Una durata?
# Cos'è 'l'? Sembra il numero 1!
n = "Alice"
d = 25
l = [1, 2, 3]
calc = lambda x: x * 2
 
# Buoni nomi - chiari e descrittivi
student_name = "Alice"
age_in_years = 25
test_scores = [1, 2, 3]
double_value = lambda x: x * 2

# Accettabile: molto corto, contesto chiaro
for i in range(10):
    print(i)
 
for x, y in coordinates:
    distance = (x**2 + y**2) ** 0.5
 
# Ma preferisci nomi descrittivi per chiarezza
for student_index in range(len(students)):
    print(students[student_index])
 
for point_x, point_y in coordinates:
    distance = (point_x**2 + point_y**2) ** 0.5

# Variabili
user_name = "Bob"
total_price = 99.99
is_valid = True
max_retry_count = 3
 
# Funzioni
def calculate_tax(amount, rate):
    """Calculate tax on a given amount."""
    return amount * rate
 
def send_email_notification(recipient, message):
    """Send an email to the specified recipient."""
    print(f"Sending to {recipient}: {message}")
 
# Uso delle funzioni
tax_amount = calculate_tax(100, 0.08)
send_email_notification("user@example.com", "Welcome!")

# Costanti a livello di modulo
MAX_LOGIN_ATTEMPTS = 3
DEFAULT_TIMEOUT_SECONDS = 30
PI = 3.14159
DATABASE_URL = "postgresql://localhost/mydb"
 
def validate_password_length(password):
    """Check if password meets minimum length requirement."""
    MIN_PASSWORD_LENGTH = 8  # Costante all'interno della funzione
    return len(password) >= MIN_PASSWORD_LENGTH
 
# Uso delle costanti
if login_attempts > MAX_LOGIN_ATTEMPTS:
    print("Account locked")

# Python non ha una sintassi per le costanti - questa è solo una variabile normale
MAX_LOGIN_ATTEMPTS = 3
 
# Python non ti impedirà di modificarla
MAX_LOGIN_ATTEMPTS = 5  # ❌ Tecnicamente funziona, ma viola la convenzione
 
# La convenzione di naming è un segnale sull'INTENTO:
# "L'ho chiamata in MAIUSCOLO per mostrare che non voglio che cambi"

# Questo valore cambierà - usa il minuscolo
max_login_attempts = 3
max_login_attempts = 5  # ✅ OK - il nome indica che può cambiare
 
# Questo valore non dovrebbe mai cambiare - usa il MAIUSCOLO
MAX_LOGIN_ATTEMPTS = 3
# Non riassegnarlo più avanti nel codice

# Definizioni di classi
class Student:
    """Represent a student with name and grades."""
    def __init__(self, name):
        self.name = name
        self.grades = []
 
class ShoppingCart:
    """Manage items in a shopping cart."""
    def __init__(self):
        self.items = []
    
    def add_item(self, item):
        """Add an item to the cart."""
        self.items.append(item)
 
class DatabaseConnection:
    """Handle database connection and queries."""
    def __init__(self, url):
        self.url = url
 
# Creazione di istanze (nota: le istanze usano nomi variabile in snake_case)
student = Student("Alice")
shopping_cart = ShoppingCart()
db_connection = DatabaseConnection("localhost")

class BankAccount:
    """Represent a bank account with balance tracking."""
    
    def __init__(self, account_number, initial_balance):
        self.account_number = account_number
        self._balance = initial_balance  # Attributo interno
    
    def deposit(self, amount):
        """Add money to the account."""
        if self._validate_amount(amount):  # Metodo interno
            self._balance += amount
    
    def _validate_amount(self, amount):
        """Internal helper to validate transaction amounts."""
        return amount > 0
    
    def get_balance(self):
        """Return the current balance."""
        return self._balance
 
# Uso della classe
account = BankAccount("12345", 1000)
account.deposit(500)
print(account.get_balance())  # Output: 1500
 
# Tecnicamente funziona, ma viola la convenzione
print(account._balance)
# Output: 1500 (works, but you shouldn't do this!)
 
# Tecnicamente funziona, ma viola la convenzione
result = account._validate_amount(100)
# Output: True (works, but you shouldn't do this!)

class Point:
    """Represent a 2D point."""
    
    def __init__(self, x, y):  # Metodo speciale: inizializzazione
        self.x = x
        self.y = y
    
    def __str__(self):  # Metodo speciale: rappresentazione come stringa
        return f"Point({self.x}, {self.y})"
    
    def __add__(self, other):  # Metodo speciale: operatore di addizione
        return Point(self.x + other.x, self.y + other.y)
 
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1)  # Output: Point(1, 2)
print(p1 + p2)  # Output: Point(4, 6)

def calculate_grade(score):
    """Determine letter grade from numeric score."""
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    else:
        return "F"
 
# Indentazione annidata: 4 spazi per livello
def process_students(students):
    """Process a list of student records."""
    for student in students:
        if student["active"]:
            grade = calculate_grade(student["score"])
            print(f"{student['name']}: {grade}")
 
students = [
    {"name": "Alice", "score": 92, "active": True},
    {"name": "Bob", "score": 78, "active": True}
]
process_students(students)
# Output:
# Alice: A
# Bob: C

# Troppo lungo - difficile da leggere
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
def calculate_monthly_payment(principal, annual_rate, years):
    return principal * (annual_rate / 12) * (1 + annual_rate / 12) ** (years * 12) / ((1 + annual_rate / 12) ** (years * 12) - 1)
 
# Meglio - spezzato in righe leggibili
def calculate_monthly_payment(principal, annual_rate, years):
    """Calculate monthly loan payment using amortization formula."""
    monthly_rate = annual_rate / 12
    num_payments = years * 12
    
    numerator = principal * monthly_rate * (1 + monthly_rate) ** num_payments
    denominator = (1 + monthly_rate) ** num_payments - 1
    
    return numerator / denominator
 
payment = calculate_monthly_payment(200000, 0.045, 30)
print(f"Monthly payment: ${payment:.2f}")  # Output: Monthly payment: $1013.37

# Chiamata di funzione lunga
result = some_function(
    first_argument,
    second_argument,
    third_argument,
    fourth_argument
)
 
# Lista lunga
colors = [
    "red", "green", "blue",
    "yellow", "orange", "purple",
    "pink", "brown", "gray"
]
 
# Stringa lunga
message = (
    "This is a very long message that needs to be broken "
    "across multiple lines for readability. Python automatically "
    "concatenates adjacent string literals."
)
print(message)
# Output: This is a very long message that needs to be broken across multiple lines for readability. Python automatically concatenates adjacent string literals.

# Spaziatura scarsa - tutto stretto e difficile da leggere
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
x=5
y=x*2+3
result=calculate_tax(100,0.08)
data=[1,2,3,4,5]
 
# Buona spaziatura - chiaro e leggibile
x = 5
y = x * 2 + 3
result = calculate_tax(100, 0.08)
data = [1, 2, 3, 4, 5]
 
# Spaziatura nelle espressioni
total = (price * quantity) + shipping_cost
is_valid = (age >= 18) and (has_license == True)
 
# Spaziatura nelle definizioni di funzione
def calculate_discount(price, discount_rate, minimum_purchase=0):
    """Calculate discounted price if minimum purchase is met."""
    if price >= minimum_purchase:
        return price * (1 - discount_rate)
    return price

# Spaziatura corretta per argomenti keyword
result = calculate_discount(price=100, discount_rate=0.1, minimum_purchase=50)
 
# Spaziatura corretta per parametri di default
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

def first_function():
    """First function."""
    pass
 
 
def second_function():
    """Second function."""
    pass
 
 
class MyClass:
    """A class definition."""
    pass

class Student:
    """Represent a student with grades."""
    
    def __init__(self, name):
        self.name = name
        self.grades = []
    
    def add_grade(self, grade):
        """Add a grade to the student's record."""
        self.grades.append(grade)
    
    def get_average(self):
        """Calculate the student's grade average."""
        if not self.grades:
            return 0
        return sum(self.grades) / len(self.grades)

def process_order(order_items, customer):
    """Process a customer order and calculate total."""
    
    # Calcola il subtotale
    subtotal = 0
    for item in order_items:
        subtotal += item["price"] * item["quantity"]
    
    # Applica lo sconto cliente
    discount = 0
    if customer["is_premium"]:
        discount = subtotal * 0.1
    
    # Calcola la tassa
    tax = (subtotal - discount) * 0.08
    
    # Calcola il totale finale
    total = subtotal - discount + tax
    
    return {
        "subtotal": subtotal,
        "discount": discount,
        "tax": tax,
        "total": total
    }

# Cattivo - spazi finali invisibili (mostrati come · solo per illustrazione)
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
def calculate(x):···
    return x * 2···
 
# Buono - nessuno spazio finale
def calculate(x):
    return x * 2

# Commento scarso - dice l'ovvio
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
x = x + 1  # Aggiungi 1 a x
 
# Commento buono - spiega il perché
x = x + 1  # Adatta per indicizzazione basata su zero
 
# Commento scarso - ridondante rispetto al codice
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
# Controlla se age è maggiore o uguale a 18
if age >= 18:
    print("Adult")
 
# Commento buono - spiega la logica di business
# Età legale per bere negli Stati Uniti
if age >= 21:
    print("Can purchase alcohol")

def binary_search(sorted_list, target):
    """Search for target in sorted list using binary search."""
    left = 0
    right = len(sorted_list) - 1
    
    while left <= right:
        # Calcola il punto medio, evitando overflow di interi
        # (right + left) // 2 potrebbe andare in overflow con indici molto grandi
        mid = left + (right - left) // 2
        
        if sorted_list[mid] == target:
            return mid
        elif sorted_list[mid] < target:
            left = mid + 1  # Il target è nella metà destra
        else:
            right = mid - 1  # Il target è nella metà sinistra
    
    return -1  # Target non trovato

def calculate_shipping_cost(weight, distance):
    """Calculate shipping cost based on weight and distance."""
    base_cost = 5.00
    
    # Promozione spedizione gratuita per articoli pesanti (policy aziendale al 2024)
    # Questo incoraggia ordini in grandi quantità e riduce i costi di spedizione per unità
    if weight > 50:
        return 0
    
    # Tariffa standard: $0.50 per libbra più $0.10 per miglio
    # Basata sul contratto con il corriere negoziato nel Q1 2024
    return base_cost + (weight * 0.50) + (distance * 0.10)

def process_data(data):
    """Process incoming data records."""
    # TODO: Questa è una correzione temporanea per record malformati
    # Rimuovere una volta implementata la validazione dei dati a monte
    if not isinstance(data, list):
        data = [data]
    
    for record in data:
        # Elabora ogni record
        pass

def calculate_bmi(weight_kg, height_m):
    """
    Calculate Body Mass Index (BMI).
    
    BMI is calculated as weight in kilograms divided by the square of height in meters.
    
    Args:
        weight_kg: Weight in kilograms (float or int)
        height_m: Height in meters (float or int)
    
    Returns:
        float: The calculated BMI value
    
    Example:
        >>> calculate_bmi(70, 1.75)
        22.857142857142858
    """
    return weight_kg / (height_m ** 2)
 
# Accedere alle docstring
print(calculate_bmi.__doc__)
# Output:
#     Calculate Body Mass Index (BMI).
#     
#     BMI is calculated as weight in kilograms divided by the square of height in meters.
#     ...

def square(x):
    """Return the square of x."""
    return x * x
 
def is_even(n):
    """Return True if n is even, False otherwise."""
    return n % 2 == 0

def find_prime_factors(n):
    """
    Find all prime factors of a positive integer.
    
    This function returns a list of prime numbers that, when multiplied
    together, equal the input number. The factors are returned in ascending order.
    
    Args:
        n: A positive integer greater than 1
    
    Returns:
        list: Prime factors in ascending order
    
    Raises:
        ValueError: If n is less than 2
    
    Example:
        >>> find_prime_factors(12)
        [2, 2, 3]
        >>> find_prime_factors(17)
        [17]
    """
    if n < 2:
        raise ValueError("n must be at least 2")
    
    factors = []
    divisor = 2
    
    while n > 1:
        while n % divisor == 0:
            factors.append(divisor)
            n = n // divisor
        divisor += 1
    
    return factors

class BankAccount:
    """
    Represent a bank account with deposit and withdrawal operations.
    
    This class maintains an account balance and provides methods for
    depositing and withdrawing money. All transactions are validated to prevent negative balances.
    
    Attributes:
        account_number: Unique identifier for the account
        balance: Current account balance in dollars
    """
    
    def __init__(self, account_number, initial_balance=0):
        """
        Initialize a new bank account.
        
        Args:
            account_number: Unique account identifier (string)
            initial_balance: Starting balance (default: 0)
        """
        self.account_number = account_number
        self.balance = initial_balance
    
    def deposit(self, amount):
        """
        Add money to the account.
        
        Args:
            amount: Amount to deposit (must be positive)
        
        Raises:
            ValueError: If amount is not positive
        """
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.balance += amount

def calculate_compound_interest(principal, rate, time, compounds_per_year=1):
    """
    Calculate compound interest on an investment.
    
    Uses the compound interest formula: A = P(1 + r/n)^(nt)
    where A is the final amount, P is principal, r is annual rate,
    n is compounds per year, and t is time in years.
    
    Args:
        principal: Initial investment amount (float)
        rate: Annual interest rate as decimal (e.g., 0.05 for 5%)
        time: Investment period in years (float)
        compounds_per_year: Number of times interest compounds annually
                           (default: 1 for annual compounding)
    
    Returns:
        float: Final amount after compound interest
    
    Example:
        >>> calculate_compound_interest(1000, 0.05, 10, 12)
        1647.0095
    """
    return principal * (1 + rate / compounds_per_year) ** (compounds_per_year * time)

def process_payment(amount, payment_method):
    """Process a payment transaction."""
    # TODO: Aggiungere supporto per pagamenti in criptovaluta
    # TODO: Implementare controlli di rilevamento frodi
    
    if payment_method == "credit_card":
        return process_credit_card(amount)
    elif payment_method == "paypal":
        return process_paypal(amount)
    else:
        raise ValueError(f"Unsupported payment method: {payment_method}")

"""
student_manager.py
 
Gestisce i record degli studenti, inclusi voti e calcoli del GPA.
 
Questo modulo fornisce funzioni per aggiungere studenti, registrare i voti
e calcolare le medie dei voti (grade point averages).
"""
 
# Import della libreria standard
import sys
from datetime import datetime
 
# Import di terze parti (se presenti)
# import requests
 
# Import locali (se presenti)
# from .database import save_student
 
# Costanti
MAX_GRADE = 100
MIN_GRADE = 0
PASSING_GRADE = 60
 
# Funzioni
def calculate_gpa(grades):
    """
    Calculate GPA from a list of numeric grades.
    
    Args:
        grades: List of numeric grades (0-100)
    
    Returns:
        float: GPA on 4.0 scale
    """
    if not grades:
        return 0.0
    
    average = sum(grades) / len(grades)
    
    # Conversione alla scala 4.0
    if average >= 90:
        return 4.0
    elif average >= 80:
        return 3.0
    elif average >= 70:
        return 2.0
    elif average >= 60:
        return 1.0
    else:
        return 0.0
 
def validate_grade(grade):
    """
    Check if a grade is within valid range.
    
    Args:
        grade: Numeric grade to validate
    
    Returns:
        bool: True if grade is valid, False otherwise
    """
    return MIN_GRADE <= grade <= MAX_GRADE
 
# Esecuzione main
if __name__ == "__main__":
    # Codice che viene eseguito quando lo script viene avviato direttamente
    test_grades = [85, 92, 78, 88]
    gpa = calculate_gpa(test_grades)
    print(f"GPA: {gpa}")  # Output: GPA: 3.0

# Import della libreria standard
import os
import sys
from datetime import datetime, timedelta
from pathlib import Path
 
# Import di terze parti
import requests
from flask import Flask, render_template
 
# Import locali dell'applicazione
from myapp.database import connect_db
from myapp.models import User, Product
from myapp.utils import format_currency

# Importa l'intero modulo
import math
result = math.sqrt(16)  # Output: 4.0
 
# Importa elementi specifici
from math import sqrt, pi
result = sqrt(16)  # Output: 4.0
 
# Import con alias
import numpy as np
array = np.array([1, 2, 3])
 
# Importa elementi multipli
from os import path, getcwd, listdir

# Scarso - non è chiaro da dove provenga sqrt
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
from math import *
result = sqrt(16)
 
# Buono - import esplicito
from math import sqrt
result = sqrt(16)

"""Configuration settings for the application."""
 
import os
 
# Costanti dell'applicazione
APP_NAME = "Student Manager"
VERSION = "1.0.0"
DEBUG_MODE = True
 
# Configurazione database
DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///students.db")
MAX_CONNECTIONS = 10
 
# Regole di business
MAX_STUDENTS_PER_CLASS = 30
PASSING_GRADE = 60
GRADE_WEIGHTS = {
    "homework": 0.3,
    "midterm": 0.3,
    "final": 0.4
}
 
def calculate_final_grade(homework, midterm, final):
    """Calculate weighted final grade."""
    return (
        homework * GRADE_WEIGHTS["homework"] +
        midterm * GRADE_WEIGHTS["midterm"] +
        final * GRADE_WEIGHTS["final"]
    )

"""Order processing module."""
 
# Funzioni dell'API pubblica
def process_order(order_items, customer):
    """
    Process a customer order.
    
    This is the main entry point for order processing.
    """
    subtotal = _calculate_subtotal(order_items)
    discount = _calculate_discount(subtotal, customer)
    tax = _calculate_tax(subtotal - discount)
    total = subtotal - discount + tax
    
    return {
        "subtotal": subtotal,
        "discount": discount,
        "tax": tax,
        "total": total
    }
 
def validate_order(order_items):
    """Validate that an order contains valid items."""
    if not order_items:
        return False
    
    for item in order_items:
        if not _validate_item(item):
            return False
    
    return True
 
# Funzioni helper interne
def _calculate_subtotal(items):
    """Calculate order subtotal (internal use)."""
    total = 0
    for item in items:
        total += item["price"] * item["quantity"]
    return total
 
def _calculate_discount(subtotal, customer):
    """Calculate customer discount (internal use)."""
    if customer.get("is_premium"):
        return subtotal * 0.1
    return 0
 
def _calculate_tax(amount):
    """Calculate sales tax (internal use)."""
    TAX_RATE = 0.08
    return amount * TAX_RATE
 
def _validate_item(item):
    """Validate a single order item (internal use)."""
    required_fields = ["name", "price", "quantity"]
    return all(field in item for field in required_fields)

"""User management system."""
 
# Costanti
DEFAULT_ROLE = "user"
ADMIN_ROLE = "admin"
 
# Prima le classi base
class User:
    """Base user class."""
    
    def __init__(self, username, email):
        self.username = username
        self.email = email
        self.role = DEFAULT_ROLE
    
    def can_edit(self, resource):
        """Check if user can edit a resource."""
        return resource.owner == self.username
 
# Poi le classi derivate dopo le classi base
class AdminUser(User):
    """Administrator with elevated privileges."""
    
    def __init__(self, username, email):
        super().__init__(username, email)
        self.role = ADMIN_ROLE
    
    def can_edit(self, resource):
        """Admins can edit any resource."""
        return True
 
# Classi correlate raggruppate insieme
class Resource:
    """Represent a resource that can be owned and edited."""
    
    def __init__(self, name, owner):
        self.name = name
        self.owner = owner
 
# Funzioni di utilità correlate alle classi
def create_user(username, email, is_admin=False):
    """Factory function to create appropriate user type."""
    if is_admin:
        return AdminUser(username, email)
    return User(username, email)

"""math_utils.py - Mathematical utility functions."""
 
def add(a, b):
    """Add two numbers."""
    return a + b
 
def multiply(a, b):
    """Multiply two numbers."""
    return a * b
 
# Questo codice viene eseguito solo quando il file viene avviato direttamente
if __name__ == "__main__":
    # Testa le funzioni
    print(f"5 + 3 = {add(5, 3)}")  # Output: 5 + 3 = 8
    print(f"5 * 3 = {multiply(5, 3)}")  # Output: 5 * 3 = 15

# another_file.py
from math_utils import add, multiply
 
result = add(10, 20)
print(result)  # Output: 30
# Il codice di test da math_utils.py NON viene eseguito

"""temperature.py - Temperature conversion utilities."""
 
def celsius_to_fahrenheit(celsius):
    """Convert Celsius to Fahrenheit."""
    return (celsius * 9/5) + 32
 
def fahrenheit_to_celsius(fahrenheit):
    """Convert Fahrenheit to Celsius."""
    return (fahrenheit - 32) * 5/9
 
if __name__ == "__main__":
    # Dimostra le funzioni
    print("Temperature Conversion Examples:")
    print(f"0°C = {celsius_to_fahrenheit(0)}°F")  # Output: 0°C = 32.0°F
    print(f"100°C = {celsius_to_fahrenheit(100)}°F")  # Output: 100°C = 212.0°F
    print(f"32°F = {fahrenheit_to_celsius(32)}°C")  # Output: 32°F = 0.0°C

"""data_processor.py - Process and analyze data files."""
 
import sys
 
def load_data(filename):
    """Load data from a file."""
    with open(filename) as f:
        return [line.strip() for line in f]
 
def analyze_data(data):
    """Perform analysis on data."""
    return {
        "count": len(data),
        "average_length": sum(len(item) for item in data) / len(data)
    }
 
if __name__ == "__main__":
    # Quando viene eseguito come script, elabora gli argomenti da riga di comando
    if len(sys.argv) < 2:
        print("Usage: python data_processor.py <filename>")
        sys.exit(1)
    
    filename = sys.argv[1]
    data = load_data(filename)
    results = analyze_data(data)
    
    print(f"Processed {results['count']} items")
    print(f"Average length: {results['average_length']:.2f}")

$ python data_processor.py data.txt
Processed 42 items
Average length: 15.23

# my_analysis.py
from data_processor import load_data, analyze_data
 
my_data = load_data("myfile.txt")
results = analyze_data(my_data)
print(f"Found {results['count']} items")

"""calculator.py - Basic calculator operations."""
 
def add(a, b):
    """Add two numbers."""
    return a + b
 
def subtract(a, b):
    """Subtract b from a."""
    return a - b
 
if __name__ == "__main__":
    # Test rapidi
    assert add(2, 3) == 5
    assert subtract(10, 4) == 6
    print("All tests passed!")  # Output: All tests passed!

"""report_generator.py - Generate reports from data."""
 
import sys
 
def load_data(filename):
    """Load data from file."""
    # Implementazione qui
    pass
 
def generate_report(data):
    """Generate report from data."""
    # Implementazione qui
    pass
 
def save_report(report, output_file):
    """Save report to file."""
    # Implementazione qui
    pass
 
def main():
    """Main entry point for the script."""
    if len(sys.argv) < 3:
        print("Usage: python report_generator.py <input> <output>")
        return 1
    
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    
    try:
        data = load_data(input_file)
        report = generate_report(data)
        save_report(report, output_file)
        print(f"Report saved to {output_file}")
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1
 
if __name__ == "__main__":
    # Esci con il codice di stato restituito da main (0 = successo, 1 = errore)
    sys.exit(main())

# Scarso - logica complessa nel blocco main
# ATTENZIONE: stile scadente - solo a scopo dimostrativo
if __name__ == "__main__":
    data = []
    for i in range(100):
        if i % 2 == 0:
            data.append(i * 2)
    result = sum(data) / len(data)
    print(result)
 
# Buono - logica nelle funzioni, il blocco main coordina
def generate_even_doubles(limit):
    """Generate doubled even numbers up to limit."""
    return [i * 2 for i in range(limit) if i % 2 == 0]
 
def calculate_average(numbers):
    """Calculate average of numbers."""
    return sum(numbers) / len(numbers)
 
if __name__ == "__main__":
    data = generate_even_doubles(100)
    result = calculate_average(data)
    print(result)  # Output: 99.0

"""
file_processor.py - Process text files with various operations.
 
Usage:
    python file_processor.py <input_file> <output_file> [--uppercase]
 
Arguments:
    input_file: Path to input file
    output_file: Path to output file
    --uppercase: Convert text to uppercase (optional)
"""
 
import sys
 
def process_file(input_path, output_path, uppercase=False):
    """Process file with specified options."""
    with open(input_path) as f:
        content = f.read()
    
    if uppercase:
        content = content.upper()
    
    with open(output_path, 'w') as f:
        f.write(content)
 
if __name__ == "__main__":
    if len(sys.argv) < 3:
        print(__doc__)  # Stampa la docstring del modulo
        sys.exit(1)
    
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    uppercase = "--uppercase" in sys.argv
    
    process_file(input_file, output_file, uppercase)
    print(f"Processed {input_file} -> {output_file}")