Un'app per la sostenibilità: dove conviene lanciarla?¶

# su Colab installo le due librerie facoltative; in locale non installo nulla
# (ydata-profiling farebbe retrocedere pandas alla versione 2)
import sys
if "google.colab" in sys.modules:
    !pip install -q plotly ydata-profiling

import os
import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

warnings.filterwarnings("ignore")
%matplotlib inline

# librerie facoltative
try:
    import plotly.express as px
    PLOTLY = True
except ImportError:
    PLOTLY = False

try:
    from ydata_profiling import ProfileReport
    YDATA = True
except ImportError:
    YDATA = False

pd.set_option("display.max_columns", 30)
pd.set_option("display.width", 170)

# stile dei grafici, impostato una volta per tutte
sns.set_theme(style="whitegrid")
plt.rcParams.update({"figure.figsize": (9, 4), "figure.dpi": 110,
                     "axes.titlesize": 12, "axes.titleweight": "bold",
                     "axes.titlelocation": "left", "grid.linewidth": 0.5})
BLU, ARANCIONE, VERDE, GRIGIO = "#2a78d6", "#eb6834", "#1baf7a", "#9a9a96"

print("pandas", pd.__version__, "| numpy", np.__version__, "| seaborn", sns.__version__)
print("plotly:", "presente" if PLOTLY else "assente (salterò un grafico)")
print("ydata-profiling:", "presente" if YDATA else "assente (salterò un riepilogo)")

# --- lettura dei due file CSV -------------------------------------------
# I file sono caricati a mano nel pannello dei file di Colab: stanno in /content
PERCORSO_APP = "/content/googleplaystore.csv"
PERCORSO_REC = "/content/googleplaystore_user_reviews.csv"

# se non sono in /content sto girando in locale: li cerco in data/
if not os.path.exists(PERCORSO_APP):
    PERCORSO_APP = "data/googleplaystore.csv"
    PERCORSO_REC = "data/googleplaystore_user_reviews.csv"

grezzo = pd.read_csv(PERCORSO_APP)
recensioni_grezze = pd.read_csv(PERCORSO_REC)

print("App        :", grezzo.shape[0], "righe x", grezzo.shape[1], "colonne")
print("Recensioni :", recensioni_grezze.shape[0], "righe x", recensioni_grezze.shape[1], "colonne")
grezzo.head(3)

# ---utilizzo la funzione info() per vedere che tipo di dati ha letto pandas ----------------------------------
grezzo.info()

# --- riepilogo automatico con ydata-profiling ---------------------------
if YDATA:
    import contextlib, io
    profilo = ProfileReport(grezzo, title="Google Play Store", progress_bar=False,
                            duplicates={"head": 5},
                            correlations={"auto": {"calculate": True}})
    with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
        profilo.to_file("report_ydata.html")
    print("Report salvato in report_ydata.html\n")
    print("Anomalie segnalate dallo strumento:")
    for avviso in profilo.description_set.alerts:
        print("  -", avviso)
else:
    print("ydata-profiling non installato: salto il report e vado avanti.")

# lo stesso conteggio dei duplicati, fatto con pandas: si vede sempre
righe_ripetute = grezzo[grezzo.duplicated(keep=False)]
print("\nRighe diverse che compaiono più di una volta:", len(righe_ripetute.drop_duplicates()))
print("Copie in più da eliminare (pandas)         :", grezzo.duplicated().sum())

# --- controllo: il voto deve stare tra 1 e 5 ----------------------------
fuori_scala = grezzo[(grezzo["Rating"] > 5) | (grezzo["Rating"] < 1)] # verifico che il voto non sia maggiore di 5 o minore di 1
print("Righe con voto fuori dall'intervallo 1-5:", len(fuori_scala))
print("-------------------------------------------------------")
print(fuori_scala.T)

# --- Controllo: le righe con lo stesso nome sono davvero la stessa app? ---

# 1) tolgo la riga sfalsata e le righe identiche, come farà la pulizia
base = grezzo[~((grezzo["Rating"] > 5) | (grezzo["Rating"] < 1))].drop_duplicates()
ripetute = base[base.duplicated("App", keep=False)]

# 2) per ogni nome ripetuto conto quante categorie e quante fasce di installazioni diverse ha
per_nome = ripetute.groupby("App").agg(righe=("App", "size"),
                                       categorie=("Category", "nunique"),
                                       fasce=("Installs", "nunique"))
esito = pd.Series("stessa categoria, stesse installazioni", index=per_nome.index)
esito[(per_nome["categorie"] > 1) & (per_nome["fasce"] == 1)] = "categoria diversa, stesse installazioni"
esito[per_nome["fasce"] > 1] = "installazioni diverse"

print(f"Righe con un nome già visto: {len(ripetute) - ripetute['App'].nunique()} "
      f"(su {ripetute['App'].nunique()} nomi)\n")
display(esito.value_counts().rename("nomi").to_frame())

# 3) i casi con installazioni diverse, per vederli in faccia
diverse = ripetute[ripetute["App"].isin(esito[esito == "installazioni diverse"].index)]
display(diverse.sort_values(["App", "Reviews"])[
    ["App", "Category", "Installs", "Reviews", "Size", "Last Updated", "Current Ver"]].head(16))

