introduction
Aujourd'hui, l'une des plateformes de médias sociaux à la mode est .... devinez quoi? Un seul WhatsApp😅. C'est l'une des plateformes de médias sociaux préférées parmi nous tous en raison de ses caractéristiques attrayantes. A plus que 2 un milliard d'utilisateurs dans le monde et « Selon un sondage, un utilisateur moyen dépense plus que 195 minutes par semaine sur WhatsApp ». À quel point la déclaration ci-dessus est-elle terrible. Laissez tomber toutes ces choses et comprenons ce que signifie vraiment l'analyseur WhatsApp.
WhatsApp Analyzer signifie que nous analysons nos activités de groupe WhatsApp. Gardez une trace de notre conversation et analysez combien de temps nous passons ou disons cela « nous gaspillons » sur whatsapp. Le but de cet article est de fournir un guide étape par étape pour créer notre propre analyseur WhatsApp à l'aide de Python.. Ici, j'ai utilisé différentes bibliothèques Python qui m'aident à extraire des informations utiles des données brutes. Ici, je choisis mon groupe WhatsApp officiel de l'université pour analyser le modèle que les étudiants suivaient, donc dans certains des instantanés je supprime les coordonnées de mes professeurs d'université et de mes camarades de classe, Désolé. Nous allons commencer…
Bibliothèques requises:
- Regex
- Pandas
- Matplotlib
- Numpy
- Seaborn
- Date et heure
- Emoji
- Mot nuage
- Heatmapz
- NLTK
- comploter
Nous importons toutes ces bibliothèques:
importation re importer des pandas au format pd importer numpy en tant que np importer matplotlib.pyplot en tant que plt importer seaborn comme sns à partir de l'importation datetime * importer la date et l'heure en tant que dt depuis matplotlib.ticker importer MaxNLocator regex d'importation importer des emoji d'importation maritime * à partir de la carte thermique importer la carte thermique à partir de wordcloud importer WordCloud , MOTS CLÉS , ImageColorGenerator à partir de l'importation nltk * de plotly importer express en px
WhatsApp nous donne la fonction d'exporter les chats, alors exportons le chat et enregistrons le fichier. Au pas 2, nous allons créer un programme Python qui extraira la date, le nom d'utilisateur de l'auteur, l'heure, les messages du fichier de discussion exporté et créer un bloc de données, et y stockera toutes les données. En réalité, la collecte de données et la partie de pré-traitement sont couvertes à l'étape 2 et dans les étapes suivantes.
Extrayons toutes les informations utiles. à partir du fichier de discussion en utilisant regex:
### Code Python pour extraire la date du fichier de discussion
def commenceAvecDateEtHeure (s):
patrón = ‘^ ([0-9]+) (/) ([0-9]+) (/) ([0-9][0-9]), ([0-9]+) :([0-9][0-9]) (UN M | PM) – ‘
résultat = re.match (Modèle, s)
si le résultat:
retourner vrai
faux retour
### Modèle Regex pour extraire le nom d'utilisateur de l'auteur.
def RechercherAuteur(s):
motifs = [
'([w]+):', # First Name
'([w]+[s]+[w]+):', # Prénom + Last Name
'([w]+[s]+[w]+[s]+[w]+):', # Prénom + Deuxième nom + Last Name
'([+]ré{2} ré{5} ré{5}):', # Numéro de portable (Inde non.)
'([+]ré{2} ré{3} ré{3} ré{4}):', # Numéro de portable (US non.)
'([w]+)[u263a-U0001f999]+:', # Nom et Emoji
]
pattern = '^' + '|'.join(motifs)
résultat = re.match(modèle, s)
si résultat:
retourner vrai
retourner Faux
### Date d'extraction, Temps, Auteur et message du fichier de discussion.
def getDataPoint(ligne):
splitLine = ligne.split(' - ')
dateHeure = splitLine[0]
Date, heure = dateHeure.split(', ')
message=" ".rejoindre(splitLine[1:])
si FindAuteur(un message):
splitMessage = message.split(': ')
auteur = splitMessage[0]
message=" ".rejoindre(splitMessage[1:])
autre:
auteur = aucun
date de retour, temps, auteur, un message
### Enfin créer un dataframe et stocker toutes les données à l'intérieur de ce dataframe.
parsedData = [] # Liste pour garder une trace des données afin qu'elles puissent être utilisées par une trame de données Pandas
### Téléchargement du fichier de discussion exporté
chemin de conversation="Chat WhatsApp avec TE Comp 20-21 Officiel.txt" # fichier de discussion
avec ouvert(chemin de la conversation, encodage="utf-8") comme fp:
### Ignorer la première ligne du fichier car il contient des informations relatives au chiffrement de bout en bout
fp.readline()
MessageBuffer = []
Date, temps, auteur = aucun, Rien, Rien
tandis que vrai:
ligne = fp.readline()
sinon ligne:
Pause
ligne = ligne.strip()
si commenceAvecDateEtHeure(ligne):
si len(tampon de message) > 0:
parsedData.append([Date, temps, auteur, ' '.join(tampon de message)])
messageBuffer.clear()
Date, temps, auteur, message = getDataPoint(ligne)
messageBuffer.append(un message)
autre:
messageBuffer.append(ligne)
df = pd.DataFrame(parsedData, colonnes=['Date', 'Time', 'Author', 'Message']) # Initialisation d'un Dataframe pandas.
### modification du type de données de "Date" colonne.
df["Date"] = pd.to_datetime(df["Date"])
Premier, regardez notre ensemble de données sur les nouveau-nés:
À présent, vérifions les informations de base de notre ensemble de données et nettoyons l'ensemble de données:
### Vérification de la forme de base de donnéesUn "base de données" ou ensemble de données est une collection structurée d’informations, qui peut être utilisé pour l’analyse statistique, Apprentissage automatique ou recherche. Les ensembles de données peuvent inclure des variables numériques, catégorique ou textuelle, Et leur qualité est cruciale pour des résultats fiables. Son utilisation s’étend à diverses disciplines, comme la médecine, Économie et sciences sociales, faciliter la prise de décision éclairée et l’élaboration de modèles prédictifs..... df.forme ### Vérification des informations de base de l'ensemble de données df.info() ### Vérification non. de nulLe terme "NUL" Il est utilisé en programmation et dans les bases de données pour représenter une valeur nulle ou inexistante. Sa fonction principale est d’indiquer qu’une variable n’a pas de valeur qui lui est attribuée ou qu’une donnée n’est pas disponible. Et SQL, par exemple, Utilisé pour gérer les enregistrements qui manquent d’informations dans certaines colonnes. Comprendre l’utilisation de "NUL" Il est essentiel d’éviter les erreurs de manipulation des données et... Valeurs dans l’ensemble de données df.isnull().somme() ### Vérification de la partie principale de l'ensemble de données df.head(50) ### Vérification de la queue de l'ensemble de données df.queue(50) ### Suppression des valeurs Nan de l'ensemble de données df = df.dropna() df = df.reset_index(drop=Vrai) df.forme ### Vérification non. d'auteurs de groupe df['Author'].nuniquam() ### Vérification des auteurs du groupe df['Author'].unique()
À présent, nous pré-traitons notre ensemble de données et essayons d'en extraire des informations utiles:
### Ajout d'une colonne supplémentaire de "Jour" pour une meilleure analyse, ici, nous utilisons la bibliothèque datetime qui nous aide à faire cette tâche facilement.
semaines = {
0 : 'Monday',
1 : 'Tuesday',
2 : 'Wednesday',
3 : 'Thrusday',
4 : 'Friday',
5 : 'Saturday',
6 : 'Sunday'
}
df['Day'] = df['Date'].dt.weekday.map(semaines)
### Réorganiser les colonnes pour une meilleure compréhension
df = df[['Date','Day','Time','Author','Message']]
### Modification du type de données de la colonne "Jour".
df['Day'] = df['Day'].astype('category')
### À la recherche d'un ensemble de données sur les nouveau-nés.
df.head()
### Compter le nombre de lettres dans chaque message
df['Letter's'] = df['Message'].appliquer(lambda s : longueur(s))
### Counting number of word's in each message
df['Word's'] = df['Message'].appliquer(lambda s : longueur(s.divisé(' ')))
### Fonction pour compter le nombre de liens dans l'ensemble de données, il ajoutera une colonne supplémentaire et y stockera des informations.
URLPATTERN = r'(https?://S+)'
df['Url_Count'] = df.Message.apply(lambda x: re.trouver(URLMODÈLE, X)).str.len()
liens = np.sum(df.Url_Count)
### Fonction pour compter le nombre de médias dans le chat.
MEDIAPATTERN = r'<Média omis>'
df['Media_Count'] = df.Message.apply(lambda x : re.trouver(MOTIF MÉDIA, X)).str.len()
média = np.sum(df.Media_Count)
### À la recherche d'un ensemble de données mis à jour
df
Extraire les statistiques de base de l'ensemble de données:
total_messages = df.shape[0] media_messages = df[df['Message'] == '<Média omis>'].forme[0] liens = np.sum(df.Url_Count) imprimer('Group Chatting Stats : ') imprimer('Total Number of Messages : {}'.format(total_messages)) imprimer('Total Number of Media Messages : {}'.format(media_messages)) imprimer('Total Number of Links : {}'.format(liens))
Extraire les statistiques de base de chaque utilisateur:
l = df.Auteur.unique() pour moi à portée(longueur(je)): ### Filtrage des messages d'un utilisateur particulier req_df = df[df["Auteur"] == je[je]] ### req_df contiendra les messages d'un seul utilisateur particulier imprimer(f'--> Statistiques de {je[je]} <-- ') ### shape imprimera le nombre de lignes, ce qui signifie indirectement le nombre de messages imprimer('Total Message Sent : ', req_df.shape[0]) ### Word_Count contient le nombre total de mots dans un message. La somme de tous les mots/le nombre total de messages donnera des mots par message mots_par_message = (np.sum(req_df['Word's']))/req_df.shape[0] w_p_m = ("%.3F" % tour(mots_par_message, 2)) imprimer('Average Words per Message : ', w_p_m) ### les médias se composent de messages médiatiques média = somme(req_df["Media_Count"]) imprimer('Total Media Message Sent : ', médias) ### les liens se composent de liens totaux liens = somme(req_df["Url_Count"]) imprimer('Total Links Sent : ', liens) imprimer() imprimer('----------------------------------------------------------n')
Créons un nuage de mots avec les mots les plus utilisés dans le chat:
### Nuage de mots des mots les plus utilisés dans notre groupe
texte = " ".rejoindre(examen pour examen dans df.Message)
nuage de mots = nuage de mots(mots vides=mots vides, background_color="blanche").produire(texte)
### Afficher l'image générée:
plt.figure( taille de la figue=(10,5))
plt.imshow(mot nuage, interpolation='bilinéaire')
plt.axis("désactivé")
plt.show()
Imprimons le nombre total.. de messages envoyés par chaque utilisateur:
### Crée une liste d'auteurs uniques
l = df.Auteur.unique()
pour moi à portée(longueur(je)):
### Filtrage des messages d'un utilisateur particulier
req_df = df[df["Auteur"] == je[je]]
### req_df contiendra les messages d'un seul utilisateur particulier
imprimer(je[je],' -> ',req_df.shape[0])
Nous imprimons le total des messages envoyés chaque jour de la semaine:
l = df.Jour.unique()
pour moi à portée(longueur(je)):
### Filtrage des messages d'un utilisateur particulier
req_df = df[df["Jour"] == je[je]]
### req_df contiendra les messages d'un seul utilisateur particulier
imprimer(je[je],' -> ',req_df.shape[0])
Finalement, nous avons extrait suffisamment d'informations textuelles du fichier de discussion, Commençons maintenant la partie Data Visualization qui nous aidera à mieux analyser et comprendre toutes les analyses que nous avons effectuées sur notre fichier de discussion exporté.. A la place des numéros de contact, J'ai utilisé des alphabets pour des raisons de sécurité, Je suis desolé.
Voyons qui est l'auteur le plus actif du groupe:
### Auteur majoritairement actif dans le groupe plt.figure(taille de la figue=(9,6)) la plupart du temps_actif = df['Author'].value_counts() ### Sommet 10 personnes qui sont majoritairement actives dans notre Groupe est : m_a = principalement_active.head(10) barres = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(longueur(barres)) m_a.plot.bar() plt.xlabel('Authors',fontdict={'fontsize': 14,'fontweight': 10}) plt.ylabel('Non. of messages',fontdict={'fontsize': 14,'fontweight': 10}) plt.titre('Mostly active member of Group',fontdict={'fontsize': 20,'fontweight': 8}) plt.xticks(x_pos, barres) plt.show()
Regardons le jour le plus actif d'une semaine:
### Journée majoritairement active dans le groupe plt.figure(taille de la figue=(8,5)) jour_actif = df['Day'].value_counts() ### Sommet 10 personnes qui sont majoritairement actives dans notre Groupe est : a_d = jour_actif.head(10) a_d.plot.bar() plt.xlabel('Day',fontdict={'fontsize': 12,'fontweight': 10}) plt.ylabel('Non. of messages',fontdict={'fontsize': 12,'fontweight': 10}) plt.titre('Mostly active day of Week in the Group',fontdict={'fontsize': 18,'fontweight': 8}) plt.show()
Regardons le Top 10 des contributeurs médias du groupe:
### Top 10 des contributeurs médias du groupe mm = df[df['Message'] == '<Média omis>'] mm1 = mm['Author'].value_counts() barres = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(longueur(barres)) top10 = mm1.tête(10) top10.plot.bar() plt.xlabel('Author's',fontdict={'fontsize': 12,'fontweight': 10}) plt.ylabel('Non. of media',fontdict={'fontsize': 12,'fontweight': 10}) plt.titre('Top-10 media contributor of Group',fontdict={'fontsize': 18,'fontweight': 8}) plt.xticks(x_pos, barres) plt.show()
Les mots sont, bien sûr, l'arme la plus puissante du monde, alors voyons qui a cette arme puissante dans le groupe😅:
max_mots = df[['Author','Word's']].par groupe('Author').somme() m_w = max_words.sort_values('Word's',ascendant=Faux).diriger(10) barres = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(longueur(barres)) m_w.plot.bar(pourriture=90) plt.xlabel('Author') plt.ylabel('Non. of words') plt.titre('Analysis of members who has used max. non. of words in his/her messages') plt.xticks(x_pos, barres) plt.show()
Regardons l'auteur du Top 10 qui a partagé le nombre maximum. de liens dans le groupe:
### Membre qui a partagé un nombre maximum de liens dans le groupe max_mots = df[['Author','Url_Count']].par groupe('Author').somme() m_w = max_words.sort_values('Url_Count',ascendant=Faux).diriger(10) barres = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(longueur(barres)) m_w.plot.bar(pourriture=90) plt.xlabel('Author') plt.ylabel('Non. of link's') plt.titre('Analysis of member's who has shared max no. of link's in Group') plt.xticks(x_pos, barres) plt.show()
Voyons l'heure à chaque fois que le groupe était très actif:
### Moment où notre groupe est très actif
plt.figure(taille de la figue=(8,5))
t = df['Time'].value_counts().diriger(20)
tx = t.plot.bar()
tx.yaxis.set_major_locator(MaxNLocator(entier=Vrai)) #Conversion des données de l'axe y en entier
plt.xlabel('Time',fontdict={'fontsize': 12,'fontweight': 10})
plt.ylabel('Non. of messages',fontdict={'fontsize': 12,'fontweight': 10})
plt.titre('Analysis of time when Group was highly active.',fontdict={'fontsize': 18,'fontweight': 8})
plt.show()
Conversion de format 12 heures à 24 heures nous aideront à effectuer une meilleure analyse:
lst = [] pour moi dans df['Time'] : out_time = datetime.strftime(datetime.strptime(je,"%je:%M %p"),"%H:%M") lst.append(out_time) df['24H_Time'] = premier df['Hours'] = df['24H_Time'].appliquer(lambda x : x.split(':')[0])
Passons en revue le moment de la journée le plus approprié où il y a une meilleure chance d'obtenir une réponse des membres du groupe:
### Heure de la journée la plus appropriée, chaque fois qu'il y aura plus de chances d'obtenir une réponse des membres du groupe. plt.figure(taille de la figue=(8,5)) heure_std = df['Hours'].value_counts().diriger(15) s_T = std_time.plot.bar() s_T.yaxis.set_major_locator(MaxNLocator(entier=Vrai)) #Conversion des données de l'axe y en entier plt.xlabel('Hours (24-Heure)',fontdict={'fontsize': 12,'fontweight': 10}) plt.ylabel('Non. of messages',fontdict={'fontsize': 12,'fontweight': 10}) plt.titre('Most suitable hour of day.',fontdict={'fontsize': 18,'fontweight': 8}) plt.show()
Créons un nuage de mots du 10 membres les plus actifs:
active_m = [liste des 10 membres les plus actifs]
pour moi à portée(longueur(active_m)) :
# Filtrage des messages d'un utilisateur particulier
m_chat = df[df["Auteur"] == actif_m[je]]
imprimer(f'--- Auteur : {active_m[je]} --- ')
# Word Cloud of mostly used word in our Group
msg = ' '.join(x pour x dans m_chat.Message)
nuage de mots = nuage de mots(mots vides=mots vides, background_color="blanche").produire(message)
plt.figure(taille de la figue=(10,5))
plt.imshow(mot nuage, interpolation='bilinéaire')
plt.axis("désactivé")
plt.show()
imprimer('____________________________________________________________________________________n')
Voyons à quelle date notre groupe a été très actif:
### Date à laquelle notre Groupe a été très actif.
plt.figure(taille de la figue=(8,5))
df['Date'].value_counts().diriger(15).plot.bar()
plt.xlabel('Date',fontdict={'fontsize': 14,'fontweight': 10})
plt.ylabel('Non. of messages',fontdict={'fontsize': 14,'fontweight': 10})
plt.titre('Analysis of Date on which Group was highly active',fontdict={'fontsize': 18,'fontweight': 8})
plt.show()
Créons un graphique de série chronologique sans. de messages:
z = df['Date'].value_counts() z1 = z.to_dict() #convertit en dictionnaire df['Msg_count'] = df['Date'].carte(z1) ### Graphique de la série temporelle fig = px.line(x=df['Date'],y = df['Msg_count']) fig.update_layout(titre="Analyse du nombre de message"s using TimeSeries plot.', xaxis_title="Mois", yaxis_title="Non. des messages") fig.update_xaxes(entailles=20) fig.show()
Créons une colonne séparée pour le mois et l'année pour une meilleure analyse:
df['Année'] = df['Date'].dt.année df['Mon'] = df['Date'].dt.mois mois = { 1 : 'Jan', 2 : 'Feb', 3 : 'Mar', 4 : 'Apr', 5 : 'mai', 6 : 'Jun', 7 : 'Jul', 8 : 'Aug', 9 : 'Sep', 10 : 'Oct', 11 : 'Nov', 12 : 'Dec' } df['Mois'] = df['Mon'].carte(mois) df.drop('Mon',axe=1,inplace=True)
Regardons le mois le plus actif:
### Mois principalement actif plt.figure(taille de la figue=(12,6)) mois_actif = df['Month_Year'].value_counts() a_m = mois_actif a_m.plot.bar() plt.xlabel('Mois',fontdict={'fontsize': 14,'fontweight': 10}) plt.ylabel('Non. of messages',fontdict={'fontsize': 14,'fontweight': 10}) plt.titre('Analysis of mostly active month.',fontdict={'fontsize': 20, 'fontweight': 8}) plt.show()
Analysons le mois le plus chargé à l'aide d'un diagramme linéaire:
z = df['Month_Year'].value_counts() z1 = z.to_dict() #convertit en dictionnaire df['Msg_count_monthly'] = df['Month_Year'].carte(z1) plt.figure(taille de la figue=(18,9)) sns.set_style("grille noire") sns.lineplot(données=df,x='Month_Year',y='Msg_count_monthly',marqueurs=Vrai,marqueur="O") plt.xlabel('Mois',fontdict={'fontsize': 14,'fontweight': 10}) plt.ylabel('Non. of messages',fontdict={'fontsize': 14,'fontweight': 10}) plt.titre('Analysis of mostly active month using line plot.',fontdict={'fontsize': 20,'fontweight': 8}) plt.show()
Passons en revue le message total par an:
### Message total par an
### Comme nous analysons que le groupe a été créé au milieu 2019, c'est pourquoi le nombre de messages dans 2019 est moins.
plt.figure(taille de la figue=(12,6))
mois_actif = df['Année'].value_counts()
a_m = mois_actif
a_m.plot.bar()
plt.xlabel('Année',fontdict={'fontsize': 14,'fontweight': 10})
plt.ylabel('Non. of messages',fontdict={'fontsize': 14,'fontweight': 10})
plt.titre('Analysis of mostly active year.',fontdict={'fontsize': 20,'fontweight': 8})
plt.show()
Utilisons un carte de chaleurUn "carte de chaleur" est une représentation graphique qui utilise des couleurs pour montrer la densité des données dans une zone spécifique. Couramment utilisé dans l’analyse de données, Etudes marketing et comportementales, Ce type de visualisation vous permet d’identifier rapidement les modèles et les tendances. Par des variations chromatiques, Les cartes thermiques facilitent l’interprétation de grands volumes d’informations, aider à prendre des décisions éclairées.... Et analysons le moment de la journée avec une grande activité:
df2 = df.groupby(['Hours', 'Day'], as_index=Faux)["Un message"].compter() df2 = df2.dropna() df2.reset_index(goutte = vrai,en place = vrai) ### Analyser sur quel groupe de temps est le plus actif en fonction des heures et du jour. analyse_2_df = df.groupby(['Hours', 'Day'], as_index=Faux)["Un message"].compter() ### Suppression des valeurs nulles analyse_2_df.dropna(inplace=Vrai) analysis_2_df.sort_values(par=['Message'],ascendant=Faux) day_of_week = ['Monday', 'Tuesday', 'Wednesday', 'Thrusday', 'Friday', 'Saturday', 'Sunday'] plt.figure(taille de la figue=(15,8)) carte de chaleur( x=analyse_2_df['Hours'], y=analyse_2_df['Day'], taille_échelle = 500, taille = analyse_2_df['Message'], y_order = day_of_week[::-1], couleur = analyse_2_df['Message'], palette = sns.cubehelix_palette(128) ) plt.show()
De la carte thermique ci-dessus, nous analysons que le « Lundi » entre les 10:00 et les 10:59, notre groupe était
très actif, de même le « Mercredi » entre les 10:00 et les 10:59, notre groupe était
très actif. Entre les 00:00 et les 08:00 le groupe était moins actif.
Note finale:
J'espère que cet article vous aidera vraiment à créer votre propre analyseur de chat WhatsApp et à analyser le modèle dans le groupe.
J'espère que cet article vous a plu. N'importe quelle question? Ai-je raté quelque chose? Veuillez me contacter à mon LinkedIn. Et finalement, … Pas besoin de dire,
Merci pour la lecture!
Santé!!!
Ronil
Les médias présentés dans cet article ne sont pas la propriété de DataPeaker et sont utilisés à la discrétion de l'auteur.
