Python e Analisi dei Dati: Guida Completa dal Principiante all’Esperto

1
2
3
4
5
6
7

# Download da https://www.anaconda.com/products/distribution
# Installazione su Linux/Mac:
bash Anaconda3-2024.02-1-Linux-x86_64.sh

# Verifica installazione
conda --version
python --version

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Ubuntu/Debian
sudo apt update && sudo apt install python3 python3-pip python3-venv

# Windows (PowerShell)
# Scaricare da python.org e installare
# Assicurarsi di selezionare "Add Python to PATH"

# macOS (con Homebrew)
brew install python3

# Creare virtual environment
python3 -m venv data_science_env
source data_science_env/bin/activate  # Linux/Mac
# data_science_env\Scripts\activate   # Windows

# Installare pacchetti essenziali
pip install numpy pandas matplotlib seaborn jupyter scikit-learn

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Estensioni essenziali:
# - Python (Microsoft)
# - Jupyter (Microsoft)
# - Python Docstring Generator
# - GitLens
# - Pylance

# Configurazione settings.json
{
    "python.defaultInterpreterPath": "./data_science_env/bin/python",
    "python.linting.enabled": true,
    "python.linting.pylintEnabled": true,
    "python.formatting.provider": "black"
}

1

import this

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# CORRETTO - Naming conventions
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def calculate_correlation(data_frame, column_x, column_y):
    """
    Calcola la correlazione tra due colonne di un DataFrame.

    Args:
        data_frame (pd.DataFrame): DataFrame contenente i dati
        column_x (str): Nome della prima colonna
        column_y (str): Nome della seconda colonna

    Returns:
        float: Coefficiente di correlazione
    """
    return data_frame[column_x].corr(data_frame[column_y])

# SCORRETTO - Nomi poco chiari
import pandas
def calc_corr(df, x, y):
    return df[x].corr(df[y])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Importare librerie
import math
import statistics

# Set di dati di esempio: temperature giornaliere
temperatures = [22.5, 25.1, 19.8, 27.3, 24.0, 26.7, 23.2, 21.9, 28.1, 25.5]

# Statistiche descrittive
mean_temp = statistics.mean(temperatures)
median_temp = statistics.median(temperatures)
std_temp = statistics.stdev(temperatures)
min_temp = min(temperatures)
max_temp = max(temperatures)

print(f"Analisi Temperature:")
print(f"Media: {mean_temp:.2f}°C")
print(f"Mediana: {median_temp:.2f}°C")
print(f"Deviazione Standard: {std_temp:.2f}°C")
print(f"Range: {min_temp:.1f}°C - {max_temp:.1f}°C")

# Output:
# Media: 24.41°C
# Mediana: 24.75°C
# Deviazione Standard: 2.64°C
# Range: 19.8°C - 28.1°C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Simulare un set di dati vendite
sales_data = [
    {"product": "Laptop", "price": 999.99, "quantity": 5, "category": "Electronics"},
    {"product": "Mouse", "price": 29.99, "quantity": 15, "category": "Electronics"},
    {"product": "Keyboard", "price": 79.99, "quantity": 8, "category": "Electronics"},
    {"product": "Monitor", "price": 299.99, "quantity": 3, "category": "Electronics"},
    {"product": "Desk", "price": 199.99, "quantity": 2, "category": "Furniture"}
]

# Analisi delle vendite
total_revenue = sum(item["price"] * item["quantity"] for item in sales_data)
electronics_revenue = sum(
    item["price"] * item["quantity"]
    for item in sales_data
    if item["category"] == "Electronics"
)

print(f"Ricavo totale: €{total_revenue:,.2f}")
print(f"Ricavo elettronica: €{electronics_revenue:,.2f}")
print(f"Percentuale elettronica: {(electronics_revenue/total_revenue)*100:.1f}%")