def pulisci(df):
    "Pulisce il dataset e restituisce anche il registro delle righe eliminate."
    registro = [("dataset grezzo", len(df))]

    d = df[~((df["Rating"] > 5) | (df["Rating"] < 1))].copy()   # tolgo la riga sfalsata e la registro comunque
    registro.append(("meno la riga sfalsata", len(d)))

    d = d.drop_duplicates()                                      # via le righe identiche e le registro comunque
    registro.append(("meno le righe duplicate", len(d)))

    # stessa app = stesso nome E stessa fascia di installazioni (vedi il controllo sopra):
    # della stessa app tengo la lettura con più recensioni (la più recente)
    d["Reviews"] = pd.to_numeric(d["Reviews"], errors="coerce")
    d = (d.sort_values("Reviews", ascending=False, kind="stable")
           .drop_duplicates(subset=["App", "Installs"], keep="first").sort_index())
    registro.append(("meno le letture ripetute della stessa app", len(d)))

    # conversione da stringa +10000 a valore numero intero in formato int64
    d["installazioni"] = (d["Installs"].str.replace(",", "", regex=False)
                                       .str.replace("+", "", regex=False).astype("int64"))
    # conversione da stringa $4.99 tolgo $ e converto in valore in numero in virgola mobile formato float
    d["prezzo"] = d["Price"].str.replace("$", "", regex=False).astype(float)
    # dal prezzo convertito trovo se l'app è gratis  o a pagamento attraverso la condizione >0
    d["tipo"] = np.where(d["prezzo"] > 0, "A pagamento", "Gratuita")

    #Ripulisco i valori perchè sono formati e unità di misura diverse e porto tutto in megabyte.
    #Alcuni valore sono tipo testo Varies with device  e li sostituisco con NaN
    dimensione = d["Size"].replace("Varies with device", np.nan)
    numero = pd.to_numeric(dimensione.str.rstrip("MkG"), errors="coerce")
    d["dimensione_mb"] = np.select([dimensione.str.endswith("k", na=False),
                                    dimensione.str.endswith("G", na=False)],
                                   [numero / 1024, numero * 1024], numero)

    # converto la stringa data aggiornamento in un vero oggetto data utilizzabile
    d["data_aggiornamento"] = pd.to_datetime(d["Last Updated"], format="%B %d, %Y")
    # calcolo per ogni app quanti giorni sono passati dall'ultimo aggiornamento rispetto all'app più recente
    d["giorni_da_aggiornamento"] = (d["data_aggiornamento"].max()
                                    - d["data_aggiornamento"]).dt.days
    # Costruisco una misura di "quanto le persone si esprimono", per confrontare le recensioni di app
    #molto scaricate e quindi con molte recensioni , con app meno scaricate. Moltiplico per mille per rendere più
    #leggibile il risultato a colpo d'occhio.
    d["recensioni_per_1000"] = d["Reviews"] / d["installazioni"].replace(0, np.nan) * 1000

    registro.append(("dataset pulito", len(d)))
    return d, pd.DataFrame(registro, columns=["passaggio", "righe"])

# la funzione restituisce due valori (una tupla),dividendoli in due variabili separate:
# app per il dataframe pulito e pronto all'uso, con tutte le colonne nuove appena viste.
# registro per la tabella che riassume quante righe c'erano a ogni passaggio di pulizia,
# utile per documentare/verificare il processo.
app, registro = pulisci(grezzo)

# rinomino in italiano e tengo solo le colonne che uso
app = app.rename(columns={"App": "nome", "Category": "categoria", "Rating": "voto",
                          "Reviews": "recensioni", "Content Rating": "eta_minima",
                          "Genres": "generi"})
app = app[["nome", "categoria", "voto", "recensioni", "installazioni", "tipo", "prezzo",
           "eta_minima", "generi", "dimensione_mb", "data_aggiornamento",
           "giorni_da_aggiornamento", "recensioni_per_1000"]]

display(registro)
print(f"App analizzate: {len(app):,}  ({len(app) / len(grezzo):.1%} delle righe di partenza)")
print(f"Voto disponibile per {app['voto'].notna().sum():,} app ({app['voto'].notna().mean():.1%})")
print("Controlli:",
      "voti tra 1 e 5 OK" if app["voto"].dropna().between(1, 5).all() else "VOTI FUORI SCALA",
      "| coppie nome + installazioni uniche OK"
      if not app.duplicated(["nome", "installazioni"]).any() else "| DOPPIONI")

# --- in questa parte di codice provo a verificare se le app senza voti sono un caso o è sistematico------------------

# Divido le app in due gruppi, con voto e senza voto,
# e per ciascun gruppo calcolo le relative statistiche
confronto = app.groupby(app["voto"].notna()).agg(
    numero_app=("nome", "count"),
    recensioni_mediane=("recensioni", "median"),
    installazioni_mediane=("installazioni", "median"),
)
# Rinomino le righe per renderle leggibili
confronto.index = ["senza voto", "con voto"]
display(confronto)

#confronto che restituisce True/False per ogni riga del sottoinsieme "senza voto": True se ha meno di 10 recensioni
# poi calcolo la media di una serie di True/False
senza_voto = app[app["voto"].isna()]
print(f"App senza voto con meno di 10 recensioni: {(senza_voto['recensioni'] < 10).mean():.1%}")

# salvo il dataset pulito in un nuovo file CSV
app.to_csv("playstore_pulito.csv", index=False, encoding="utf-8-sig")
print("\nDataset pulito salvato in playstore_pulito.csv")

# --- statistiche descrittive, e il rapporto media/mediana --------------
NUMERICHE = ["voto", "recensioni", "installazioni", "dimensione_mb",
             "giorni_da_aggiornamento", "recensioni_per_1000"]
display(app[NUMERICHE].describe().round(2))

# il prezzo lo lascio fuori: la sua mediana è 0 (il 92% delle app è gratuito)
riepilogo = pd.DataFrame({"media": app[NUMERICHE].mean(),
                          "mediana": app[NUMERICHE].median()})
riepilogo["media / mediana"] = riepilogo["media"] / riepilogo["mediana"]
riepilogo.sort_values("media / mediana", ascending=False).round(2)

# --- Distribuzione delle tre variabili più rilevanti: voto, recensioni ed installazioni ---

# 1) preparo una figura con 3 grafici affiancati
fig, axes = plt.subplots(1, 3, figsize=(13.5, 3.4))

