Analisi delle Campagne Email con Python: Una Guida Passo Passo

Introduzione

In questo articolo, esploreremo come utilizzare Python e la libreria Pandas per analizzare i dati di una campagna email e ricavare informazioni preziose sulle sue performance. Il codice fornito ci permette di calcolare metriche chiave come il tasso di apertura, il tasso di clic e di visualizzare i risultati in modo chiaro attraverso grafici.

Il Dataset

Il dataset che utilizziamo contiene informazioni dettagliate su ciascuna email inviata, come:

• ID email: Un identificativo unico per ogni email.
• Oggetto: L’oggetto dell’email.
• Aperta: Indica se l’email è stata aperta (1) o meno (0).
• Cliccata: Indica se è stato cliccato un link nell’email (1) o meno (0).
• Segmento: Il segmento a cui appartiene il destinatario.
• Dispositivo: Il dispositivo utilizzato per aprire l’email.
• Sistema operativo: Il sistema operativo utilizzato.
• Paese: Il paese del destinatario.
• Data di invio: La data in cui l’email è stata inviata.
• Immagine: Indica se l’email contiene un’immagine (1) o meno (0).
• Nome campagna: Il nome della campagna.

Qui sotto trovate il codice per generare un file .CSV di prova,

import pandas as pd
import numpy as np

# Crea un DataFrame con dati casuali più dettagliati
data = {'email_id': np.arange(1000),
'subject_line': ['Promozione Estiva' for _ in range(300)] + ['Nuovi Prodotti' for _ in range(300)] + ['Saldi Invernali' for _ in range(400)],
'opened': np.random.choice([0, 1], size=1000),
'clicked': np.random.choice([0, 1], size=1000, p=[0.8, 0.2]),
'segment': np.random.choice(['Giovani', 'Professionisti', 'Famiglie'], size=1000),
'device': np.random.choice(['mobile', 'desktop', 'tablet'], size=1000),
'os': np.random.choice(['iOS', 'Android', 'Windows', 'macOS'], size=1000),
'country': np.random.choice(['Italia', 'Francia', 'Spagna', 'Germania'], size=1000),
'send_date': pd.to_datetime('today') - pd.to_timedelta(np.random.randint(0, 30), unit='d'),
'has_image': np.random.choice([0, 1], size=1000),
'campaign_name': np.random.choice(['Estate', 'NuoviArrivi', 'Inverno'], size=1000)}

df = pd.DataFrame(data)

# Salva il DataFrame come file CSV
df.to_csv('email_campaign_data_complex.csv', index=False)

 

altrimenti potete scaricarlo direttamente  qui sotto:

email_campaign_data_complex

 

Il Codice spiegato passo per passo:

1. Importazione delle librerie:

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

• Pandas: Utilizzata per la manipolazione dei dati.
• NumPy: Fornisce funzioni matematiche e strumenti per lavorare con array.
• Matplotlib e Seaborn: Librerie per la visualizzazione dei dati.

2. Caricamento dei dati:

df = pd.read_csv('email_campaign_data_complex.csv')

Carichiamo il dataset CSV in un DataFrame Pandas, che è essenzialmente una tabella strutturata.

3. Calcolo delle metriche globali: Calcoliamo il numero totale di email inviate, il tasso di apertura, il tasso di clic e il tasso di clic su apertura.

4. Analisi per segmento: Raggruppiamo i dati per segmento e calcoliamo le metriche per ciascun segmento. Visualizziamo i risultati in un grafico a barre per confrontare le performance dei diversi segmenti.

5. Analisi temporale: Analizziamo come le performance variano in base al giorno della settimana in cui l’email è stata inviata.

Cosa possiamo fare con questo codice?

• Identificare i segmenti più performanti: Capire quali segmenti rispondono meglio alle campagne.
• Ottimizzare il timing: Determinare i giorni della settimana migliori per inviare le email.
• Valutare l’impatto del contenuto: Confrontare le performance di email con diversi soggetti o contenuti.
• Misurare l’efficacia delle campagne: Valutare il successo complessivo di ciascuna campagna.

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

# Carica il DataFrame (assicurati di sostituire 'email_campaign_data_complex.csv' con il tuo percorso)
df = pd.read_csv('email_campaign_data_complex.csv')

# Calcolo delle metriche globali
total_emails = len(df)
opened_emails = df['opened'].sum()
clicked_emails = df['clicked'].sum()