# Prodotto più costoso
most_expensive = max(sales_data, key=lambda x: x["price"])
print(f"Prodotto più costoso: {most_expensive['product']} - €{most_expensive['price']}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Creare un grafico semplice con dati fittizi
months = ["Gen", "Feb", "Mar", "Apr", "Mag", "Giu"]
sales = [12000, 15500, 13200, 16800, 14200, 18500]

# Calcolo crescita month-over-month
growth_rates = []
for i in range(1, len(sales)):
    growth = ((sales[i] - sales[i-1]) / sales[i-1]) * 100
    growth_rates.append(growth)

# Report crescita
print("Crescita Month-over-Month:")
for i, rate in enumerate(growth_rates):
    print(f"{months[i]} -> {months[i+1]}: {rate:+.1f}%")

# Calcolo trend
average_growth = sum(growth_rates) / len(growth_rates)
print(f"\nCrescita media mensile: {average_growth:+.1f}%")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Cell 1: Configurazione
import sys
print(f"Python version: {sys.version}")
print(f"Current working directory: {sys.path[0]}")

# Cell 2: Load sample data
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'age': [25, 30, 35, 28, 32],
    'salary': [50000, 60000, 70000, 55000, 65000]
}

# Cell 3: Analisi di base
ages = [person['age'] for person in data.values()]
salaries = [person['salary'] for person in data.values()]