# 2) Voto: istogramma, con la mediana evidenziata da una linea ARANCIONE
voti = app["voto"].dropna()
axes[0].hist(voti, bins=np.arange(1, 5.11, 0.1), color=BLU, edgecolor="white", linewidth=0.5)
axes[0].axvline(voti.median(), color=ARANCIONE, linewidth=2)
axes[0].set_xlabel("voto")
axes[0].set_ylabel("numero di app")
axes[0].set_title("Il voto è compresso verso l'alto")
axes[0].text(voti.median() - 0.1, axes[0].get_ylim()[1] * 0.9, f"mediana {voti.median()}",
             color=ARANCIONE, ha="right", fontweight="bold", fontsize=9)

# 3) RECENSIONI : istogramma in scala logaritmica
axes[1].hist(app.loc[app["recensioni"] > 0, "recensioni"], bins=np.logspace(0, 8, 40),
             color=BLU, edgecolor="white", linewidth=0.5)
axes[1].set_xscale("log")
axes[1].set_xlabel("recensioni (scala logaritmica)")
axes[1].set_ylabel("numero di app")
axes[1].set_title("Le recensioni in scala log")

# 4) INSTALLAZIONI — barre orizzontali, una per ciascuna delle 20 fasce
fasce = app["installazioni"].value_counts().sort_index()
axes[2].barh(range(len(fasce)), fasce.values, color=BLU)
axes[2].set_yticks(range(len(fasce)), [f"{v:,}" for v in fasce.index], fontsize=7)
axes[2].set_xlabel("numero di app")
axes[2].set_title("Le installazioni a fasce")


plt.tight_layout()
plt.show()
# 5) riepilogo numerico delle tre variabili più rilevanti date come argomento al print
print(f"Voto      mediana {voti.median()} | >= 4,0: {(voti >= 4).mean():.1%} | "
      f">= 4,5: {(voti >= 4.5).mean():.1%} | < 3,0: {(voti < 3).mean():.1%}")
print(f"Recensioni    mediana {app['recensioni'].median():,.0f} | "
      f"massimo {app['recensioni'].max():,.0f}")
print(f"Installazioni mediana {app['installazioni'].median():,.0f} | "
      f"fasce distinte {app['installazioni'].nunique()}")

# --- Concentrazione del mercato e modello di business (gratis o a pagamento) ---

# 1) CONCENTRAZIONE per l'1%, 10% e 50% delle app più scaricate,
#    calcolo quale quota delle installazioni totali si prendono
totale = app["installazioni"].sum()
concentrazione = pd.DataFrame([
    {"gruppo": f"top {q:.0%}",
     "numero di app": int(len(app) * q),
     "quota delle installazioni": app["installazioni"].nlargest(int(len(app) * q)).sum() / totale}
    for q in (0.01, 0.10, 0.50)
])

# 2) preparo una figura con 2 grafici affiancati
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11.5, 3.2))

# 3) GRAFICO 1:  barre orizzontali della concentrazione, col gruppo "top 1%" in evidenza
colori = [ARANCIONE if g == "top 1%" else BLU for g in concentrazione["gruppo"]]
ax1.barh(concentrazione["gruppo"], concentrazione["quota delle installazioni"] * 100,
         color=colori)
ax1.invert_yaxis()
ax1.set_xlabel("% delle installazioni totali")
ax1.set_title("L'1% delle app si prende metà del mercato")
ax1.set_xlim(0, 118)
for i, v in enumerate(concentrazione["quota delle installazioni"]):
    ax1.text(v * 100 + 1.5, i, f"{v:.1%}", va="center", fontweight="bold", fontsize=9)

# 4) GRAFICO 2:  quante app sono gratuite e quante a pagamento
conteggio_tipo = app["tipo"].value_counts()
ax2.bar(conteggio_tipo.index, conteggio_tipo.values, color=[BLU, ARANCIONE], width=0.5)
ax2.set_ylabel("numero di app")
ax2.set_title("Il 92,2% del catalogo è gratuito")
ax2.set_ylim(0, conteggio_tipo.max() * 1.2)
for i, v in enumerate(conteggio_tipo.values):
    ax2.text(i, v + 180, f"{v:,}\n{v / len(app):.1%}", ha="center", fontsize=9)

plt.tight_layout()
plt.show()

# 5) riepilogo testuale: prezzo delle app a pagamento
prezzi = app.loc[app["tipo"] == "A pagamento", "prezzo"]
print(f"App a pagamento: {len(prezzi):,} ({len(prezzi) / len(app):.2%}) | "
      f"prezzo mediano {prezzi.median():.2f} $ | il {(prezzi <= 10).mean():.1%} costa <= 10 $")

# 6) riepilogo testuale: altre caratteristiche del catalogo (dimensione, età, aggiornamenti)
print(f"Dimensione mediana {app['dimensione_mb'].median():.0f} MB | "
      f"età 'Everyone' {(app['eta_minima'] == 'Everyone').mean():.1%} | "
      f"giorni dall'ultimo aggiornamento (mediana) {app['giorni_da_aggiornamento'].median():.0f}")

# --- Applicazione della regola IQR ---
def conta_outlier(serie):
    serie = serie.dropna()
    q1, q3 = serie.quantile([0.25, 0.75])
    iqr = q3 - q1
    anomali = ((serie < q1 - 1.5 * iqr) | (serie > q3 + 1.5 * iqr)).sum()
    return pd.Series({"n outlier": anomali, "su n valori": len(serie),
                      "% outlier": 100 * anomali / len(serie)})

da_controllare = {
    "recensioni": app["recensioni"],
    "recensioni (in log)": np.log10(app["recensioni"].clip(lower=1)),
    "installazioni": app["installazioni"],
    "installazioni (in log)": np.log10(app["installazioni"].clip(lower=1)),
    "voto": app["voto"],
}
pd.DataFrame({n: conta_outlier(s) for n, s in da_controllare.items()}).T.round(2)