open_rate = (opened_emails / total_emails) * 100
click_through_rate = (clicked_emails / total_emails) * 100
click_to_open_rate = (clicked_emails / opened_emails) * 100 if opened_emails > 0 else 0

print(f"Totale email inviate: {total_emails}")
print(f"Tasso di apertura: {open_rate:.2f}%")
print(f"Tasso di clic: {click_through_rate:.2f}%")
print(f"Tasso di clic su apertura: {click_to_open_rate:.2f}%")

# Analisi per segmento
segment_analysis = df.groupby('segment').agg({
'opened': 'sum',
'clicked': 'sum',
'email_id': 'count'
}).rename(columns={'email_id': 'total_emails'})

segment_analysis['open_rate'] = (segment_analysis['opened'] / segment_analysis['total_emails']) * 100
segment_analysis['click_through_rate'] = (segment_analysis['clicked'] / segment_analysis['total_emails']) * 100
segment_analysis['click_to_open_rate'] = (segment_analysis['clicked'] / segment_analysis['opened']) * 100

# Visualizzazione del tasso di apertura per segmento
sns.barplot(x=segment_analysis.index, y='open_rate', data=segment_analysis)
plt.title('Tasso di apertura per segmento')
plt.show()




# Analisi temporale 
df['send_date'] = pd.to_datetime(df['send_date'])
df['send_day'] = df['send_date'].dt.day_name()

day_analysis = df.groupby('send_day').agg({
'opened': 'sum',
'clicked': 'sum',
'email_id': 'count'
}).rename(columns={'email_id': 'total_emails'})

Il risultato

Le analisi per dispositivo, sistema operativo e campagna sono fondamentali per comprendere a fondo le performance delle tue campagne email e ottimizzare le tue strategie. Vediamo come possiamo implementare queste analisi nel nostro codice Python:

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

# Carica il DataFrame
df = pd.read_csv('email_campaign_data_complex.csv')

# Funzione per calcolare le metriche
def calculate_metrics(df, groupby_column):
"""Calcola le metriche per un gruppo di dati.

Args:
df: DataFrame con i dati.
groupby_column: Colonna per il raggruppamento (es. 'device', 'campaign_name').

Returns:
DataFrame con le metriche calcolate.
"""

grouped = df.groupby(groupby_column).agg({
'opened': 'sum',
'clicked': 'sum',
'email_id': 'count'
}).rename(columns={'email_id': 'total_emails'})

grouped['open_rate'] = (grouped['opened'] / grouped['total_emails']) * 100
grouped['click_through_rate'] = (grouped['clicked'] / grouped['total_emails']) * 100
grouped['click_to_open_rate'] = (grouped['clicked'] / grouped['opened']) * 100

return grouped

# Analisi per dispositivo
device_metrics = calculate_metrics(df, 'device')
sns.barplot(x=device_metrics.index, y='open_rate', data=device_metrics)
plt.title('Tasso di apertura per dispositivo')
plt.show()

# Analisi per sistema operativo
os_metrics = calculate_metrics(df, 'os')
sns.barplot(x=os_metrics.index, y='open_rate', data=os_metrics)
plt.title('Tasso di apertura per sistema operativo')
plt.show()

# Analisi per campagna
campaign_metrics = calculate_metrics(df, 'campaign_name')
sns.heatmap(campaign_metrics[['open_rate', 'click_through_rate']], annot=True, fmt='.2f')
plt.title('Confronto delle campagne')
plt.show()

 

Il risultato:

Tasso di apertura per dispositivo

 

Tasso di apertura per sistema operativo

Cosa ci dice questa analisi?

• Dispositivi preferiti: Identifica quali dispositivi sono più utilizzati per aprire le email.
• Ottimizzazione del contenuto: Permette di adattare il contenuto delle email in base al dispositivo (es. immagini più piccole per dispositivi mobili).
• Compatibilità: Evidenzia eventuali problemi di visualizzazione su determinati sistemi operativi.

 

Confronto delle campagne

Cosa ci dice questa analisi?

• Campagne di successo: Identifica le campagne che hanno ottenuto i migliori risultati.
• Miglioramenti: Evidenzia le aree in cui è possibile migliorare le future campagne.
• A/B testing: Supporta l’analisi dei risultati degli A/B test.

 

(46)

PubblicitàPubblicità