Python
Pandas-Histogramm: Ein Anfängerhandbuch für die Visualisierung von Daten

Pandas-Histogramm: Ein Anfängerhandbuch für die Visualisierung von Daten

MoeNagy Dev

Pandas-Histogramm: Visualisierung von Datenverteilungen

Verständnis von Pandas-Histogrammen

Einführung in Pandas-Histogramme

Pandas, eine leistungsstarke Datenmanipulations- und Analysebibliothek in Python, bietet eine bequeme Möglichkeit, Histogramme zu erstellen, die für die Visualisierung von Datenverteilungen unerlässlich sind. Histogramme sind eine graphische Darstellung der Häufigkeitsverteilung eines Datensatzes und ermöglichen es Ihnen, Einblicke in die zugrunde liegenden Muster und Merkmale Ihrer Daten zu gewinnen.

Hauptmerkmale und Vorteile von Pandas-Histogrammen

Pandas-Histogramme bieten mehrere wichtige Merkmale und Vorteile:

  1. Intuitive Datenexploration: Histogramme helfen Ihnen dabei, Form, Zentrum und Streuung Ihrer Daten schnell zu erkennen, was sie zu einem wertvollen Werkzeug für die explorative Datenanalyse macht.
  2. Ausreißererkennung: Histogramme können das Vorhandensein von Ausreißern aufzeigen, die Datenpunkte, die außerhalb des typischen Bereichs der Verteilung liegen.
  3. Vergleich von Verteilungen: Durch Überlagerung mehrerer Histogramme können Sie die Verteilungen verschiedener Datensätze oder Untergruppen in Ihren Daten visuell vergleichen.
  4. Statistische Inferenz: Histogramme können verwendet werden, um die Annahmen, die statistischen Tests wie die Normalverteilung zugrunde liegen, zu prüfen und Hypothesenprüfungen zu unterstützen.
  5. Anpassung und Flexibilität: Pandas-Histogramme können stark angepasst werden, indem Sie die Anzahl der Bins, die Größe der Bins, Farben und andere visuelle Aspekte an Ihre spezifischen Bedürfnisse anpassen.

Erstellen von Pandas-Histogrammen

Importieren von Pandas und Matplotlib

Um Pandas-Histogramme zu erstellen, müssen Sie die erforderlichen Bibliotheken importieren:

import pandas as pd
import matplotlib.pyplot as plt

Generieren eines einfachen Histogramms

Beginnen wir mit der Erstellung eines einfachen Histogramms unter Verwendung der hist()-Funktion von Pandas:

# Laden eines Beispieldatensatzes
data = pd.DataFrame({'Alter': [25, 30, 35, 40, 45, 50, 55, 60, 65, 70]})
 
# Erstellen eines einfachen Histogramms
data['Alter'].hist()
plt.show()

Dieser Code generiert ein Histogramm der Spalte 'Alter' im Datensatz und zeigt die Verteilung der Alter an.

Anpassung des Erscheinungsbilds des Histogramms

Pandas-Histogramme bieten verschiedene Anpassungsoptionen, um die Visualisierung zu verbessern.

Festlegen der Anzahl der Bins

Sie können die Anzahl der Bins (Säulen) im Histogramm mit dem bins-Parameter steuern:

data['Alter'].hist(bins=6)
plt.show()

Dies erstellt ein Histogramm mit 6 Bins.

Anpassen der Bin-Größen

Um die Bin-Größen anzupassen, können Sie eine Liste von Bin-Grenzen an den bins-Parameter übergeben:

bins = [20, 30, 40, 50, 60, 70, 80]
data['Alter'].hist(bins=bins)
plt.show()

Dies erstellt ein Histogramm mit Bins im Bereich von 20 bis 80 in Schritten von 10.

Ändern von Farbe und Stil des Histogramms

Sie können die Farbe und den Stil des Histogramms mit den Styling-Optionen von Matplotlib anpassen:

# Festlegen der Histogrammfarbe
data['Alter'].hist(color='green')
plt.show()
 