# --- Due casi di valori anomali, spiegati uno per uno -------------------

# 1) CASO 1: app con più recensioni che installazioni (fisicamente impossibile)
impossibili = app[app["recensioni_per_1000"] > 1000]
print(f"App con più recensioni che installazioni: {len(impossibili)} (impossibile!)")
print("È un effetto della conversione: 'Installs' diceva '1+' e io l'ho reso 1.\n")

# 2) CASO 2: app che costano 100 $ o più quanto quelle 20 app distorcono la media dei prezzi
care = app[app["prezzo"] >= 100]
print(f"App che costano 100 $ o più: {len(care)}, "
      f"di cui {care['nome'].str.contains('rich', case=False).sum()} con 'rich' nel nome")
display(care.nlargest(5, "prezzo")[["nome", "categoria", "prezzo", "installazioni", "voto"]])

a_pagamento = app[app["tipo"] == "A pagamento"]
print(f"Media dei prezzi con quelle 20 app:  {a_pagamento['prezzo'].mean():.2f} $")
print(f"Media dei prezzi senza quelle 20:    {a_pagamento.loc[a_pagamento['prezzo'] < 100, 'prezzo'].mean():.2f} $")
print(f"Mediana, in entrambi i casi:         {a_pagamento['prezzo'].median():.2f} $")

# --- Due modi di misurare quanto le variabili si muovono insieme -------
COLONNE = ["voto", "recensioni", "installazioni", "prezzo", "dimensione_mb",
           "giorni_da_aggiornamento"]
ETICHETTE = ["voto", "recensioni", "installazioni", "prezzo", "dimensione", "giorni da agg."]

# i due metodi di calcolo: il primo misura relazioni "su una retta",
# il secondo misura relazioni "per posizione in classifica" (anche se curve)
METODI = ["pearson", "spearman"]
TITOLI = ["Relazioni lineari: le due variabili crescono in proporzione?",
          "Relazioni per tendenza: le due variabili crescono insieme,\nanche se non in proporzione?"]

# 1) preparo una figura con 2 grafici affiancati
fig, axes = plt.subplots(1, 2, figsize=(12.5, 4.2))

# 2) per ciascuno dei due metodi, calcolo la matrice e la disegno come heatmap
for ax, metodo, titolo in zip(axes, METODI, TITOLI):
    matrice = app[COLONNE].corr(method=metodo)
    sns.heatmap(matrice, mask=np.triu(np.ones_like(matrice, dtype=bool), k=1),
                annot=True, fmt="+.2f", cmap="coolwarm_r", center=0, vmin=-1, vmax=1,
                square=True, linewidths=2, linecolor="white", cbar=False, ax=ax,
                xticklabels=ETICHETTE, yticklabels=ETICHETTE, annot_kws={"size": 9})
    ax.set_title(titolo)
    plt.setp(ax.get_xticklabels(), rotation=35, ha="right")

# 3) didascalia comune, per leggere i colori
fig.suptitle("Blu = crescono insieme  ·  rosso = vanno in direzioni opposte",
             fontsize=9, x=0.01, ha="left", y=1.02)
plt.tight_layout()
plt.show()

# --- Lo stesso confronto, letto in due scale diverse --------------------

# 1) calcolo quanto sono legate "recensioni" e "installazioni",
#    prima sui valori originali, poi sui loro logaritmi
coefficiente_grezzo = app[["recensioni", "installazioni"]].corr().iloc[0, 1]
coefficiente_log = np.log10(app[["recensioni", "installazioni"]].clip(lower=1)).corr().iloc[0, 1]

print(f"recensioni ~ installazioni, sui valori originali : {coefficiente_grezzo:.3f}")
print(f"recensioni ~ installazioni, sui logaritmi         : {coefficiente_log:.3f}")

# 2) preparo due grafici affiancati: a sinistra scala normale, a destra scala logaritmica
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 3.8))

# 3) disegno lo stesso grafico a punti due volte, cambiando solo la scala degli assi
for ax, log, titolo in [(ax1, False, f"Scala normale: indice = {coefficiente_grezzo:.2f}"),
                        (ax2, True, f"Scala logaritmica: indice = {coefficiente_log:.2f}")]:
    ax.scatter(app["installazioni"], app["recensioni"], s=6, alpha=0.3, color=BLU,
               linewidths=0)
    if log:
        ax.set_xscale("log")
        ax.set_yscale("log")
    ax.set_xlabel("installazioni")
    ax.set_ylabel("recensioni")
    ax.set_title(titolo)

# 4) cosa si vede nel primo grafico
ax1.text(0.3, 0.55, "i punti non stanno\nsu una retta,\nstanno su una curva",
         transform=ax1.transAxes, fontsize=9)
plt.tight_layout()
plt.show()

# --- La domanda : le app più recensite hanno anche un voto più alto? -----------------

# 1) tengo solo le app che hanno sia il voto sia il dato sul coinvolgimento,
#    e le divido in 5 gruppi di uguale numerosità (quintili), dal meno al più recensito
confronto = app.dropna(subset=["voto", "recensioni_per_1000"]).copy()
confronto["gruppo"] = pd.qcut(confronto["recensioni_per_1000"], 5,
                              labels=["Q1 meno recensite", "Q2", "Q3", "Q4",
                                      "Q5 più recensite"])

# 2) per ciascun gruppo calcolo: quante app contiene, il voto medio,
#    e il livello di coinvolgimento tipico (valore centrale del gruppo)
per_gruppo = confronto.groupby("gruppo", observed=True).agg(
    numero_app=("nome", "count"),
    voto_medio=("voto", "mean"),
    recensioni_per_1000=("recensioni_per_1000", "median"),
)
display(per_gruppo.round(2))

