Python
Mühelos Histogramme in Python plotten: Ein Beginner's Guide

Mühelos Histogramme in Python plotten: Ein Beginner's Guide

MoeNagy Dev

Was ist ein Histogramm?

Ein Histogramm ist eine graphische Darstellung der Verteilung eines Datensatzes. Es ist ein grundlegendes Werkzeug in der Datenanalyse und Visualisierung, da es eine klare und intuitive Möglichkeit bietet, die zugrunde liegenden Muster und Merkmale eines Datensatzes zu verstehen.

Ein Histogramm wird erstellt, indem der Wertebereich des Datensatzes in eine Reihe von Bins (oder Intervallen) unterteilt wird und dann die Anzahl der Datenpunkte gezählt wird, die in jeden Bin fallen. Das resultierende Diagramm zeigt die Häufigkeit oder Anzahl der Datenpunkte in jedem Bin an und bietet eine visuelle Darstellung der Datenverteilung.

Histogramme sind besonders nützlich, um die Form, zentrale Tendenz und Streuung eines Datensatzes zu verstehen. Sie können dabei helfen, Muster zu identifizieren, wie zum Beispiel das Vorhandensein mehrerer Spitzen (was auf eine multimodale Verteilung hinweist), Schiefe (Asymmetrie in der Verteilung) und Ausreißer (Datenpunkte, die außerhalb der Hauptverteilung liegen).

Datenvorbereitung

Um ein Histogramm in Python zu erstellen, müssen wir die erforderlichen Bibliotheken importieren und einige Beispieldaten generieren.

import numpy as np
import matplotlib.pyplot as plt
 
# Beispieldaten generieren
data = np.random.normal(0, 1, 1000)

In diesem Beispiel verwenden wir die Funktion numpy.random.normal(), um 1000 Datenpunkte aus einer Standardnormalverteilung (Mittelwert = 0, Standardabweichung = 1) zu generieren. Sie können dies durch Ihren eigenen Datensatz ersetzen oder eine andere Verteilung verwenden, um die Histogrammvisualisierung zu erkunden.

Grundlegendes Plotten von Histogrammen

Der grundlegendste Weg, ein Histogramm in Python zu erstellen, besteht darin, die Funktion plt.hist() aus der Matplotlib-Bibliothek zu verwenden.

# Histogramm erstellen
plt.hist(data, bins=30, color='blue', alpha=0.5)
 
# Beschriftungen und Titel hinzufügen
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.title('Histogramm der Beispieldaten')
 
# Das Diagramm anzeigen
plt.show()

In diesem Beispiel erstellen wir ein Histogramm mit 30 Bins, verwenden eine blaue Farbe und eine Transparenz (alpha) von 0,5. Sie können das Histogramm anpassen, indem Sie die Anzahl der Bins, die Bin-Breite, die Farbe und die Transparenz anpassen.

Anpassen des Histogramms

Festlegen der Anzahl der Bins

Die Anzahl der Bins in einem Histogramm ist ein wichtiger Parameter, der das Aussehen und die Interpretation des Diagramms wesentlich beeinflussen kann. Sie können die Anzahl der Bins mit dem Parameter bins in der Funktion plt.hist() anpassen.

# Histogramm mit 10 Bins
plt.hist(data, bins=10, color='green', alpha=0.7)
plt.show()
 
# Histogramm mit 50 Bins
plt.hist(data, bins=50, color='red', alpha=0.7)
plt.show()

Eine Erhöhung der Anzahl der Bins kann mehr Details über die Datenverteilung liefern, kann aber auch zu einem unruhigeren oder "schnatterigen" Erscheinungsbild führen. Eine Verringerung der Anzahl der Bins kann das Histogramm glätten, aber einige Feinheiten verbergen.

Anpassen der Bin-Breite

Neben der Anzahl der Bins können Sie auch die Bin-Breite anpassen, um das Detailniveau im Histogramm zu steuern.

# Histogramm mit einer Bin-Breite von 0,2
plt.hist(data, bins=np.arange(-3, 3, 0.2), color='orange', alpha=0.7)
plt.show()
 
# Histogramm mit einer Bin-Breite von 0,5
plt.hist(data, bins=np.arange(-3, 3, 0.5), color='purple', alpha=0.7)
plt.show()