# Ändern des Histogrammstils
plt.style.use('seaborn')
data['Alter'].hist()
plt.show()

Diese Beispiele zeigen, wie die Histogrammfarbe in grün geändert und der 'seaborn'-Stil auf die Grafik angewendet wird.

Erforschen von Histogrammeigenschaften

Pandas-Histogramme bieten Zugriff auf verschiedene statistische Eigenschaften, die es Ihnen ermöglichen, tiefere Einblicke in Ihre Daten zu gewinnen.

Zugriff auf Histogrammstatistiken

Sie können die Bin-Grenzen, die Bin-Zählungen und die Bin-Mittepunkte mit den folgenden Attributen abrufen:

# Erstellen eines Histogramms
hist = data['Alter'].hist()
 
# Zugriff auf die Bin-Grenzen
bin_grenzen = hist.patches[0].get_bbox().get_points()[:, 0]
 
# Zugriff auf die Bin-Zählungen
bin_zählungen = hist.patches[0].get_height()
 
# Zugriff auf die Bin-Mittepunkte
bin_mittepunkte = 0.5 * (bin_grenzen[:-1] + bin_grenzen[1:])
 
print(f"Bin-Grenzen: {bin_grenzen}")
print(f"Bin-Zählungen: {bin_zählungen}")
print(f"Bin-Mittepunkte: {bin_mittepunkte}")

Dieser Code zeigt, wie man die Bin-Grenzen, Bin-Zählungen und Bin-Mittepunkte aus dem Histogrammobjekt extrahiert.

Kombination von Histogrammen

Pandas-Histogramme können auf verschiedene Weise kombiniert werden, um den Vergleich zu ermöglichen.

Überlagerung mehrerer Histogramme

Um mehrere Histogramme im selben Plot zu überlagern, können Sie die Funktion plot() anstelle von hist() verwenden:

# Erstellen eines Beispieldatensatzes mit zwei Spalten
data = pd.DataFrame({'Alter': [25, 30, 35, 40, 45, 50, 55, 60, 65, 70],
                     'Größe': [160, 165, 170, 175, 180, 185, 190, 195, 200, 205]})
 
# Überlagerung von Histogrammen
data['Alter'].plot(kind='hist', alpha=0.5, bins=6, label='Alter')
data['Größe'].plot(kind='hist', alpha=0.5, bins=6, label='Größe')
plt.legend()
plt.show()

Dieser Code erstellt einen einzelnen Plot mit überlagerten Histogrammen für die Spalten 'Alter' und 'Größe', die es ermöglichen, die Verteilungen visuell zu vergleichen.

Subplots für den Vergleich

Alternativ können Sie ein Raster von Subplots erstellen, um mehrere Histogramme nebeneinander anzuzeigen:

# Erstellen von Subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
 
# Histogramme auf separaten Subplots plotten
data['Alter'].hist(ax=ax1, bins=6, label='Alter')
data['Größe'].hist(ax=ax2, bins=6, label='Größe')
 
# Beschriftungen und Titel hinzufügen
ax1.set_title('Verteilung von Alter')
ax2.set_title('Verteilung von Größe')
plt.show()

Dieses Beispiel erstellt eine Abbildung mit zwei Subplots, von denen jeder ein Histogramm für eine andere Spalte im Datensatz anzeigt und somit eine detailliertere vergleichende Analyse ermöglicht.

Fortgeschrittene Histogrammtechniken

Pandas-Histogramme können komplexere Datentypen verarbeiten und bieten erweiterte Visualisierungsoptionen.

Umgang mit kategorialen Daten

Pandas-Histogramme können auch verwendet werden, um die Verteilung kategorialer Variablen zu visualisieren.

# Erstellen Sie einen Beispiel-Datensatz mit einer kategorialen Variable
data = pd.DataFrame({'Geschlecht': ['Männlich', 'Weiblich', 'Männlich', 'Weiblich', 'Männlich', 'Weiblich']})
 
# Erstellen Sie ein Histogramm für die kategoriale Variable
data ['Geschlecht'].value_counts(). plot (Kind = 'bar')
 plt.show ()