# 3) grafico a barre: un voto medio per ciascuno dei 5 gruppi
fig, ax = plt.subplots(figsize=(7.5, 3))
ax.bar(range(5), per_gruppo["voto_medio"], color=sns.color_palette("Blues", 5), width=0.6)
ax.set_xticks(range(5), [e.replace(" ", "\n", 1) for e in per_gruppo.index], fontsize=9)
ax.set_ylim(3.8, 4.55)
ax.set_ylabel("voto medio")
ax.set_title("Voto e coinvolgimento salgono insieme (legame, non causa)")
for i, v in enumerate(per_gruppo["voto_medio"]):
    ax.text(i, v + 0.012, f"{v:.2f}", ha="center", fontweight="bold", fontsize=10)
plt.tight_layout()
plt.show()

# 4) un indice numerico che conferma la tendenza vista nel grafico
indice = confronto[["voto", "recensioni_per_1000"]].corr(method="spearman").iloc[0, 1]
print(f"Indice di correlazione tra voto e coinvolgimento: {indice:+.3f}")

# --- Controprova con il secondo file: il tono delle recensioni scritte ---

# 1) tengo solo le recensioni che hanno il sentiment (positivo, negativo o neutro)
recensioni = recensioni_grezze.dropna(subset=["Sentiment"])

# 2) per ogni app calcolo due misure del tono delle recensioni:
#    la polarità tipica (da -1 = negativa a +1 = positiva)
#    e la percentuale di recensioni positive
per_app = recensioni.groupby("App").agg(
    polarita_mediana=("Sentiment_Polarity", "median"),
    quota_positive=("Sentiment", lambda s: (s == "Positive").mean()),
)

# 3) unisco i due file (merge) usando il nome dell'app come chiave comune,
#    e tengo solo le app che hanno anche il voto
unite = app.merge(per_app, left_on="nome", right_index=True, how="inner").dropna(subset=["voto"])

# 4) controllo se il voto in numeri e il tono delle recensioni scritte vanno d'accordo
print(f"Recensioni con sentiment: {len(recensioni):,} | app coperte: {len(unite):,} "
      f"({len(unite) / len(app):.1%} del dataset)")
print(f"Correlazione voto ~ tono del testo scritto:    "
      f"{unite[['voto', 'polarita_mediana']].corr().iloc[0, 1]:+.3f}")
print(f"Correlazione voto ~ % di recensioni positive:  "
      f"{unite[['voto', 'quota_positive']].corr().iloc[0, 1]:+.3f}")

# --- Costruisco un profilo per ciascuna categoria dello store -----------

# 1) per ogni categoria calcolo alcuni numeri di base: quante app contiene,
#    quante installazioni ha in totale, quante ne ha la sua app più scaricata,
#    il voto mediano, il coinvolgimento mediano, e da quanto non si aggiorna
per_categoria = app.groupby("categoria").agg(
    numero_app=("nome", "count"),
    installazioni_totali=("installazioni", "sum"),
    installazioni_prima_app=("installazioni", "max"),
    voto_mediano=("voto", "median"),
    recensioni_per_1000=("recensioni_per_1000", "median"),
    giorni_da_aggiornamento=("giorni_da_aggiornamento", "median"),
)

# 2) che percentuale del catalogo totale rappresenta questa categoria,
#    sia in numero di app sia in installazioni
per_categoria["quota_app"] = per_categoria["numero_app"] / per_categoria["numero_app"].sum()
per_categoria["quota_installazioni"] = (per_categoria["installazioni_totali"]
                                        / per_categoria["installazioni_totali"].sum())

# 3) la categoria riceve più o meno attenzione di quanto "pesa" nel catalogo?
#    sopra 1 = ha più installazioni di quante gliene spetterebbero in proporzione
#    sotto 1 = ne ha meno
per_categoria["domanda_su_offerta"] = (per_categoria["quota_installazioni"]
                                       / per_categoria["quota_app"])

# 4) quanto è dominata la categoria da una singola app di successo:
#    che percentuale delle sue installazioni totali prende solo la prima app
per_categoria["quota_prima_app"] = (per_categoria["installazioni_prima_app"]
                                    / per_categoria["installazioni_totali"])

# 5) due indicatori in più: che percentuale di app supera il milione di
#    installazioni, e che percentuale è a pagamento
per_categoria["quota_oltre_1M"] = app.groupby("categoria")["installazioni"].apply(
    lambda s: (s >= 1_000_000).mean())
per_categoria["quota_a_pagamento"] = app.groupby("categoria")["tipo"].apply(
    lambda s: (s == "A pagamento").mean())

# 6) riepilogo generale, e tabella delle 8 categorie con più app
print(f"{len(per_categoria)} categorie, {per_categoria['numero_app'].sum():,} app")
per_categoria.sort_values("numero_app", ascending=False)[
    ["numero_app", "quota_app", "quota_installazioni", "domanda_su_offerta",
     "quota_prima_app", "quota_oltre_1M", "voto_mediano"]].head(8).round(3)

# --- Tre modi di guardare la concorrenza nelle categorie ----------------

# 1) una funzione che trasforma i nomi tecnici delle categorie
#    (es. "FOOD_AND_DRINK") in nomi più semplici da leggere (es. "Food & Drink")
def nome_leggibile(categoria):
    return categoria.replace("_AND_", " & ").replace("_", " ").title()

# 2) ordino le categorie dalla più affollata alla meno affollata,
#    e preparo i nomi leggibili da usare nei grafici
ordinate = per_categoria.sort_values("numero_app", ascending=False)
nomi = [nome_leggibile(c) for c in ordinate.index]
righe = range(len(nomi))

# 3) preparo tre grafici affiancati e ravvicinati (wspace piccolo),
#    tutti con le stesse categorie sull'asse verticale
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(14, 9), sharey=True,
                                    gridspec_kw={"wspace": 0.06})