In diesem Beispiel verwenden wir die Funktion np.arange(), um die Bin-Grenzen zu erstellen und die Start-, End- und Schritt-Werte anzugeben.

Ändern der Farbe und Transparenz des Histogramms

Sie können das Aussehen des Histogramms weiter anpassen, indem Sie die Farbe und Transparenz (alpha) der Balken anpassen.

# Histogramm mit einer anderen Farbe und Transparenz
plt.hist(data, bins=30, color='red', alpha=0.3)
plt.show()

Das Experimentieren mit verschiedenen Farb- und Transparenzeinstellungen kann Ihnen helfen, Histogramme zu erstellen, die visuell ansprechend sind und die Datenverteilung effektiv darstellen.

Fortgeschrittene Anpassung des Histogramms

Neben dem grundlegenden Plotten von Histogrammen können Sie die Visualisierung weiter anpassen, um sie informativer und visuell ansprechender zu gestalten.

Hinzufügen von Beschriftungen und Titel

Das Hinzufügen klarer Beschriftungen und eines aussagekräftigen Titels kann dem Leser helfen, den Kontext und das Ziel des Histogramms zu verstehen.

# Beschriftungen und Titel hinzufügen
plt.hist(data, bins=30, color='blue', alpha=0.5)
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.title('Histogramm der Beispieldaten')
plt.show()

Anpassen der Achsenskalen

Abhängig vom Bereich und der Verteilung Ihrer Daten möchten Sie möglicherweise die Skalen der x- und y-Achsen anpassen, um die Daten besser anzupassen.

# Anpassen der Skalen der x- und y-Achsen
plt.hist(data, bins=30, color='blue', alpha=0.5)
plt.xlim(-3, 3)
plt.ylim(0, 150)
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.title('Histogramm der Beispieldaten')
plt.show()

In diesem Beispiel setzen wir den Bereich der x-Achse auf -3 bis 3 und den Bereich der y-Achse auf 0 bis 150, um die Datenverteilung besser anzupassen.

Anzeigen von Rasterlinien

Das Hinzufügen von Rasterlinien kann dem Leser helfen, das Histogramm besser zu interpretieren und bestimmte Datenpunkte oder Häufigkeiten zu identifizieren.

# Rasterlinien hinzufügen
plt.hist(data, bins=30, color='blue', alpha=0.5)
plt.grid(True)
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.title('Histogramm der Beispieldaten')
plt.show()

Speichern des Histogramms als Bilddatei

Sobald Sie mit dem Histogramm zufrieden sind, können Sie es als Bilddatei speichern, um es in Berichten, Präsentationen oder anderen Anwendungen zu verwenden.

# Histogramm als Bilddatei speichern
plt.hist(data, bins=30, color='blue', alpha=0.5)
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.title('Histogramm der Beispieldaten')
plt.savefig('histogramm.png', dpi=300)

In diesem Beispiel speichern wir das Histogramm als PNG-Datei mit einer Auflösung von 300 Punkten pro Zoll (dpi).

Histogrammausgleich

Histogramme können auch normalisiert werden, um die relative Häufigkeit oder Wahrscheinlichkeitsdichte der Daten anstelle der absoluten Häufigkeit darzustellen.

# Erzeuge ein normiertes Histogramm
plt.hist(data, bins=30, density=True, color='blue', alpha=0.5)
plt.xlabel('Wert')
plt.ylabel('Wahrscheinlichkeitsdichte')
plt.title('Normiertes Histogramm der Stichprobendaten')
plt.show()

Durch Festlegen des Parameters density=True in der Funktion plt.hist() stellt die y-Achse des Histogramms die Wahrscheinlichkeitsdichte anstelle der Häufigkeit dar. Dies kann nützlich sein, um Histogramme von Datensätzen mit unterschiedlichen Skalen zu vergleichen oder um das Histogramm mit einer Wahrscheinlichkeitsverteilungskurve zu überlagern.

Mehrere Histogramme auf demselben Diagramm

Sie können mehrere Histogramme auf derselben Abbildung darstellen, um die Verteilungen verschiedener Datensätze oder Variablen zu vergleichen.