Dieser Code erzeugt ein Balkendiagramm, das dem Histogramm für kategoriale Daten entspricht und die Häufigkeit jeder Kategorie anzeigt.

Normalisierung von Histogrammen

Pandas-Histogramme können normalisiert werden, um die Wahrscheinlichkeitsdichtefunktion (PDF) oder die kumulative Verteilungsfunktion (CDF) anzuzeigen.

# Erstellen Sie ein normiertes PDF-Histogramm
data ['Alter']. Plot (Kind = 'hist', Dichte = wahr, Bins = 6)
 plt.show ()
 
# Erstellen Sie ein normiertes CDF-Histogramm
data ['Alter']. Plot (Kind = 'hist', Kumulativ = wahr, Dichte = wahr, Bins = 6)
 plt.show ()

Der Parameter Dichte = True normalisiert das Histogramm, um die Wahrscheinlichkeitsdichtefunktion anzuzeigen, während Kumulativ = True ein Histogramm erzeugt, das die kumulative Verteilungsfunktion anzeigt.

Pandas-Histogramm-Anwendungsfälle

Pandas-Histogramme sind vielseitig einsetzbar und können in verschiedenen Datenanalyse- und Visualisierungsszenarien eingesetzt werden.

Explorative Datenanalyse

Histogramme sind unverzichtbar, um die Verteilung Ihrer Daten zu untersuchen, Ausreißer zu identifizieren und Schiefe oder andere Muster zu erkennen.

# Untersuchen Sie die Verteilung einer Variablen
data ['Alter']. hist ()
plt.show ()
 
# Ausreißer erkennen
data ['Alter']. plot (Art = 'box')
plt.show ()

Das erste Beispiel erstellt ein Histogramm, um die Verteilung der Spalte "Alter" zu visualisieren, während das zweite Beispiel ein Boxplot verwendet, um potenzielle Ausreißer zu identifizieren.

Vergleich von Datensätzen

Das Überlagern von Histogrammen oder das Erstellen von nebeneinander liegenden Subplots kann Ihnen dabei helfen, die Verteilungen verschiedener Datensätze oder Untergruppen in Ihren Daten zu vergleichen.

# Verteilungen von zwei Variablen vergleichen
Figur, (ax1, ax2) = plt.subplots (1, 2, figsize = (12, 4))
data ['Alter']. hist (ax = ax1, Bins = 6, Label = 'Alter')
data ['Höhe']. hist (ax = ax2, Bins = 6, Label = 'Höhe')
plt.show ()

Dieser Code erstellt eine Abbildung mit zwei Subplots, wobei jedes einen Histogramm für eine andere Variable darstellt und es Ihnen ermöglicht, die Datenverteilungen visuell zu vergleichen.

Hypothesentests

Histogramme können verwendet werden, um die Annahmen statistischer Tests, wie z. B. Normalität, zu überprüfen und Hypothesentests zu unterstützen.

# Test auf Normalität
from scipy.stats import normaltest
_, p_value = normaltest (data ['Alter'])
print (f"Normalsptest p-Wert: {p_value:.4f}")

In diesem Beispiel wird die Funktion "normaltest()" aus der SciPy-Bibliothek verwendet, um einen Normalitätstest für die Spalte "Alter" durchzuführen, und der resultierende p-Wert wird ausgegeben. Histogramme können verwendet werden, um die Normalitätsannahme visuell zu überprüfen.

Datenstrukturen

Listen

Listen sind eine der grundlegendsten Datenstrukturen in Python. Sie sind geordnete Sammlungen von Elementen, wobei jedes Element einen anderen Datentyp haben kann. Listen sind veränderbar, d. H. Sie können Elemente in der Liste hinzufügen, entfernen und ändern.

Hier ein Beispiel für das Erstellen und Manipulieren einer Liste:

# Erstellen einer Liste
Früchte = ['Apfel', 'Banane', 'Kirsche']
 