# 4) per seguire una categoria con lo sguardo da sinistra a destra:
#    una riga sì e una no ha uno sfondo grigio chiaro, uguale nei tre grafici,
#    e le righe orizzontali della griglia sono tolte per non fare confusione
for ax in (ax1, ax2, ax3):
    for r in righe:
        if r % 2 == 0:
            ax.axhspan(r - 0.5, r + 0.5, color="#eeeeec", zorder=0)
    ax.grid(axis="y", visible=False)
    ax.set_ylim(len(nomi) - 0.5, -0.5)   # stesso ordine dall'alto in basso

# 5) primo grafico: quanti concorrenti ci sono in ogni categoria
ax1.barh(righe, ordinate["numero_app"], height=0.65, zorder=2,
         color=[ARANCIONE if c in ("FAMILY", "GAME", "TOOLS") else BLU for c in ordinate.index])
ax1.set_yticks(righe, nomi, fontsize=9.5)
ax1.set_xlim(0, ordinate["numero_app"].max() * 1.15)
ax1.set_xlabel("numero di app")
ax1.set_title("Quanti concorrenti")
for r, v in zip(righe, ordinate["numero_app"]):
    ax1.text(v + 15, r, f"{v:,}".replace(",", "."), va="center", fontsize=7.5)

# 6) secondo grafico: la categoria riceve più o meno attenzione di quanto "pesa"?
#    oltre la linea nera (valore 1) = più attenzione del previsto, prima = meno
ax2.barh(righe, ordinate["domanda_su_offerta"], height=0.65, zorder=2,
         color=[VERDE if v >= 1 else GRIGIO for v in ordinate["domanda_su_offerta"]])
ax2.axvline(1, color="black", linewidth=1.1, zorder=3)
ax2.set_xlim(0, ordinate["domanda_su_offerta"].max() * 1.15)
ax2.set_xlabel("quota installazioni ÷ quota app")
ax2.set_title("Quanta attenzione ricevono")
for r, v in zip(righe, ordinate["domanda_su_offerta"]):
    ax2.text(v + 0.05, r, f"{v:.2f}".replace(".", ","), va="center", fontsize=7.5)

# 7) terzo grafico: quanto è forte il leader di ciascuna categoria
ax3.barh(righe, ordinate["quota_prima_app"] * 100, height=0.65, zorder=2,
         color=[ARANCIONE if v > 0.30 else BLU for v in ordinate["quota_prima_app"]])
ax3.set_xlim(0, ordinate["quota_prima_app"].max() * 100 * 1.15)
ax3.set_xlabel("% del mercato presa dalla prima app")
ax3.set_title("Quanto è forte il leader\n(ARANCIONE = oltre il 30%)")
for r, v in zip(righe, ordinate["quota_prima_app"]):
    ax3.text(v * 100 + 0.8, r, f"{v:.0%}", va="center", fontsize=7.5)

plt.show()

# 8) elenco testuale: chi è l'app leader nelle 6 categorie più dominate da un solo prodotto
print("La prima app nelle sei categorie più concentrate:\n")
for categoria in per_categoria.nlargest(6, "quota_prima_app").index:
    dentro = app[app["categoria"] == categoria]
    prima = dentro.loc[dentro["installazioni"].idxmax()]
    quota = prima["installazioni"] / dentro["installazioni"].sum()
    print(f"  {nome_leggibile(categoria):22s} {prima['nome'][:40]:40s} {quota:6.1%}")

# --- Dove si arriva a un pubblico grande, e dove gli utenti partecipano di più ---

# 1) ordino le categorie dalla domanda più alta alla più bassa.
#    Lo stesso ordine vale per tutti e due i grafici, così ogni categoria
#    sta alla stessa altezza a sinistra e a destra
ordinate = per_categoria.sort_values("quota_oltre_1M", ascending=False)
nomi = [nome_leggibile(c) for c in ordinate.index]
righe = range(len(nomi))

# categorie da evidenziare in arancione in ciascun grafico
DA_NOTARE_DOMANDA = ["FOOD_AND_DRINK", "HOUSE_AND_HOME", "EDUCATION", "SHOPPING"]
DA_NOTARE_COINVOLGIMENTO = ["GAME", "EDUCATION", "HEALTH_AND_FITNESS"]

# i due valori di riferimento dello store, disegnati come linea nera
media_oltre_1M = (app["installazioni"] >= 1e6).mean() * 100
mediana_coinvolgimento = app["recensioni_per_1000"].median()

# 2) preparo due grafici affiancati e ravvicinati, con le stesse categorie in verticale
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 9), sharey=True,
                               gridspec_kw={"wspace": 0.06})

# 3) una riga sì e una no con lo sfondo grigio chiaro, uguale nei due grafici,
#    per seguire una categoria con lo sguardo da sinistra a destra
for ax in (ax1, ax2):
    for r in righe:
        if r % 2 == 0:
            ax.axhspan(r - 0.5, r + 0.5, color="#eeeeec", zorder=0)
    ax.grid(axis="y", visible=False)
    ax.set_ylim(len(nomi) - 0.5, -0.5)   # stesso ordine dall'alto in basso

# 4) primo grafico — DOMANDA: percentuale di app che supera il milione di installazioni
ax1.barh(righe, ordinate["quota_oltre_1M"] * 100, height=0.65, zorder=2,
         color=[ARANCIONE if c in DA_NOTARE_DOMANDA else BLU for c in ordinate.index])
ax1.axvline(media_oltre_1M, color="black", linewidth=1.1, zorder=3)
ax1.set_yticks(righe, nomi, fontsize=9.5)
ax1.set_xlim(0, ordinate["quota_oltre_1M"].max() * 100 * 1.15)
ax1.set_xlabel("% di app che superano il milione di installazioni")
ax1.set_title(f"Domanda\n(linea = media dello store, {media_oltre_1M:.1f}%)".replace(".", ","))
for r, v in zip(righe, ordinate["quota_oltre_1M"]):
    ax1.text(v * 100 + 0.8, r, f"{v:.0%}", va="center", fontsize=7.5)