# Generiere zwei Beispieldatensätze
data1 = np.random.normal(0, 1, 1000)
data2 = np.random.normal(1, 0.5, 1000)
 
# Erzeuge eine Abbildung mit zwei Teilplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
 
# Plotte das erste Histogramm
ax1.hist(data1, bins=30, color='blue', alpha=0.5)
ax1.set_xlabel('Wert')
ax1.set_ylabel('Häufigkeit')
ax1.set_title('Histogramm von Datensatz 1')
 
# Plotte das zweite Histogramm
ax2.hist(data2, bins=30, color='red', alpha=0.5)
ax2.set_xlabel('Wert')
ax2.set_ylabel('Häufigkeit')
ax2.set_title('Histogramm von Datensatz 2')
 
# Passe den Abstand zwischen den Teilplots an
plt.subplots_adjust(wspace=0.4)
plt.show()

In diesem Beispiel erstellen wir eine Abbildung mit zwei Teilplots, von denen jeder ein Histogramm für einen anderen Datensatz enthält. Wir passen auch den Abstand zwischen den Teilplots mit der Funktion plt.subplots_adjust() an.

Histogramme mit kategorialen Daten

Histogramme können auch verwendet werden, um die Verteilung kategorialer Daten zu visualisieren, obwohl die Interpretation leicht unterschiedlich ist.

# Generiere Beispielkategoriedaten
categories = ['A', 'B', 'C', 'D', 'E']
data = np.random.choice(categories, 1000)
 
# Erzeuge ein Histogramm für kategoriale Daten
plt.hist(data, bins=len(categories), edgecolor='black')
plt.xticks(range(len(categories)), categories)
plt.xlabel('Kategorie')
plt.ylabel('Häufigkeit')
plt.title('Histogramm kategorialer Daten')
plt.show()

In diesem Beispiel generieren wir 1000 zufällige kategoriale Datenpunkte und erstellen ein Histogramm, um ihre Verteilung zu visualisieren. Der Parameter bins ist auf die Anzahl der eindeutigen Kategorien eingestellt, und wir verwenden plt.xticks() um die x-Achse mit den Kategorienamen zu beschriften.

Histogramme mit kontinuierlichen Daten

Bei der Arbeit mit kontinuierlichen Daten wird die Wahl der Anzahl der Bins wichtiger, da sie das Aussehen und die Interpretation des Histogramms erheblich beeinflussen kann.

# Generiere Beispieldatenkontinuierlich
data = np.random.normal(0, 1, 1000)
 
# Erzeuge ein Histogramm mit unterschiedlichen Bindegrößen
plt.figure(figsize=(12, 4))
 
plt.subplot(1, 2, 1)
plt.hist(data, bins=10, color='blue', alpha=0.5)
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.title('Histogramm mit 10 Bins')
 
plt.subplot(1, 2, 2)
plt.hist(data, bins=50, color='red', alpha=0.5)
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.title('Histogramm mit 50 Bins')
 
plt.subplots_adjust(wspace=0.4)
plt.show()

In diesem Beispiel erstellen wir zwei Histogramme nebeneinander mit unterschiedlichen Anzahlen von Bins (10 und 50), um den Einfluss der Bindegröße auf die Visualisierung von kontinuierlichen Daten zu verdeutlichen.

Funktionen

Funktionen sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie ermöglichen es Ihnen, die Logik zu kapseln und Ihren Code modularer und wartbarer zu gestalten.

Hier ist ein Beispiel für eine Funktion, die die Fläche eines Rechtecks berechnet:

def calculate_area(length, width):
    area = length * width
    return area
 
# Rufen Sie die Funktion auf
rect_area = calculate_area(5, 10)
print(rect_area)  # Ausgabe: 50

In diesem Beispiel nimmt die Funktion calculate_area() zwei Parameter (length und width) entgegen und liefert die berechnete Fläche zurück. Sie können die Funktion aufrufen und das Ergebnis in der Variablen rect_area speichern.

Funktionen können auch Standardparameterwerte haben und eine variable Anzahl von Argumenten akzeptieren:

def print_greeting(name, message="Hallo"):
    print(f"{message}, {name}!")
 