print("Statistiche rapide:")
print(f"Eta media: {sum(data['age']) / len(data['age']):.1f}")
print(f"Stipendio medio: €{sum(data['salary']) / len(data['salary']):,.0f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Analisi Stipendi per Età

## Obiettivi
- Analizzare la correlazione tra età e stipendio
- Identificare pattern nei dati
- Visualizzare le relazioni

## Metodologia
1. **Caricamento dati**: Caricamento set di dati campione
2. **EDA**: Analisi esplorativa dei dati
3. **Visualizzazione**: Grafici per risultati chiave
4. **Risultati**: Conclusioni e raccomandazioni

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def statistical_calculator(numbers):
    """
    Calcolatrice statistica completa.

    Args:
        numbers (list): Lista di numeri

    Returns:
        dict: Statistiche calcolate
    """
    if not numbers:
        return {"error": "Lista vuota"}

    # Implementa le seguenti statistiche:
    # - Media, mediana, moda
    # - Deviazione standard
    # - Quartili (Q1, Q2, Q3)
    # - Range e IQR

    # La tua implementazione qui...
    pass

# Test della funzione
test_data = [1, 2, 2, 3, 4, 4, 4, 5, 6, 7, 8, 9, 10]
results = statistical_calculator(test_data)
print(results)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

def text_analyzer(text):
    """
    Analizza un testo e fornisce statistiche.

    Args:
        text (str): Testo da analizzare

    Returns:
        dict: Statistiche del testo
    """
    # Implementa:
    # - Conteggio parole, caratteri, frasi
    # - Parole più frequenti
    # - Lunghezza media parole
    # - Readability score semplificato

    # La tua implementazione qui...
    pass

# Test
sample_text = """
Python è un linguaggio di programmazione versatile e potente.
È particolarmente adatto per l'analisi dei dati e l'apprendimento automatico.
La sua sintassi chiara lo rende ideale per principianti ed esperti.
"""

analysis = text_analyzer(sample_text)
print(analysis)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Creazione liste per analisi dati
sales_2023 = [45000, 52000, 48000, 61000, 55000, 67000, 59000, 63000, 58000, 71000, 66000, 74000]
months = ["Gen", "Feb", "Mar", "Apr", "Mag", "Giu", "Lug", "Ago", "Set", "Ott", "Nov", "Dic"]

# Operazioni di base
print(f"Vendite totali: €{sum(sales_2023):,}")
print(f"Media mensile: €{sum(sales_2023) / len(sales_2023):,.0f}")
print(f"Miglior mese: {months[sales_2023.index(max(sales_2023))]}")

# Slicing per analisi trimestri
q1 = sales_2023[0:3]   # Primo trimestre
q2 = sales_2023[3:6]   # Secondo trimestre
q3 = sales_2023[6:9]   # Terzo trimestre
q4 = sales_2023[9:12]  # Quarto trimestre

quarterly_performance = [sum(q1), sum(q2), sum(q3), sum(q4)]
print(f"Performance trimestri: {quarterly_performance}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Calcolo crescita month-over-month
growth_rates = [
    ((sales_2023[i] - sales_2023[i-1]) / sales_2023[i-1] * 100)
    for i in range(1, len(sales_2023))
]

# Filtraggio mesi con crescita positiva
positive_months = [
    months[i+1] for i, growth in enumerate(growth_rates) if growth > 0
]

# Identificazione outliers (vendite > 1.5 deviazione standard dalla media)
import statistics
mean_sales = statistics.mean(sales_2023)
std_sales = statistics.stdev(sales_2023)
threshold = mean_sales + (1.5 * std_sales)

outlier_months = [
    (months[i], sales) for i, sales in enumerate(sales_2023)
    if sales > threshold
]

print(f"Mesi outlier: {outlier_months}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# Set di dati prodotti
products = ["Laptop", "Mouse", "Keyboard", "Monitor", "Tablet"]
prices = [999, 29, 79, 299, 599]
categories = ["Electronics", "Accessories", "Accessories", "Electronics", "Electronics"]

# Sorting con chiavi personalizzate
# Ordinare prodotti per prezzo
products_by_price = sorted(zip(products, prices), key=lambda x: x[1], reverse=True)
print("Prodotti per prezzo:", products_by_price)

# Raggruppamento per categoria
from collections import defaultdict
category_groups = defaultdict(list)
for product, category in zip(products, categories):
    category_groups[category].append(product)

print("Raggruppamento:", dict(category_groups))

# Operazioni statistiche su liste
def analyze_numeric_list(data, label="Data"):
    """Analisi completa di una lista numerica"""
    return {
        'label': label,
        'count': len(data),
        'sum': sum(data),
        'mean': sum(data) / len(data),
        'min': min(data),
        'max': max(data),
        'range': max(data) - min(data),
        'sorted': sorted(data)
    }

price_analysis = analyze_numeric_list(prices, "Prezzi Prodotti")
print(price_analysis)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# Record dipendenti (immutabili per integrità)
Employee = tuple  # Type hint for clarity

employees = [
    ("Alice Johnson", "Scienziato dei dati", 75000, "2020-03-15"),
    ("Bob Smith", "Analista dati", 55000, "2021-07-22"),
    ("Carol Davis", "Ingegnere ML", 85000, "2019-11-30"),
    ("David Wilson", "Ingegnere dei dati", 70000, "2020-09-10")
]

# Unpacking per analisi
names, roles, salaries, hire_dates = zip(*employees)

# Named tuples per struttura più chiara
from collections import namedtuple

Employee = namedtuple('Employee', ['name', 'role', 'salary', 'hire_date'])
structured_employees = [Employee(*emp) for emp in employees]

# Analisi con named tuples
data_scientists = [emp for emp in structured_employees if 'Scienziato dei dati' in emp.role]
avg_salary_by_role = {}

for role in set(emp.role for emp in structured_employees):
    role_salaries = [emp.salary for emp in structured_employees if emp.role == role]
    avg_salary_by_role[role] = sum(role_salaries) / len(role_salaries)

print("Stipendio medio per ruolo:")
for role, avg_sal in avg_salary_by_role.items():
    print(f"  {role}: €{avg_sal:,.0f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Analisi geografica vendite
sales_locations = [
    ("Milano", (45.4642, 9.1900), 125000),
    ("Roma", (41.9028, 12.4964), 98000),
    ("Napoli", (40.8518, 14.2681), 76000),
    ("Torino", (45.0703, 7.6869), 85000),
    ("Firenze", (43.7696, 11.2558), 67000)
]

# Calcolo distanze (esempio semplificato)
def calculate_distance(coord1, coord2):
    """Calcola distanza euclidea approssimativa"""
    lat1, lon1 = coord1
    lat2, lon2 = coord2
    return ((lat2 - lat1)**2 + (lon2 - lon1)**2)**0.5

# Trova location più vicine a Milano
milan_coord = sales_locations[0][1]
distances_from_milan = [
    (city, calculate_distance(milan_coord, coord), sales)
    for city, coord, sales in sales_locations[1:]  # Escludi Milano stessa
]

distances_from_milan.sort(key=lambda x: x[1])
print("Città per distanza da Milano:", distances_from_milan)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# Set di dati comportamento clienti
customers_q1 = {"Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace"}
customers_q2 = {"Bob", "Diana", "Eve", "Henry", "Iris", "Jack", "Kate"}
customers_q3 = {"Charlie", "Diana", "Frank", "Henry", "Liam", "Mia", "Noah"}
customers_q4 = {"Alice", "Eve", "Grace", "Jack", "Liam", "Olivia", "Paul"}

# Analisi customer retention
retained_customers = customers_q1 & customers_q2 & customers_q3 & customers_q4
print(f"Clienti fedeli (tutti i trimestri): {retained_customers}")

# Nuovi clienti per trimestre
new_q2 = customers_q2 - customers_q1
new_q3 = customers_q3 - (customers_q1 | customers_q2)
new_q4 = customers_q4 - (customers_q1 | customers_q2 | customers_q3)

print(f"Nuovi clienti Q2: {new_q2}")
print(f"Nuovi clienti Q3: {new_q3}")
print(f"Nuovi clienti Q4: {new_q4}")

# Customer churn analysis
lost_after_q1 = customers_q1 - (customers_q2 | customers_q3 | customers_q4)
seasonal_customers = (customers_q1 | customers_q4) - (customers_q2 | customers_q3)

print(f"Clienti persi dopo Q1: {lost_after_q1}")
print(f"Clienti stagionali: {seasonal_customers}")

# Metriche di business
total_unique_customers = customers_q1 | customers_q2 | customers_q3 | customers_q4
active_all_quarters = len(retained_customers)
total_customers = len(total_unique_customers)

retention_rate = (active_all_quarters / len(customers_q1)) * 100
print(f"Tasso di retention: {retention_rate:.1f}%")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# Set di dati vendite complesso
sales_data = {
    "2023": {
        "Q1": {"Milano": 45000, "Roma": 38000, "Napoli": 25000},
        "Q2": {"Milano": 52000, "Roma": 41000, "Napoli": 28000},
        "Q3": {"Milano": 48000, "Roma": 39000, "Napoli": 30000},
        "Q4": {"Milano": 61000, "Roma": 45000, "Napoli": 35000}
    },
    "2024": {
        "Q1": {"Milano": 51000, "Roma": 42000, "Napoli": 29000},
        "Q2": {"Milano": 58000, "Roma": 46000, "Napoli": 33000}
    }
}

# Analisi performance per città
def analyze_city_performance(data, city):
    """Analizza performance di una città attraverso anni e trimestri"""
    city_data = []

    for year, quarters in data.items():
        for quarter, cities in quarters.items():
            if city in cities:
                city_data.append({
                    'year': year,
                    'quarter': quarter,
                    'sales': cities[city],
                    'period': f"{year}-{quarter}"
                })

    # Calcola metriche
    total_sales = sum(record['sales'] for record in city_data)
    avg_sales = total_sales / len(city_data)

    # Growth analysis
    city_data.sort(key=lambda x: (x['year'], x['quarter']))
    growth_rates = []

    for i in range(1, len(city_data)):
        prev_sales = city_data[i-1]['sales']
        curr_sales = city_data[i]['sales']
        growth = ((curr_sales - prev_sales) / prev_sales) * 100
        growth_rates.append(growth)

    return {
        'city': city,
        'total_sales': total_sales,
        'average_quarterly_sales': avg_sales,
        'quarters_analyzed': len(city_data),
        'average_growth_rate': sum(growth_rates) / len(growth_rates) if growth_rates else 0,
        'data_points': city_data
    }

# Analisi per ogni città
cities = ["Milano", "Roma", "Napoli"]
city_analyses = {city: analyze_city_performance(sales_data, city) for city in cities}

# Report comparativo
print("REPORT PERFORMANCE CITTÀ:")
print("-" * 50)
for city, analysis in city_analyses.items():
    print(f"{city}:")
    print(f"  Vendite totali: €{analysis['total_sales']:,}")
    print(f"  Media trimestrale: €{analysis['average_quarterly_sales']:,.0f}")
    print(f"  Crescita media: {analysis['average_growth_rate']:+.1f}%")
    print()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# Aggregazioni avanzate
quarterly_totals = {
    f"{year}-{quarter}": sum(cities.values())
    for year, quarters in sales_data.items()
    for quarter, cities in quarters.items()
}

yearly_totals = {
    year: sum(
        sum(cities.values()) for cities in quarters.values()
    )
    for year, quarters in sales_data.items()
}

city_totals = {}
for year, quarters in sales_data.items():
    for quarter, cities in quarters.items():
        for city, sales in cities.items():
            if city not in city_totals:
                city_totals[city] = 0
            city_totals[city] += sales

print("Totali per trimestre:", quarterly_totals)
print("Totali per anno:", yearly_totals)
print("Totali per città:", city_totals)

# Ranking e top performers
top_quarters = sorted(quarterly_totals.items(), key=lambda x: x[1], reverse=True)
top_cities = sorted(city_totals.items(), key=lambda x: x[1], reverse=True)

print(f"Miglior trimestre: {top_quarters[0][0]} con €{top_quarters[0][1]:,}")
print(f"Miglior città: {top_cities[0][0]} con €{top_cities[0][1]:,}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# Set di dati originale: lista di tuple
raw_data = [
    ("Prodotto A", "Electronics", 299.99, 150),
    ("Prodotto B", "Clothing", 89.99, 300),
    ("Prodotto C", "Electronics", 199.99, 200),
    ("Prodotto D", "Home", 149.99, 100),
    ("Prodotto E", "Electronics", 399.99, 75)
]

# Conversione a dizionario per lookup
product_dict = {product: {"category": cat, "price": price, "stock": stock}
               for product, cat, price, stock in raw_data}

# Conversione a set per categorie uniche
unique_categories = set(item[1] for item in raw_data)

# Lista di dizionari per analisi strutturata
products_list = [
    {"name": product, "category": cat, "price": price, "stock": stock}
    for product, cat, price, stock in raw_data
]

# Raggruppamento per categoria
from collections import defaultdict
category_analysis = defaultdict(lambda: {"products": [], "total_value": 0, "avg_price": 0})

for product in products_list:
    cat = product["category"]
    category_analysis[cat]["products"].append(product["name"])
    category_analysis[cat]["total_value"] += product["price"] * product["stock"]

# Calcola prezzo medio per categoria
for cat_data in category_analysis.values():
    cat_products = [p for p in products_list if p["category"] in cat_data["products"]]
    cat_data["avg_price"] = sum(p["price"] for p in cat_products) / len(cat_products)

print("Analisi per categoria:")
for category, data in category_analysis.items():
    print(f"{category}: {len(data['products'])} prodotti, "
          f"valore totale €{data['total_value']:,.0f}, "
          f"prezzo medio €{data['avg_price']:.2f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def build_recommendation_system(purchase_history):
    """
    Costruisci un sistema di raccomandazione basato su acquisti storici.

    Args:
        purchase_history (dict): {customer_id: [list_of_products]}

    Returns:
        dict: Raccomandazioni per ogni cliente
    """
    # La tua implementazione qui:
    # 1. Trova clienti con acquisti simili
    # 2. Suggerisci prodotti acquistati da clienti simili
    # 3. Ordina raccomandazioni per popolarità
    pass

# Test data
purchase_data = {
    "customer_1": ["laptop", "mouse", "keyboard"],
    "customer_2": ["laptop", "monitor", "speakers"],
    "customer_3": ["mouse", "keyboard", "headphones"],
    "customer_4": ["laptop", "mouse", "webcam"],
    "customer_5": ["tablet", "stylus", "case"]
}

recommendations = build_recommendation_system(purchase_data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

def sales_performance_analyzer(sales_records):
    """
    Analizza performance vendite multi-dimensionale.

    Args:
        sales_records (list): Lista di record vendite
            Formato: [{"date": "2024-01-15", "product": "X", "amount": 100, "region": "North"}]

    Returns:
        dict: Report completo con metriche e risultati chiave
    """
    # Implementa:
    # 1. Trend analysis per periodo
    # 2. Performance per regione
    # 3. Top products analysis
    # 4. Seasonal patterns detection
    # 5. Anomaly detection
    pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

PRINCIPIANTE (0-3 mesi)
├── Fondamenti Python e sintassi
├── Padronanza strutture dati
├── I/O file e elaborazione di base
└── Primi progetti di analisi dei dati

INTERMEDIO (3-8 mesi)
├── Competenza NumPy e Pandas
├── Visualizzazione dati (Matplotlib, Seaborn)
├── Analisi statistica
├── Pulizia dati e pre-elaborazione
└── Integrazione SQL

AVANZATO (8-18 mesi)
├── Apprendimento automatico (Scikit-learn)
├── Statistica avanzata
├── Ingegneria delle caratteristiche
├── Selezione e validazione del modello
└── Fondamenti MLOps

ESPERTO (18+ mesi)
├── Apprendimento profondo (PyTorch/TensorFlow)
├── Elaborazione Big Data (Spark/Dask)
├── Algoritmi ML avanzati
├── Rilascio in produzione
└── Ricerca e innovazione