Analizzatore di WhatsApp | Analisi della chat di gruppo di WhatsApp utilizzando Python

import re
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import *
import datetime as dt
from matplotlib.ticker import MaxNLocator
import regex
import emoji
from seaborn import *
from heatmap import heatmap
from wordcloud import WordCloud , STOPWORDS , ImageColorGenerator
from nltk import *
da Plotly Import Express come PX

### Codice Python per estrarre la data dal file di chat 

def inizia con data e ora (S):
modello = '^ ([0-9]+) (/) ([0-9]+) (/) ([0-9][0-9]), ([0-9]+) :([0-9][0-9]) (SONO | pomeridiano) – ‘
risultato = ri.match (Modello, S)
se il risultato:
restituire vero
falso ritorno

### Modello Regex per estrarre il nome utente dell'autore.

def TrovaAutore(S):
    modelli = [
        '([w]+):',                        # First Name
        '([w]+[S]+[w]+):',              # Nome di battesimo + Last Name
        '([w]+[S]+[w]+[S]+[w]+):',    # Nome di battesimo + Secondo nome + Last Name
        '([+]D{2} D{5} D{5}):',         # Numero di cellulare (India no.)
        '([+]D{2} D{3} D{3} D{4}):',   # Numero di cellulare (Us no.)
        '([w]+)[U263A-U0001f999]+:',    # Nome ed Emoji              
    ]
    pattern = '^' + '|'.join(Modelli)
    risultato = re.match(modello, S)
    se risultato:
        return True
    return False


### Data di estrazione, Ore, Autore e messaggio dal file di chat.

def getDataPoint(linea):   
    splitLine = line.split(' - ') 
    dateTime = splitLine[0]
    Data, ora = dateTime.split(', ') 
    messaggio=" ".aderire(splitLine[1:])
    se FindAuthor(Messaggio): 
        splitMessage = message.split(': ') 
        autore = splitMessage[0] 
        messaggio=" ".aderire(splitMessage[1:])
    altro:
        author = None
    return date, tempo, autore, Messaggio

### Infine creare un dataframe e memorizzare tutti i dati all'interno di quel dataframe.

parsedData = [] # Elenco per tenere traccia dei dati in modo che possano essere utilizzati da un dataframe Pandas
### Uploading exported chat file
conversationPath="WhatsApp Chat con TE Comp 20-21 Ufficiale.txt" # chat file
with open(conversationPath, codifica="utf-8") come fp:
    ### Skipping first line of the file because contains information related to something about end-to-end encryption
    fp.readline() 
    messageBuffer = [] 
    Data, tempo, autore = Nessuno, Nessuno, None
    while True:
        linea = fp.readline() 
        se non linea: 
            break
        line = line.strip() 
        se inizia con data e ora(linea): 
            se len(messaggioBuffer) > 0: 
                parsedData.append([Data, tempo, autore, ' '.aderire(messaggioBuffer)]) 
            messageBuffer.clear() 
            Data, tempo, autore, messaggio = getDataPoint(linea) 
            messageBuffer.append(Messaggio) 
        altro:
            messageBuffer.append(linea)
df = pd.DataFrame(parsedData, colonne=['Data', 'Tempo', 'Autore', 'Messaggio']) # Inizializzazione di un Dataframe panda.
### modifica del tipo di dati di "Data" colonna.
df["Data"] = pd.to_datetime(df["Data"])