# 5) secondo grafico — COINVOLGIMENTO: recensioni ogni 1.000 installazioni
ax2.barh(righe, ordinate["recensioni_per_1000"], height=0.65, zorder=2,
         color=[ARANCIONE if c in DA_NOTARE_COINVOLGIMENTO else BLU for c in ordinate.index])
ax2.axvline(mediana_coinvolgimento, color="black", linewidth=1.1, zorder=3)
ax2.set_xlim(0, ordinate["recensioni_per_1000"].max() * 1.15)
ax2.set_xlabel("recensioni ogni 1.000 installazioni")
ax2.set_title(f"Coinvolgimento\n(linea = valore tipico dello store, {mediana_coinvolgimento:.0f})")
for r, v in zip(righe, ordinate["recensioni_per_1000"]):
    ax2.text(v + 0.3, r, f"{v:.1f}".replace(".", ","), va="center", fontsize=7.5)

plt.show()

# --- Tutte le categorie in un solo grafico interattivo con PLOTLY ---

# il grafico si crea solo se la libreria plotly è installata
if PLOTLY:
    # 1) preparo i dati: una riga per categoria, con il nome leggibile
    dati = per_categoria.reset_index()
    dati["nome_categoria"] = dati["categoria"].map(nome_leggibile)

    # 2) grafico a bolle, dove ogni bolla è una categoria:
    #    - in orizzontale: quante app ci sono (più a destra = più concorrenza)
    #    - in verticale: quante app superano il milione (più in alto = più domanda)
    #    - grandezza della bolla: quanto gli utenti scrivono recensioni
    #    - colore: quanto è forte il leader (rosso = una sola app domina)
    figura = px.scatter(
        dati, x="numero_app", y="quota_oltre_1M",
        size="recensioni_per_1000", color="quota_prima_app",
        hover_name="nome_categoria", log_x=True, color_continuous_scale="RdYlGn_r",
        hover_data={"numero_app": ":,", "quota_oltre_1M": ":.1%",
                    "quota_prima_app": ":.1%", "categoria": False},
        labels={"numero_app": "numero di app (scala log)  →  più concorrenza",
                "quota_oltre_1M": "% oltre il milione  →  più domanda",
                "quota_prima_app": "quota della<br>prima app"},
        title="Le 33 categorie — passa il mouse su un punto")

    # 3) ritocchi grafici e visualizzazione
    figura.update_traces(marker=dict(line=dict(width=1, color="white")))
    figura.update_layout(width=860, height=500, template="simple_white")
    figura.show()
else:
    print("plotly non installato: salto il grafico interattivo.")

# --- IPOTESI 1 e 2: cosa si guadagna e cosa si perde facendo pagare un'app ---

# 1) tengo solo le app che hanno un voto
con_voto = app.dropna(subset=["voto"])

# 2) IPOTESI 1 — per app gratuite e a pagamento: quante sono e che voto hanno
h1 = con_voto.groupby("tipo")["voto"].agg(numero_app="count", voto_medio="mean",
                                          voto_mediano="median").round(3)

# 3) IPOTESI 2 — per gli stessi due gruppi: installazioni tipiche
#    e percentuale di app che supera il milione
h2 = app.groupby("tipo").agg(
    installazioni_mediane=("installazioni", "median"),
    oltre_1_milione=("installazioni", lambda s: (s >= 1_000_000).mean()),
).round(3)

# 4) unisco le due tabelle e le mostro insieme
display(h1.join(h2))

# 5) preparo tre grafici affiancati
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(13.5, 3.2))

# 6) primo grafico (H1) — come si distribuiscono i voti nei due gruppi
sns.boxplot(data=con_voto, x="tipo", y="voto", ax=ax1, width=0.45,
            palette={"Gratuita": BLU, "A pagamento": ARANCIONE})
ax1.set_title("IPOTESI 1 — il voto")
ax1.set_xlabel("")

# 7) secondo grafico (IPOTESI 2) — installazioni tipiche, in scala logaritmica
ax2.bar(h2.index, h2["installazioni_mediane"], color=[ARANCIONE, BLU], width=0.5)
ax2.set_yscale("log")
ax2.set_ylabel("installazioni mediane (log)")
ax2.set_title("IPOTESI 2 — il pubblico")
ax2.set_ylim(top=h2["installazioni_mediane"].max() * 6)
for i, v in enumerate(h2["installazioni_mediane"]):
    ax2.text(i, v * 1.4, f"{v:,.0f}", ha="center", fontweight="bold")

# 8) terzo grafico (IPOTESI 2) — percentuale di app che supera il milione
ax3.bar(h2.index, h2["oltre_1_milione"] * 100, color=[ARANCIONE, BLU], width=0.5)
ax3.set_ylabel("% oltre il milione")
ax3.set_title("IPOTESI 2 — probabilità di sfondare")
ax3.set_ylim(0, 48)
for i, v in enumerate(h2["oltre_1_milione"]):
    ax3.text(i, v * 100 + 1.2, f"{v:.1%}", ha="center", fontweight="bold")

plt.tight_layout()
plt.show()

# --- IPOTESI 3: un prezzo più alto scoraggia le installazioni? ---

# 1) tengo solo le app a pagamento, escludendo le 20 app-scherzo sopra i 100 $
a_pagamento = app[(app["tipo"] == "A pagamento") & (app["prezzo"] < 100)].copy()

# 2) divido le app in 5 fasce di prezzo
a_pagamento["fascia_prezzo"] = pd.cut(
    a_pagamento["prezzo"], bins=[0, 1.49, 2.99, 5.99, 14.99, 100],
    labels=["fino a 1,49 $", "1,50–2,99 $", "3,00–5,99 $", "6,00–14,99 $", "15 $ e oltre"])