# Zugriff auf Elemente
Drucken (fruits[0])  # Ausgabe: 'Apfel'
Drucken (früchte[-1])  # Ausgabe: 'Kirsche'
 
# Ändern von Elementen
Früchte [1] = 'Orange'
Drucken (früchte)  # Ausgabe: ['Apfel', 'Orange', 'Kirsche']
 
# Hinzufügen von Elementen
Früchte hinzufügen ('Kiwi')
Drucken (früchte)  # Ausgabe: ['Apfel', 'Orange', 'Kirsche', 'Kiwi']
 
# Entfernen von Elementen
Früchte entfernen ('Banane')
Drucken (früchte)  # Ausgabe: ['Apfel', 'Orange', 'Kirsche', 'Kiwi']

Tupel

Tupel ähneln Listen, sind jedoch unveränderlich, dh Sie können ihre Elemente nach dem Erstellen nicht ändern. Tupel werden häufig verwendet, um zusammengehörige Daten zu speichern, die nicht geändert werden sollten.

Hier ein Beispiel für die Verwendung von Tupeln:

# Erstellen eines Tupels
Punkt = (2, 3)
Drucken Sie (Punkt)  # Ausgabe: (2, 3)
 
# Zugriff auf Elemente
Drucken (punkt [0])  # Ausgabe: 2
Drucken (punkt [1])  # Ausgabe: 3
 
# Versuch, ein Tupel-Element zu ändern
# Punkt[0] = 4  # TypeError: 'tuple' -Objekt unterstützt keine Elementzuweisung

Wörterbücher

Wörterbücher sind ungeordnete Sammlungen von Schlüssel-Wert-Paaren. Sie sind nützlich, um Daten effizient zu speichern und abzurufen.

Hier ein Beispiel für die Verwendung von Wörterbüchern:

# Erstellen eines Wörterbuchs
Person = {
    'Name':'John Doe',
    'Alter': 35,
    'Beruf': 'Softwareentwickler'
}
 
# Zugriff auf Werte
Drucken (Person ['Name'])  # Ausgabe: 'John Doe'
Drucken (Person ['Alter'])  # Ausgabe: 35
 
# Hinzufügen neuer Schlüssel-Wert-Paare
Person['Email'] = 'john.doe@example.com'
Drucken (Person)  # Ausgabe: {'Name':'John Doe','Alter': 35,'Beruf':'Softwareentwickler', 'Email':'john.doe@example.com'}
 
# Entfernen von Schlüssel-Wert-Paaren
Del Person ['Beruf']
Drucken (Person)  # Ausgabe: {'Name':'John Doe','Alter': 35, 'Email':'john.doe@example.com'}

Sets

Sets sind ungeordnete Sammlungen eindeutiger Elemente. Sie sind nützlich für die Durchführung von Mengenoperationen wie Vereinigung, Schnittmenge und Differenz.

Hier ein Beispiel für die Verwendung von Sets:

# Erstellen eines Sets
Farben = {'Rot', 'Grün', 'Blau'}
Drucken (Farben)  # Ausgabe: {'Grün', 'Blau', 'Rot'}
 
# Hinzufügen von Elementen zu einem Set
Farben hinzufügen ('Gelb')
Drucken (Farben)  # Ausgabe: {'Grün', 'Blau', 'Rot', 'Gelb'}
 
# Entfernen von Elementen aus einem Set
Farben entfernen ('Grün')
Drucken (Farben)  # Ausgabe: {'Blau', 'Rot', 'Gelb'}
 
# Set-Operationen
Set1 = {1, 2, 3}
Set2 = {2, 3, 4}
Drucken (set1.union (set2))  # Ausgabe: {1, 2, 3, 4}
Drucken (set1.intersection (set2))  # Ausgabe: {2, 3}
Drucken (set1.difference (set2))  # Ausgabe: {1}

Steuerfluss

Bedingte Anweisungen

Bedingte Anweisungen wie if-else und elif ermöglichen es Ihnen, verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen.

# if-else-Anweisung
Alter = 18
If Alter> = 18:
    Drucken ("Sie sind ein Erwachsener.")