print_greeting("Alice")  # Ausgabe: Hallo, Alice!
print_greeting("Bob", "Hi")  # Ausgabe: Hi, Bob!
 
def calculate_sum(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total
 
print(calculate_sum(1, 2, 3))  # Ausgabe: 6
print(calculate_sum(4, 5, 6, 7, 8))  # Ausgabe: 30

Im ersten Beispiel hat die Funktion print_greeting() einen Standardwert für den Parameter message, der verwendet wird, wenn kein Wert angegeben ist. Im zweiten Beispiel kann die Funktion calculate_sum() eine beliebige Anzahl von Argumenten akzeptieren, die in einem Tupel mit dem Namen numbers gesammelt werden.

Module und Pakete

Die Standardbibliothek von Python bietet eine Vielzahl von integrierten Modulen, die Sie in Ihren Programmen verwenden können. Sie können auch Ihre eigenen Module und Pakete erstellen, um Ihren Code zu organisieren.

Hier ist ein Beispiel, wie das Modul math verwendet wird:

import math
 
radius = 5
circle_area = math.pi * radius ** 2
print(circle_area)  # Ausgabe: 78.53981633974483

In diesem Beispiel importieren wir das Modul math und verwenden dann die Konstante pi und den Operator **, um den Flächeninhalt eines Kreises zu berechnen.

Sie können auch bestimmte Funktionen oder Attribute aus einem Modul importieren:

from math import pi, sqrt
 
radius = 5
circle_area = pi * radius ** 2
diagonal = sqrt(radius ** 2 + radius ** 2)
print(circle_area)  # Ausgabe: 78.53981633974483
print(diagonal)  # Ausgabe: 7.0710678118654755

Hier importieren wir die Funktionen pi und sqrt direkt aus dem Modul math, was es uns ermöglicht, sie ohne das Präfix math. zu verwenden. Um Ihr eigenes Modul zu erstellen, speichern Sie einfach Ihren Python-Code in einer Datei mit der Erweiterung .py. Sie können zum Beispiel eine Datei namens my_module.py mit dem folgenden Inhalt erstellen:

def greet(name):
    print(f"Hallo, {name}!")
 
def calculate_area(length, width):
    return length * width

Sie können dann die Funktionen aus Ihrem Modul importieren und verwenden:

import my_module
 
my_module.greet("Alice")  # Ausgabe: Hallo, Alice!
area = my_module.calculate_area(5, 10)
print(area)  # Ausgabe: 50

Packages sind eine Möglichkeit, Module in eine hierarchische Struktur zu organisieren. Um ein Package zu erstellen, müssen Sie ein Verzeichnis mit einer __init__.py-Datei erstellen. Diese Datei kann leer sein, ist aber erforderlich, damit Python das Verzeichnis als Package erkennt.

Sie können zum Beispiel ein Verzeichnis namens my_package mit einer __init__.py-Datei erstellen und dann eine my_module.py-Datei im Verzeichnis hinzufügen:

my_package/
    __init__.py
    my_module.py

Sie können dann die Funktionen aus dem Modul innerhalb des Packages importieren und verwenden:

import my_package.my_module
 
my_package.my_module.greet("Alice")  # Ausgabe: Hallo, Alice!
area = my_package.my_module.calculate_area(5, 10)
print(area)  # Ausgabe: 50

Alternativ können Sie das from-Statement verwenden, um die Funktionen direkt aus dem Modul zu importieren:

from my_package.my_module import greet, calculate_area
 
greet("Alice")  # Ausgabe: Hallo, Alice!
area = calculate_area(5, 10)
print(area)  # Ausgabe: 50

Datei I/O

Python bietet eingebaute Funktionen zum Lesen aus und Schreiben in Dateien. Die am häufigsten verwendeten Funktionen sind open(), read(), write() und close().

Hier ist ein Beispiel, wie der Inhalt einer Datei gelesen wird:

# Die Datei im Lese-Modus öffnen
with open("beispiel.txt", "r") as datei:
    inhalt = datei.read()
    print(inhalt)

In diesem Beispiel wird die open()-Funktion verwendet, um die Datei beispiel.txt im Lese-Modus ("r") zu öffnen. Die with-Anweisung stellt sicher, dass die Datei ordnungsgemäß geschlossen wird, nachdem der Codeblock ausgeführt wurde, auch wenn eine Ausnahme auftritt.

Sie können auch die Datei Zeile für Zeile lesen:

with open("beispiel.txt", "r") as datei:
    for zeile in datei:
        print(zeile.strip())

Dies gibt jede Zeile der Datei aus und entfernt mit der strip()-Methode führende oder abschließende Leerzeichen.

Zum Schreiben in eine Datei können Sie die write()-Funktion verwenden:

with open("ausgabe.txt", "w") as datei:
    datei.write("Hallo, Welt!\n")
    datei.write("Dies ist eine neue Zeile.\n")

In diesem Beispiel wird die Datei ausgabe.txt im Schreibmodus ("w") geöffnet und dann die write()-Funktion verwendet, um zwei Zeilen Text zur Datei hinzuzufügen.

Sie können auch Daten an eine bestehende Datei anhängen, indem Sie sie im Anhänge-Modus ("a") öffnen:

with open("ausgabe.txt", "a") as datei:
    datei.write("Dies ist eine zusätzliche Zeile.\n")

Dadurch wird eine neue Zeile am Ende der Datei ausgabe.txt hinzugefügt.

Ausnahmebehandlung

Der Mechanismus der Ausnahmebehandlung in Python ermöglicht es Ihnen, Fehler und unerwartete Situationen in Ihrem Code zu behandeln. Das try-except-Block wird verwendet, um Ausnahmen abzufangen und zu behandeln.

Hier ist ein Beispiel, wie man eine ZeroDivisionError behandelt:

try:
    ergebnis = 10 / 0
except ZeroDivisionError:
    print("Fehler: Division durch Null")

In diesem Beispiel versucht der try-Block, 10 durch 0 zu dividieren, was einen ZeroDivisionError verursacht. Der except-Block fängt die Ausnahme ab und gibt eine Fehlermeldung aus.

Sie können auch mehrere Ausnahmen in einem einzigen except-Block behandeln:

try:
    zahl = int(input("Geben Sie eine Zahl ein: "))
    ergebnis = 10 / zahl
except (ValueError, ZeroDivisionError):
    print("Fehler: Ungültige Eingabe oder Division durch Null")

In diesem Beispiel versucht der try-Block, die Eingabe des Benutzers in eine Ganzzahl umzuwandeln und dann 10 durch das Ergebnis zu dividieren. Wenn der Benutzer einen nicht numerischen Wert eingibt, wird ein ValueError ausgelöst, und wenn der Benutzer 0 eingibt, wird ein ZeroDivisionError ausgelöst. Der except-Block fängt beide Ausnahmen ab und gibt eine Fehlermeldung aus.

Sie können auch die Klauseln else und finally mit dem try-except-Block verwenden:

try:
    zahl = int(input("Geben Sie eine Zahl ein: "))
    ergebnis = 10 / zahl
except ValueError:
    print("Fehler: Ungültige Eingabe")
except ZeroDivisionError:
    print("Fehler: Division durch Null")
else:
    print(f"Das Ergebnis ist: {ergebnis}")
finally:
    print("Der 'try-except'-Block ist abgeschlossen.")

In diesem Beispiel wird die else-Klausel ausgeführt, wenn im try-Block keine Ausnahmen ausgelöst werden, und die finally-Klausel wird immer ausgeführt, unabhängig davon, ob eine Ausnahme ausgelöst wurde or not.

Fazit

In diesem Tutorial haben Sie verschiedene Python-Konzepte kennengelernt, darunter Funktionen, Module und Packages, Datei I/O und Ausnahmebehandlung. Diese sind wesentliche Fähigkeiten für jeden Python-Programmierer und werden Ihnen dabei helfen, organisierten, wartbaren und robusten Code zu schreiben.

Denken Sie daran, dass der beste Weg, Ihre Python-Kenntnisse zu verbessern, darin besteht, zu üben. Versuchen Sie, die gelernten Konzepte auf Ihre eigenen Projekte anzuwenden, und scheuen Sie sich nicht, das umfangreiche Ökosystem von Python-Bibliotheken und -Werkzeugen zu erkunden. Viel Glück auf Ihrer Python-Programmierreise!

MoeNagy Dev