# 3) per ogni fascia calcolo: quante app ci sono, le installazioni tipiche
#    e la percentuale di app che supera le 10.000 installazioni
h3 = a_pagamento.groupby("fascia_prezzo", observed=True).agg(
    numero_app=("nome", "count"),
    installazioni_mediane=("installazioni", "median"),
    oltre_10_mila=("installazioni", lambda s: (s >= 10_000).mean()),
)
display(h3.round(3))

# 4) grafico a barre: percentuale di app oltre le 10.000 installazioni, per fascia
fig, ax = plt.subplots(figsize=(8, 3))
ax.bar(range(len(h3)), h3["oltre_10_mila"] * 100, width=0.6,
       color=[ARANCIONE if f == "1,50–2,99 $" else BLU for f in h3.index])
ax.set_xticks(range(len(h3)), h3.index)
ax.set_ylabel("% oltre le 10.000\ninstallazioni")
ax.set_title("IPOTESI 3 — non è una discesa: è una gobba")
ax.set_ylim(0, 58)
for i, (v, n) in enumerate(zip(h3["oltre_10_mila"], h3["numero_app"])):
    ax.text(i, v * 100 + 1.5, f"{v:.0%}\n({n} app)", ha="center", fontsize=9)
plt.tight_layout()
plt.show()

# 5) un indice che riassume se prezzo e installazioni crescono insieme oppure no
indice = a_pagamento[["prezzo", "installazioni"]].corr(method="spearman").iloc[0, 1]
print(f"Indice di correlazione tra prezzo e installazioni: {indice:+.3f}")

# --- Controprova per l'IPOTESI 3: dentro ogni fascia di prezzo ci sono le stesse app? ---

# per ogni fascia, che percentuale delle app viene da ciascuna categoria
composizione = pd.crosstab(a_pagamento["fascia_prezzo"], a_pagamento["categoria"],
                           normalize="index")

# le tre categorie più presenti in ogni fascia
prime_tre = pd.DataFrame({
    fascia: [f"{nome_leggibile(c) if 'nome_leggibile' in globals() else c} {q:.0%}"
             for c, q in riga.nlargest(3).items()]
    for fascia, riga in composizione.iterrows()
}, index=["1ª categoria", "2ª categoria", "3ª categoria"]).T
display(prime_tre)

print(f"Temi grafici (PERSONALIZATION) nella fascia fino a 1,49 $: "
      f"{composizione.loc['fino a 1,49 $', 'PERSONALIZATION']:.0%} | "
      f"app mediche (MEDICAL) sopra i 15 $: {composizione.loc['15 $ e oltre', 'MEDICAL']:.0%}")

# --- IPOTESI 4 e 5: contano gli aggiornamenti? E conta la categoria? ---

# 1) tengo solo le app con un voto e le divido in 5 fasce,
#    secondo il tempo passato dall'ultimo aggiornamento
con_voto = app.dropna(subset=["voto"]).copy()
con_voto["eta_aggiornamento"] = pd.cut(
    con_voto["giorni_da_aggiornamento"], bins=[-1, 30, 90, 180, 365, 10_000],
    labels=["< 1 mese", "1–3 mesi", "3–6 mesi", "6–12 mesi", "oltre 1 anno"])

# 2) IPOTESI 4 — per ogni fascia: quante app ci sono e qual è il voto medio
h4 = con_voto.groupby("eta_aggiornamento", observed=True).agg(
    numero_app=("nome", "count"), voto_medio=("voto", "mean"))

# 3) IPOTESI 5 — per ogni categoria con almeno 30 app votate: il voto tipico,
#    con le categorie ordinate dalla migliore alla peggiore
categorie_grandi = (con_voto.groupby("categoria")["voto"].agg(["count", "median"])
                    .query("count >= 30").sort_values("median", ascending=False))

# 4) preparo due grafici affiancati (il secondo un po' più largo)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13.5, 4.2),
                               gridspec_kw={"width_ratios": [1, 1.25]})

# 5) primo grafico (IPOTESI 4) — voto medio per fascia di aggiornamento
ax1.bar(range(len(h4)), h4["voto_medio"], color=sns.color_palette("Blues_r", len(h4)),
        width=0.6)
ax1.set_xticks(range(len(h4)), h4.index, rotation=20, ha="right")
ax1.set_ylim(3.9, 4.35)
ax1.set_ylabel("voto medio")
ax1.set_title("H4 — più tempo passa, più il voto scende")
for i, v in enumerate(h4["voto_medio"]):
    ax1.text(i, v + 0.008, f"{v:.2f}", ha="center", fontsize=9, fontweight="bold")

# 6) secondo grafico (IPOTESI 5) — i voti di ogni categoria, con una linea arancione
#    sul voto tipico di tutto lo store
sns.boxplot(data=con_voto[con_voto["categoria"].isin(categorie_grandi.index)],
            y="categoria", x="voto", order=categorie_grandi.index, ax=ax2,
            color=BLU, width=0.6, fliersize=1, linewidth=0.7)
ax2.axvline(app["voto"].median(), color=ARANCIONE, linewidth=1.5)
ax2.set_yticks(range(len(categorie_grandi)),
               [nome_leggibile(c) for c in categorie_grandi.index], fontsize=7)
ax2.set_ylabel("")
ax2.set_xlim(1, 5.1)
ax2.set_title("IPOTESI 5 — le mediane vanno da 4,1 a 4,5")

plt.tight_layout()
plt.show()

# 7) riepilogo numerico delle due ipotesi
print(f"IPOTESI 4: voto medio con aggiornamento < 1 mese {h4['voto_medio'].iloc[0]:.2f} | "
      f"oltre 1 anno {h4['voto_medio'].iloc[-1]:.2f}")
print(f"IPOTESI 5: escursione delle mediane fra {len(categorie_grandi)} categorie: "
      f"{categorie_grandi['median'].max() - categorie_grandi['median'].min():.1f} punti")