total_messages = df.shape[0]
media_messages = df[df['Messaggio'] == '<Media omessi>'].forma[0]
collegamenti = np.sum(Df. Url_Count)
Stampa("Statistiche chat di gruppo" : ')
Stampa("Numero totale di messaggi" : {}'.formato(total_messages))
Stampa("Numero totale di messaggi multimediali" : {}'.formato(media_messages))
Stampa("Numero totale di collegamenti" : {}'.formato(link))

l = df.Autore.unico()
per io nel raggio d'azione(len(io)):
  ### Filtrare i messaggi di un particolare utente
  req_df = df[df["Autore"] == l[io]]
  ### req_df conterrà i messaggi di un solo particolare utente
  Stampa(F'--> Statistiche di {io[io]} <-- ')
  ### shape stamperà il numero di righe che indirettamente significa il numero di messaggi
  Stampa("Totale messaggio inviato" : ', req_df.shape[0])
  ### Word_Count contiene parole totali in un messaggio. La somma di tutte le parole/Messaggi totali produrrà parole per messaggio
  parole_per_messaggio = (np.sum(req_df['Parola']))/req_df.shape[0]
  w_p_m = ("%.3F" % il giro(parole_per_messaggio, 2))  
  Stampa("Parole medie per messaggio" : ', w_p_m)
  ### i media sono costituiti da messaggi dei media
  media = somma(req_df["Conteggio_media"])
  Stampa("Totale messaggio multimediale inviato" : ', media)
  ### i collegamenti sono costituiti da collegamenti totali
  link = somma(req_df["Url_Count"])   
  Stampa("Totale link inviati" : ', link)   
  Stampa()
  Stampa('------------------------------------------------- ---------n')

### Word Cloud delle parole più usate nel nostro Gruppo
testo = " ".aderire(recensione per la revisione in df.Message)
wordcloud = WordCloud(stopword=STOPWORD, background_color="bianco").creare(testo)
  ### Visualizza l'immagine generata:
plt.figure( figsize=(10,5))
plt.imshow(nuvola di parole, interpolazione='bilineare')
asse.plt("spento")
plt.mostra()

### Crea un elenco di autori unici
l = df.Autore.unico()
per io nel raggio d'azione(len(io)):
  ### Filtrare i messaggi di un particolare utente
  req_df = df[df["Autore"] == l[io]]
  ### req_df conterrà i messaggi di un solo particolare utente
  Stampa(io[io],'->  ',req_df.shape[0])

l = df.Giorno.unico()
per io nel raggio d'azione(len(io)):
  ### Filtrare i messaggi di un particolare utente
  req_df = df[df["Giorno"] == l[io]]
  ### req_df conterrà i messaggi di un solo particolare utente
  Stampa(io[io],'->  ',req_df.shape[0])

### Autore più attivo nel gruppo
plt.figure(figsize=(9,6))
principalmente_attivo = df['Autore'].value_counts()
### Superiore 10 persone che sono maggiormente attive nel nostro Gruppo è : 
m_a = perlopiù_attivo.testa(10)
barre = ['UN','B','C','D',"E",'F','G','H','IO','J']
x_pos = np.arange(len(barre))
m_a.plot.bar()
plt.xlabel("Autori",fontdict={'dimensione del font': 14,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.titolo("Membro per lo più attivo del gruppo",fontdict={'dimensione del font': 20,'fontweight': 8})
plt.xticks(x_pos, barre)
plt.mostra()

### Giornata prevalentemente attiva nel gruppo
plt.figure(figsize=(8,5))
active_day = df['Giorno'].value_counts()
### Superiore 10 persone che sono maggiormente attive nel nostro Gruppo è : 
a_d = active_day.head(10)
a_d.plot.bar()
plt.xlabel('Giorno',fontdict={'dimensione del font': 12,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 12,'fontweight': 10})
plt.titolo("Giorno della settimana più attivo nel gruppo",fontdict={'dimensione del font': 18,'fontweight': 8})
plt.mostra()

### Top-10 Media Contributor del Gruppo
mm = df[df['Messaggio'] == '<Media omessi>']
mm1 = mm['Autore'].value_counts()
barre = ['UN','B','C','D',"E",'F','G','H','IO','J']
x_pos = np.arange(len(barre))
top10 = mm1.testa(10)
top10.plot.bar()
plt.xlabel("Autore",fontdict={'dimensione del font': 12,'fontweight': 10})
plt.ylabel('No. dei media',fontdict={'dimensione del font': 12,'fontweight': 10})
plt.titolo('Top-10 contributori mediatici del Gruppo',fontdict={'dimensione del font': 18,'fontweight': 8})
plt.xticks(x_pos, barre)
plt.mostra()

max_words = df[['Autore','Parola']].raggruppare per('Autore').somma()
m_w = max_words.sort_values('Parola',ascendente=Falso).testa(10)
barre = ['UN','B','C','D',"E",'F','G','H','IO','J']
x_pos = np.arange(len(barre))
m_w.plot.bar(marciume=90)
plt.xlabel('Autore')
plt.ylabel('No. di parole')
plt.titolo('Analisi dei membri che hanno utilizzato max. no. di parole nei suoi messaggi')
plt.xticks(x_pos, barre)
plt.mostra()

### Membro che ha condiviso un numero massimo di link nel gruppo 
max_words = df[['Autore','Url_Count']].raggruppare per('Autore').somma()
m_w = max_words.sort_values('Url_Count',ascendente=Falso).testa(10)
barre = ['UN','B','C','D',"E",'F','G','H','IO','J']
x_pos = np.arange(len(barre))
m_w.plot.bar(marciume=90)
plt.xlabel('Autore')
plt.ylabel('No. di link')
plt.titolo('Analisi del membro che ha condiviso max no. di link nel Gruppo')
plt.xticks(x_pos, barre)
plt.mostra()

### Ora ogni volta che il nostro gruppo è molto attivo
plt.figure(figsize=(8,5))
t = df['Tempo'].value_counts().testa(20)
tx = t.plot.bar()
tx.yaxis.set_major_locator(MaxNLocator(integer=True))  #Converting y axis data to integer
plt.xlabel('Tempo',fontdict={'dimensione del font': 12,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 12,'fontweight': 10})
plt.titolo("Analisi del tempo in cui il Gruppo era molto attivo.",fontdict={'dimensione del font': 18,'fontweight': 8})
plt.mostra()

### Ora del giorno più adatta, ogni volta che ci saranno più possibilità di ottenere risposta dai membri del gruppo.
plt.figure(figsize=(8,5))
std_time = df['Ore'].value_counts().testa(15)
s_T = std_time.plot.bar()
s_T.yaxis.set_major_locator(MaxNLocator(integer=True))  #Converting y axis data to integer
plt.xlabel(«Orari di apertura (24-Ora)',fontdict={'dimensione del font': 12,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 12,'fontweight': 10})
plt.titolo("Ora del giorno più adatta.",fontdict={'dimensione del font': 18,'fontweight': 8})
plt.mostra()

active_m = [elenco dei membri Top-10 altamente attivi]
per io nel raggio d'azione(len(active_m)) :
    # Filtering out messages of particular user
    m_chat = df[df["Autore"] == active_m[io]]
    Stampa(F'--- Autore :  {active_m[io]} --- ')
    # Word Cloud of mostly used word in our Group
    msg = ' '.join(x per x in m_chat. Messaggio)
    wordcloud = WordCloud(stopword=STOPWORD, background_color="bianco").creare(msg)
    plt.figure(figsize=(10,5))
    plt.imshow(nuvola di parole, interpolazione='bilineare')
    asse.plt("spento")
    plt.mostra()
    Stampa('____________________________________________________________________________________n')

### Data in cui il nostro Gruppo è stato molto attivo.
plt.figure(figsize=(8,5))
df['Data'].value_counts().testa(15).trama.bar()
plt.xlabel('Data',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.titolo("Analisi della data in cui il gruppo era molto attivo",fontdict={'dimensione del font': 18,'fontweight': 8})
plt.mostra()

z = df['Data'].value_counts() 
z1 = z.to_dict() #converts to dictionary
df['Msg_count'] = df['Data'].carta geografica(z1 ·)
### Trama di Timeseries 
fig = px.line(x=df['Data'],y=df['Msg_count'])
fig.update_layout(titolo="Analisi del numero di messaggi"s usando la trama di TimeSeries.',
                  xaxis_title="Mese",
                  yaxis_title="No. di Messaggi")
fig.update_xaxes(nticks=20)
fig.mostra()

### Mese per lo più attivo 
plt.figure(figsize=(12,6))
active_month = df['Month_Year'].value_counts()
a_m = active_month
a_m.plot.bar()
plt.xlabel('Mese',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.titolo("Analisi del mese per lo più attivo.",fontdict={'dimensione del font': 20,
        'fontweight': 8})
plt.mostra()

z = df['Month_Year'].value_counts() 
z1 = z.to_dict() #converts to dictionary
df['Msg_count_monthly'] = df['Month_Year'].carta geografica(z1 ·)
plt.figure(figsize=(18,9))
sns.set_style("darkgrid")
sns.lineplot(dati=df,x='Month_Year',y='Msg_count_monthly',marcatori=Vero,marcatore="oh")
plt.xlabel('Mese',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.titolo("Analisi del mese per lo più attivo utilizzando il grafico a linee.",fontdict={'dimensione del font': 20,'fontweight': 8})
plt.mostra()

### Messaggio totale all'anno
### Mentre analizziamo che il gruppo è stato creato a metà 2019, ecco perché numero di messaggi in 2019 è meno.
plt.figure(figsize=(12,6))
active_month = df['Anno'].value_counts()
a_m = active_month
a_m.plot.bar()
plt.xlabel('Anno',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.ylabel('No. di messaggi',fontdict={'dimensione del font': 14,'fontweight': 10})
plt.titolo('Analisi dell'anno per lo più attivo.',fontdict={'dimensione del font': 20,'fontweight': 8})
plt.mostra()