Einführung
Heute, eine der trendigen Social-Media-Plattformen ist .... erraten Sie, was? Eine einzige WhatsApp😅. Es ist aufgrund seiner attraktiven Funktionen eine der beliebtesten Social-Media-Plattformen von uns allen. Hat mehr als 2 eine Milliarde Nutzer weltweit und „In Bezug auf eine Umfrage, ein durchschnittlicher Benutzer gibt mehr aus als 195 Minuten pro Woche auf WhatsApp“. Wie schrecklich ist die obige Aussage. Lass all diese Dinge fallen und lass uns verstehen, was der WhatsApp-Analyzer wirklich bedeutet.
WhatsApp Analyzer bedeutet, dass wir unsere WhatsApp-Gruppenaktivitäten analysieren. Verfolgen Sie unser Gespräch und analysieren Sie, wie viel Zeit wir damit verbringen oder sagen Sie das „wir verschwenden“ auf whatsapp. Das Ziel dieses Artikels ist es, eine Schritt-für-Schritt-Anleitung bereitzustellen, um unseren eigenen WhatsApp-Parser mit Python zu erstellen.. Hier habe ich verschiedene Python-Bibliotheken verwendet, die mir helfen, nützliche Informationen aus den Rohdaten zu extrahieren. Hier wähle ich meine offizielle WhatsApp-Gruppe der Universität aus, um das Muster zu analysieren, dem die Studenten folgten, Also lösche ich in einigen Schnappschüssen die Kontaktdaten meiner Universitätsprofessoren und meiner Kommilitonen, Es tut uns leid. Lasst uns beginnen…
Erforderliche Bibliotheken:
- Regex
- Pandas
- Matplotlib
- Numpy
- Seaborn
- Datum (und Uhrzeit
- Emoji
- Wortwolke
- Heatmapz
- NLTK
- Handlung
Wir importieren all diese Bibliotheken:
Importieren Pandas als pd importieren numpy als np importieren import matplotlib.pyplot als plt import seaborn als sns aus Datetime-Import * import datetime als dt aus matplotlib.ticker importieren MaxNLocator Regex importieren Emoji importieren aus seefrischem Import * aus Heatmap importieren Heatmap aus Wordcloud importieren WordCloud , STOPWÖRTER , ImageColorGenerator aus nltk-Import * aus Plotly Import Express als px
WhatsApp gibt uns die Funktion, Chats zu exportieren, Also exportieren wir den Chat und speichern die Datei. Im Schritt 2, Wir werden ein Python-Programm erstellen, das das Datum extrahiert, der Benutzername des Autors, Die Zeit, die Nachrichten aus der exportierten Chat-Datei und erstellen Sie einen Datenrahmen, und speichert alle Daten darin. In Wirklichkeit, Datenerfassung und Vorverarbeitung werden in Schritt behandelt 2 und in weiteren Schritten.
Lassen Sie uns alle nützlichen Informationen extrahieren. aus Chat-Datei mit Regex:
### Python-Code zum Extrahieren des Datums aus der Chat-Datei
def startetWithDateAndTime (S):
patrón = ‚^ ([0-9]+) (/) ([0-9]+) (/) ([0-9][0-9]), ([0-9]+) :([0-9][0-9]) (BIN | PN) – ‚
Ergebnis = re.match (Muster, S)
wenn das ergebnis:
true zurückgeben
falsche Rückgabe
### Regex-Muster zum Extrahieren des Benutzernamens des Autors.
def FindAutor(S):
Muster = [
'([w]+):', # First Name
'([w]+[S]+[w]+):', # Vorname + Last Name
'([w]+[S]+[w]+[S]+[w]+):', # Vorname + Zweiter Vorname + Last Name
'([+]D{2} D{5} D{5}):', # Handy Nummer (Indien Nr.)
'([+]D{2} D{3} D{3} D{4}):', # Handy Nummer (US-Nr.)
'([w]+)[u263a-U0001f999]+:', # Name und Emoji
]
pattern = '^' + '|'.join(Muster)
Ergebnis = re.match(Muster, S)
wenn ergebnis:
true zurückgeben
falsch zurückgeben
### Datum extrahieren, Zeit, Autor und Nachricht aus der Chat-Datei.
def getDataPoint(Leitung):
splitLine = line.split(' - ')
dateTime = splitLine[0]
Datum, time = dateTime.split(', ')
Nachricht=" ".beitreten(Trennlinie[1:])
wenn FindAutor(Botschaft):
splitMessage = message.split(': ')
Autor = splitMessage[0]
Nachricht=" ".beitreten(splitMessage[1:])
anders:
Autor = Keine
Rückflugdatum, Zeit, Autor, Botschaft
### Endlich einen Datenrahmen erstellen und alle Daten in diesem Datenrahmen speichern.
parsedData = [] # Liste zum Nachverfolgen von Daten, damit sie von einem Pandas-Datenrahmen verwendet werden können
### Hochladen einer exportierten Chat-Datei
Konversationspfad="WhatsApp-Chat mit TE Comp 20-21 Offizielle.txt" # Chat-Datei
mit offen(Konversationspfad, Kodierung="utf-8") als fp:
### Überspringen der ersten Zeile der Datei, da sie Informationen zu Ende-zu-Ende-Verschlüsselung enthält
fp.readline()
MessageBuffer = []
Datum, Zeit, Autor = Keiner, Keiner, Keiner
während wahr:
line = fp.readline()
wenn nicht linie:
brechen
line = line.strip()
wenn beginntWithDateAndTime(Leitung):
wenn len(MessageBuffer) > 0:
parsedData.append([Datum, Zeit, Autor, ' '.join(MessageBuffer)])
messageBuffer.clear()
Datum, Zeit, Autor, Nachricht = getDataPoint(Leitung)
messageBuffer.append(Botschaft)
anders:
messageBuffer.append(Leitung)
df = pd.DataFrame(parsedData, Spalten=[Datum, Uhrzeit, 'Author', 'Message']) # Initialisieren eines Pandas-Datenrahmens.
### Ändern des Datentyps von "Datum" Säule.
df["Datum"] = pd.to_datetime(df["Datum"])
Zuerst, Schauen Sie sich unseren Neugeborenen-Datensatz an:
Jetzt, Lassen Sie uns die grundlegenden Informationen unseres Datensatzes überprüfen und den Datensatz bereinigen:
### Überprüfen der Form von Datensatzein "Datensatz" oder Datensatz ist eine strukturierte Sammlung von Informationen, die für statistische Analysen verwendet werden können, Maschinelles Lernen oder Forschung. Datensätze können numerische Variablen enthalten, kategorisch oder textuell, und ihre Qualität ist entscheidend für zuverlässige Ergebnisse. Sein Einsatz erstreckt sich auf verschiedene Disziplinen, wie z.B. Medizin, Wirtschafts- und Sozialwissenschaften, Erleichterung einer fundierten Entscheidungsfindung und der Entwicklung von Vorhersagemodellen..... df.shape ### Überprüfen grundlegender Informationen des Datensatzes df.info() ### Überprüfung nein. von NullDer Begriff "NULL" Er wird in der Programmierung und in Datenbanken verwendet, um einen Nullwert oder einen nicht vorhandenen Wert darzustellen. Ihre Hauptfunktion besteht darin, anzuzeigen, dass einer Variablen kein Wert zugewiesen wurde oder dass ein Datenelement nicht verfügbar ist. Und SQL, zum Beispiel, Wird verwendet, um Datensätze zu verwalten, bei denen in bestimmten Spalten Informationen fehlen. Die Verwendung von verstehen "NULL" Es ist wichtig, Fehler bei der Datenmanipulation zu vermeiden und... Werte im Datensatz df.isnull().Summe() ### Kopfteil des Datensatzes prüfen df.kopf(50) ### Schwanzteil des Datensatzes prüfen df.tail(50) ### Löschen von Nan-Werten aus dem Datensatz df = df.dropna() df = df.reset_index(drop=wahr) df.shape ### Überprüfung nein. der Autoren der Gruppe df['Author'].nuniquam() ### Autoren der Gruppe prüfen df['Author'].einzigartig()
Jetzt, Wir verarbeiten unseren Datensatz vor und versuchen, nützliche Informationen daraus zu extrahieren:
### Hinzufügen einer weiteren Spalte von "Tag" zur besseren Analyse, Hier verwenden wir die Datetime-Bibliothek, die uns hilft, diese Aufgabe einfach zu erledigen.
Wochen = {
0 : 'Monday',
1 : 'Tuesday',
2 : 'Wednesday',
3 : 'Thrusday',
4 : 'Friday',
5 : 'Saturday',
6 : 'Sunday'
}
df['Day'] = df[Datum].dt.weekday.map(Wochen)
### Spalten zum besseren Verständnis neu anordnen
df = df[[Datum,'Day',Uhrzeit,'Author','Message']]
### Ändern des Datentyps der Spalte "Tag".
df['Day'] = df['Day'].astyp('Kategorie')
### Suche Neugeborenen-Datensatz.
df.kopf()
### Anzahl der Buchstaben in jeder Nachricht zählen
df['Letter's'] = df['Message'].anwenden(Lambda s : len(S))
### Counting number of word's in each message
df['Word's'] = df['Message'].anwenden(Lambda s : len(s.split('Review')))
### Funktion zum Zählen der Anzahl von Links im Datensatz, Es wird eine zusätzliche Spalte hinzufügen und Informationen darin speichern.
URLPATTERN = r'(https?://S+)'
df['Url_Count'] = df.Message.apply(Lambda x: wiederfinden(URLPATTERN, x)).str.len()
Links = np.sum(df.Url_Count)
### Funktion zum Zählen der Medienanzahl im Chat.
MEDIAPATTERN = r'<Medien weggelassen>'
df['Media_Count'] = df.Message.apply(Lambda x : wiederfinden(MEDIENMUSTER, x)).str.len()
media = np.sum(df.Media_Count)
### Suche nach aktualisiertem Datensatz
df
Extrahieren Sie grundlegende Statistiken aus dem Datensatz:
total_messages = df.shape[0] media_messages = df[df['Message'] == '<Medien weggelassen>'].Form[0] Links = np.sum(df.Url_Count) drucken('Group Chatting Stats : ') drucken('Total Number of Messages : {}'.format(total_messages)) drucken('Total Number of Media Messages : {}'.format(media_messages)) drucken('Total Number of Links : {}'.format(Links))
Extrahieren grundlegender Statistiken von jedem Benutzer:
l = df.Autor.unique() für mich in Reichweite(len(l)): ### Nachrichten eines bestimmten Benutzers herausfiltern req_df = df[df["Autor"] == l[ich]] ### req_df enthält Nachrichten nur eines bestimmten Benutzers drucken(f'--> Statistiken von {l[ich]} <-- ') ### Die Form druckt die Anzahl der Zeilen, was indirekt die Anzahl der Nachrichten bedeutet drucken('Total Message Sent : ', req_df.shape[0]) ### Word_Count enthält die Gesamtzahl der Wörter in einer Nachricht. Die Summe aller Wörter/Gesamtnachrichten ergibt Wörter pro Nachricht words_per_message = (np.sum(req_df['Word's']))/req_df.shape[0] w_p_m = ("%.3F" % runden(Wörter_per_Nachricht, 2)) drucken('Average Words per Message : ', w_p_m) ### Medien bestehen aus Medienbotschaften Medien = Summe(req_df["Media_Count"]) drucken('Total Media Message Sent : ', Medien) ### Links bestehen aus der Gesamtzahl der Links Links = Summe(req_df["URL_Count"]) drucken('Total Links Sent : ', Links) drucken() drucken('----------------------------------------------------------n')
Lassen Sie uns eine Wortwolke mit den am häufigsten verwendeten Wörtern im Chat erstellen:
### Wortwolke der am häufigsten verwendeten Wörter in unserer Gruppe
Text = " ".beitreten(Rezension für Rezension in df.Message)
Wortwolke = Wortwolke(stopwords=STOPWORDS, background_color="Weiß").generieren(Text)
### Zeigen Sie das generierte Bild an:
plt.figur( Feigengröße=(10,5))
plt.imshow(Wortwolke, Interpolation='bilinear')
plt.achse("aus")
plt.zeigen()
Drucken wir die Gesamtnr.. der von jedem Benutzer gesendeten Nachrichten:
### Erstellt eine Liste einzigartiger Autoren
l = df.Autor.unique()
für mich in Reichweite(len(l)):
### Nachrichten eines bestimmten Benutzers herausfiltern
req_df = df[df["Autor"] == l[ich]]
### req_df enthält Nachrichten nur eines bestimmten Benutzers
drucken(l[ich],' -> ',req_df.shape[0])
Wir drucken die gesamten gesendeten Nachrichten an jedem Wochentag:
l = df.Tag.einzigartig()
für mich in Reichweite(len(l)):
### Nachrichten eines bestimmten Benutzers herausfiltern
req_df = df[df["Tag"] == l[ich]]
### req_df enthält Nachrichten nur eines bestimmten Benutzers
drucken(l[ich],' -> ',req_df.shape[0])
Schließlich, wir haben genügend Textinformationen aus der Chat-Datei extrahiert, Beginnen wir nun mit dem Teil der Datenvisualisierung, der uns zu einer besseren Analyse und einem besseren Verständnis aller Analysen unserer exportierten Chat-Datei verhilft. Anstelle von Kontaktnummern, Ich habe aus Sicherheitsgründen Alphabete verwendet, Entschuldige vielmals.
Mal sehen, wer der aktivste Autor der Gruppe ist:
### Meist aktiver Autor in der Gruppe plt.figur(Feigengröße=(9,6)) meistens_aktiv = df['Author'].value_counts() ### Oberteil 10 Menschen, die in unserer Gruppe am meisten aktiv sind, ist : m_a = meist_active.head(10) Balken = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(len(Riegel)) m_a.plot.bar() plt.xlabel('Authors',fontdict={'fontsize': 14,'fontweight': 10}) plt.ylabel('Nein. of messages',fontdict={'fontsize': 14,'fontweight': 10}) plt.titel('Mostly active member of Group',fontdict={'fontsize': 20,'fontweight': 8}) plt.xticks(x_pos, Riegel) plt.zeigen()
Schauen wir uns den aktivsten Tag der Woche an:
### Meist Aktiver Tag in der Gruppe plt.figur(Feigengröße=(8,5)) active_day = df['Day'].value_counts() ### Oberteil 10 Menschen, die in unserer Gruppe am meisten aktiv sind, ist : a_d = active_day.head(10) a_d.plot.bar() plt.xlabel('Day',fontdict={'fontsize': 12,'fontweight': 10}) plt.ylabel('Nein. of messages',fontdict={'fontsize': 12,'fontweight': 10}) plt.titel('Mostly active day of Week in the Group',fontdict={'fontsize': 18,'fontweight': 8}) plt.zeigen()
Schauen wir uns die Top-10-Medienbeitragenden in der Gruppe an:
### Top-10-Medienbeitragende der Gruppe mm = df[df['Message'] == '<Medien weggelassen>'] mm1 = mm['Author'].value_counts() Balken = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(len(Riegel)) top10 = mm1.Kopf(10) top10.plot.bar() plt.xlabel('Author's',fontdict={'fontsize': 12,'fontweight': 10}) plt.ylabel('Nein. of media',fontdict={'fontsize': 12,'fontweight': 10}) plt.titel('Top-10 media contributor of Group',fontdict={'fontsize': 18,'fontweight': 8}) plt.xticks(x_pos, Riegel) plt.zeigen()
Die Worte sind, Natürlich, die stärkste Waffe der Welt, mal sehen wer diese mächtige Waffe in der Gruppe hat😅:
max_words = df[['Author','Word's']].gruppiere nach('Author').Summe() m_w = max_words.sort_values('Word's',aufsteigend=Falsch).Kopf(10) Balken = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(len(Riegel)) m_w.plot.bar(rot=90) plt.xlabel('Author') plt.ylabel('Nein. of words') plt.titel('Analysis of members who has used max. Nein. of words in his/her messages') plt.xticks(x_pos, Riegel) plt.zeigen()
Schauen wir uns den Top-10-Autor an, der die maximale Anzahl geteilt hat. der Links in der Gruppe:
### Mitglied, das die maximale Anzahl von Links in der Gruppe geteilt hat max_words = df[['Author','Url_Count']].gruppiere nach('Author').Summe() m_w = max_words.sort_values('Url_Count',aufsteigend=Falsch).Kopf(10) Balken = ['A','B','C','D','E','F','G','H','I','J'] x_pos = np.arange(len(Riegel)) m_w.plot.bar(rot=90) plt.xlabel('Author') plt.ylabel('Nein. of link's') plt.titel('Analysis of member's who has shared max no. of link's in Group') plt.xticks(x_pos, Riegel) plt.zeigen()
Mal sehen, wann die Gruppe jedes Mal sehr aktiv war:
### Zeit, wenn unsere Gruppe sehr aktiv ist
plt.figur(Feigengröße=(8,5))
t = df[Uhrzeit].value_counts().Kopf(20)
tx = t.plot.bar()
tx.yaxis.set_major_locator(MaxNLocator(Ganzzahl=Wahr)) #Konvertieren von y-Achsendaten in ganze Zahlen
plt.xlabel(Uhrzeit,fontdict={'fontsize': 12,'fontweight': 10})
plt.ylabel('Nein. of messages',fontdict={'fontsize': 12,'fontweight': 10})
plt.titel('Analysis of time when Group was highly active.',fontdict={'fontsize': 18,'fontweight': 8})
plt.zeigen()
Formatkonvertierung 12 Stunden bis 24 Stunden helfen uns, eine bessere Analyse durchzuführen:
lst = [] für ich in df[Uhrzeit] : out_time = datetime.strftime(datetime.strptime(ich,"%ich:%M %p"),"%h:%m") lst.anhängen(out_time) df['24H_Time'] = lst df['Hours'] = df['24H_Time'].anwenden(Lambda x : x.split(':')[0])
Sehen wir uns die am besten geeignete Tageszeit an, zu der eine bessere Chance besteht, eine Antwort von den Gruppenmitgliedern zu erhalten:
### Am besten geeignete Tageszeit, wann immer es mehr Chancen gibt, Antworten von Gruppenmitgliedern zu bekommen. plt.figur(Feigengröße=(8,5)) std_time = df['Hours'].value_counts().Kopf(15) s_T = std_time.plot.bar() s_T.yaxis.set_major_locator(MaxNLocator(Ganzzahl=Wahr)) #Konvertieren von y-Achsendaten in ganze Zahlen plt.xlabel('Hours (24-Stunde)',fontdict={'fontsize': 12,'fontweight': 10}) plt.ylabel('Nein. of messages',fontdict={'fontsize': 12,'fontweight': 10}) plt.titel('Most suitable hour of day.',fontdict={'fontsize': 18,'fontweight': 8}) plt.zeigen()
Erstellen wir eine Wortwolke aus dem 10 aktivste Mitglieder:
aktiv_m = [Liste der Top-10 hochaktiven Mitglieder]
für mich in Reichweite(len(aktiv_m)) :
# Nachrichten eines bestimmten Benutzers herausfiltern
m_chat = df[df["Autor"] == aktiv_m[ich]]
drucken(f'--- Autor : {aktiv_m[ich]} --- ')
# Word Cloud of mostly used word in our Group
msg = ' '.join(x für x in m_chat.Message)
Wortwolke = Wortwolke(stopwords=STOPWORDS, background_color="Weiß").generieren(Nachricht)
plt.figur(Feigengröße=(10,5))
plt.imshow(Wortwolke, Interpolation='bilinear')
plt.achse("aus")
plt.zeigen()
drucken('____________________________________________________________________________________n')
Mal sehen, wann unsere Gruppe sehr aktiv war:
### Datum, an dem unsere Gruppe sehr aktiv war.
plt.figur(Feigengröße=(8,5))
df[Datum].value_counts().Kopf(15).plot.bar()
plt.xlabel(Datum,fontdict={'fontsize': 14,'fontweight': 10})
plt.ylabel('Nein. of messages',fontdict={'fontsize': 14,'fontweight': 10})
plt.titel('Analysis of Date on which Group was highly active',fontdict={'fontsize': 18,'fontweight': 8})
plt.zeigen()
Lassen Sie uns ein Zeitreihendiagramm zu Nr. erstellen. von Nachrichten:
z = df[Datum].value_counts() z1 = z.to_dict() #konvertiert in Wörterbuch df['Msg_count'] = df[Datum].Karte(z1) ### Zeitreihendiagramm fig = px.line(x=df[Datum],y = df['Msg_count']) fig.update_layout(Titel="Analyse der Anzahl der Nachrichten"s using TimeSeries plot.', xaxis_title="Monat", yaxis_title="Nein. von Nachrichten") fig.update_xaxes(Striche=20) fig.show()
Lassen Sie uns zur besseren Analyse eine separate Spalte für Monat und Jahr erstellen:
df['Jahr'] = df[Datum].dt.Jahr df['Mon'] = df[Datum].dt.Monat Monate = { 1 : 'Jan', 2 : 'Feb', 3 : 'Mar', 4 : 'Apr', 5 : May', 6 : 'Jun', 7 : 'Jul', 8 : 'Aug', 9 : 'Sep', 10 : 'Oct', 11 : 'Nov', 12 : 'Dec' } df['Monat'] = df['Mon'].Karte(Monate) df.drop('Mon',Achse=1,inplace=True)
Schauen wir uns den aktivsten Monat an:
### Meist aktiver Monat plt.figur(Feigengröße=(12,6)) aktiver_monat = df['Month_Year'].value_counts() a_m = aktiver_Monat a_m.plot.bar() plt.xlabel('Monat',fontdict={'fontsize': 14,'fontweight': 10}) plt.ylabel('Nein. of messages',fontdict={'fontsize': 14,'fontweight': 10}) plt.titel('Analysis of mostly active month.',fontdict={'fontsize': 20, 'fontweight': 8}) plt.zeigen()
Analysieren wir den geschäftigsten Monat mit einem Liniendiagramm:
z = df['Month_Year'].value_counts() z1 = z.to_dict() #konvertiert in Wörterbuch df['Msg_count_monthly'] = df['Month_Year'].Karte(z1) plt.figur(Feigengröße=(18,9)) sns.set_style("dunkles Gitter") sns.lineplot(Daten=df,x='Month_Year',y='Msg_count_monthly',Marker=Wahr,Markierung="Ö") plt.xlabel('Monat',fontdict={'fontsize': 14,'fontweight': 10}) plt.ylabel('Nein. of messages',fontdict={'fontsize': 14,'fontweight': 10}) plt.titel('Analysis of mostly active month using line plot.',fontdict={'fontsize': 20,'fontweight': 8}) plt.zeigen()
Sehen wir uns die Gesamtnachricht pro Jahr an:
### Gesamtnachricht pro Jahr
### Wie wir analysieren, wurde die Gruppe Mitte 2019, deshalb Anzahl der Nachrichten in 2019 ist weniger.
plt.figur(Feigengröße=(12,6))
aktiver_monat = df['Jahr'].value_counts()
a_m = aktiver_Monat
a_m.plot.bar()
plt.xlabel('Jahr',fontdict={'fontsize': 14,'fontweight': 10})
plt.ylabel('Nein. of messages',fontdict={'fontsize': 14,'fontweight': 10})
plt.titel('Analysis of mostly active year.',fontdict={'fontsize': 20,'fontweight': 8})
plt.zeigen()
Verwenden wir eine Heatmapein "Heatmap" ist eine grafische Darstellung, die Farben verwendet, um die Dichte von Daten in einem bestimmten Bereich anzuzeigen. Häufig in der Datenanalyse verwendet, Marketing und Verhaltensstudien, Diese Art der Visualisierung ermöglicht es Ihnen, Muster und Trends schnell zu erkennen. Durch chromatische Variationen, Heatmaps erleichtern die Interpretation großer Informationsmengen, dabei helfen, fundierte Entscheidungen zu treffen.... Und analysieren wir die Tageszeit mit großer Aktivität:
df2 = df.groupby(['Hours', 'Day'], as_index=Falsch)["Nachricht"].zählen() df2 = df2.dropna() df2.reset_index(fallen = wahr,inplace = wahr) ### Analysieren, welche Zeitgruppe basierend auf Stunden und Tag am meisten aktiv ist. analysis_2_df = df.groupby(['Hours', 'Day'], as_index=Falsch)["Nachricht"].zählen() ### Nullwerte löschen analysis_2_df.dropna(inplace=Wahr) analysis_2_df.sort_values(von=['Message'],aufsteigend=Falsch) day_of_week = ['Monday', 'Tuesday', 'Wednesday', 'Thrusday', 'Friday', 'Saturday', 'Sunday'] plt.figur(Feigengröße=(15,8)) Heatmap( x=analyse_2_df['Hours'], y=analyse_2_df['Day'], size_scale = 500, Größe = Analyse_2_df['Message'], y_order = day_of_week[::-1], Farbe = Analyse_2_df['Message'], palette = sns.cubehelix_palette(128) ) plt.zeigen()
Aus der Heatmap oben, wir analysieren, dass die „Montag“ zwischen den 10:00 und das 10:59, unsere Gruppe war
sehr aktiv, ähnlich die „Mittwoch“ zwischen den 10:00 und das 10:59, unsere Gruppe war
Sehr aktiv. Zwischen den 00:00 und das 08:00 die Gruppe war weniger aktiv.
Schlussbemerkung:
Ich hoffe, dieser Artikel hilft Ihnen wirklich dabei, Ihren eigenen WhatsApp-Chat-Analyzer zu erstellen und das Muster in der Gruppe zu analysieren.
Hoffe dir hat dieser Artikel gefallen. Irgendeine Frage? Habe ich was verpasst? Bitte kontaktieren Sie mich unter meiner LinkedIn. Und schlussendlich, … Keine Notwendigkeit zu sagen,
Danke fürs Lesen!
Gesundheit!!!
Ronil
Die in diesem Artikel gezeigten Medien sind nicht Eigentum von DataPeaker und werden nach Ermessen des Autors verwendet.