Sonst:
    Drucken ("Sie sind ein Minderjähriger.")
 
# elif-Anweisung
Score = 85
If Score> = 90:
    Drucken ("Note: A")
Elif Score> = 80:
    Drucken ("Note: B")
Elif Score> = 70:
    Drucken ("Note: C")
Sonst:
    Drucken ("Note: F")

Schleifen

Schleifen wie for und while ermöglichen es Ihnen, einen Codeblock wiederholt auszuführen.

# for-Schleife
fruits = ['Apfel', 'Banane', 'Kirsche']
for fruit in fruits:
    print(fruit)
 
# while-Schleife
count = 0
while count < 5:
    print(count)
    count += 1

List Comprehension

List Comprehension ist eine prägnante Art, Listen zu erstellen, indem eine Transformation oder Bedingung auf jedes Element eines vorhandenen Iterables angewendet wird (z. B. eine Liste, ein Tupel oder eine Menge).

# Klassische Art, eine Liste von Quadraten zu erstellen
numbers = [1, 2, 3, 4, 5]
squares = []
for num in numbers:
    squares.append(num ** 2)
print(squares)  # Ausgabe: [1, 4, 9, 16, 25]
 
# Mit List Comprehension
squares = [num ** 2 for num in numbers]
print(squares)  # Ausgabe: [1, 4, 9, 16, 25]

Funktionen

Funktionen sind wiederverwendbare Codeblöcke, die eine spezifische Aufgabe ausführen. Sie können Argumente akzeptieren, Operationen durchführen und Werte zurückgeben.

# Definieren einer Funktion
def greet(name):
    """
    Begrüßt die Person mit dem angegebenen Namen.
    """
    print(f"Hallo, {name}!")
 
# Aufrufen der Funktion
greet("Alice")  # Ausgabe: Hallo, Alice!
 
# Funktionen mit Rückgabewerten
def add_numbers(a, b):
    return a + b
 
result = add_numbers(3, 4)
print(result)  # Ausgabe: 7

Module und Pakete

Das modulare Design von Python ermöglicht es Ihnen, Ihren Code in wiederverwendbare Komponenten namens Module zu organisieren. Module können zu Paketen gruppiert werden, die Sammlungen von verwandten Modulen sind.

# Importieren eines Moduls
import math
print(math.pi)  # Ausgabe: 3.141592653589793
 
# Importieren einer bestimmten Funktion aus einem Modul
from math import sqrt
print(sqrt(16))  # Ausgabe: 4.0
 
# Importieren eines Moduls mit einem Alias
import numpy as np
print(np.array([1, 2, 3]))  # Ausgabe: [1 2 3]

Fehlerbehandlung

Die Fehlerbehandlung in Python ermöglicht es Ihnen, Laufzeitfehler und unerwartete Situationen zu verwalten und darauf zu reagieren.

# Behandlung eines ZeroDivisionError
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Fehler: Division durch Null.")
 
# Behandlung mehrerer Ausnahmen
try:
    int_value = int("abc")
except ValueError:
    print("Fehler: Ungültiges Integer-Format.")
except Exception as e:
    print(f"Unerwarteter Fehler: {e}")

Dateiein-/ausgabe

Python bietet integrierte Funktionen und Methoden zum Lesen und Schreiben von Dateien.

# Schreiben in eine Datei
with open("beispiel.txt", "w") as file:
    file.write("Hallo, Welt!")
 
# Lesen aus einer Datei
with open("beispiel.txt", "r") as file:
    content = file.read()
    print(content)  # Ausgabe: Hallo, Welt!

Zusammenfassung

In diesem Tutorial haben Sie verschiedene Datenstrukturen, Kontrollflussanweisungen, Funktionen, Module, Fehlerbehandlung und Dateiein-/ausgabe in Python kennengelernt. Diese Konzepte sind wichtig für die Erstellung robuster und effizienter Python-Anwendungen. Üben Sie diese Konzepte, um Ihr Verständnis zu festigen und ein versierter Python-Programmierer zu werden.

MoeNagy Dev