Luftverkehrsunfall-Datenvisualisierung mit PyGWalker

Im Zeitalter der modernen Luftfahrt ist es von größter Bedeutung, Flugzeugabstürze zu verstehen. Dies hilft nicht nur dabei, die Sicherheitsmaßnahmen zu verbessern, sondern liefert uns auch Erkenntnisse über die Faktoren, die in der Geschichte die Luftfahrtindustrie beeinflusst haben. In diesem Notebook begeben wir uns auf eine datengetriebene Reise und tauchen tief in die Aufzeichnungen von Flugzeugabstürzen ein. Mit Hilfe der Fähigkeiten von PyGWalker, einer revolutionären Python-Bibliothek zur visuellen Datenexploration, möchten wir Muster, Trends und wichtige Erkenntnisse aus diesen unglücklichen Vorfällen im Laufe der Jahre aufdecken.

Was ist PyGWalker?

PyGWalker ist eine innovative Python-Bibliothek, die entwickelt wurde, um pandas DataFrames in eine interaktive Benutzeroberfläche umzuwandeln, die an Tableau erinnert. Diese Benutzeroberfläche ist auf effiziente und intuitive Datenvisualisierung zugeschnitten und ermöglicht es Benutzern, versteckte Muster und Erkenntnisse in ihren Datensätzen aufzudecken, ohne umfangreiche Codierung zu benötigen. Die Schönheit von PyGWalker liegt in seiner Fähigkeit, komplexe Daten zugänglicher und verständlicher zu machen und die Lücke zwischen Datenwissenschaft und Entscheidungsfindung zu schließen.

(opens in a new tab)

Weitere Details und den Einstieg in PyGWalker finden Sie in seinem offiziellen GitHub-Repository (opens in a new tab).

pip install -q pygwalker --pre

Hinweis: Sie müssen möglicherweise den Kernel neu starten, um aktualisierte Pakete verwenden zu können.

Laden und Erkunden des Flugzeugabsturz-Datensatzes

Wir beginnen damit, den Datensatz zu laden und uns einen ersten Überblick über seine Struktur zu verschaffen.

import pandas as pd
import numpy as np
from datetime import datetime
import pygwalker as pyg
 
# 1. Daten lesen
df = pd.read_csv('/kaggle/input/airplane-crashes-since-1908/Airplane_Crashes_and_Fatalities_Since_1908.csv')

Datenbereinigung und -vorverarbeitung für den Flugzeugabsturz-Datensatz

Um die Genauigkeit unserer Visualisierungen sicherzustellen, müssen wir unsere Daten vorverarbeiten und bereinigen. Dies umfasst die Behandlung von fehlenden Werten, die Extraktion relevanter Zeitmerkmale und mehr.

# 2. Bereinigung der Zeit-Spalte
df['Time'] = df['Time'].replace(np.nan, '00:00') 
df['Time'] = df['Time'].str.replace('c: ', '').str.replace('c:', '').str.replace('c', '')
df['Time'] = df['Time'].str.replace('12\'20', '12:20').str.replace('18.40', '18:40').str.replace('0943', '09:43')
df['Time'] = df['Time'].str.replace('22\'08', '22:08').str.replace('114:20', '00:00')
 
# Extrahieren der Stunde aus der 'Time'-Spalte
df['Hour'] = df['Time'].str.split(':').str[0].astype(int)
 
# 3. Kombinieren der Spalten Datum und Zeit
df['DateTime'] = df['Date'] + ' ' + df['Time']
 
# 4. In das Datumsformat konvertieren
def todate(x):
    return datetime.strptime(x, '%m/%d/%Y %H:%M')
df['DateTime'] = df['DateTime'].apply(todate)
 
# 5. Jahr, Monat und Tag aus DateTime extrahieren
df['Year'] = df['DateTime'].dt.year
df['Month'] = df['DateTime'].dt.month
df['Day'] = df['DateTime'].dt.day
 
print('Der Datumsumfang reicht von ' + str(df.DateTime.min()) + ' bis ' + str(df.DateTime.max()))
 
# 6. Bereinigung der Operator-Spalte
df['Operator'] = df['Operator'].str.upper()

Visualisierung der Flugzeugabsturz-Daten mit PyGWalker

Mit unseren bereinigten und vorverarbeiteten Daten können wir diese nun mit PyGWalker visualisieren. Dies ermöglicht es uns, den Datensatz interaktiv zu erkunden und aussagekräftige Erkenntnisse zu gewinnen.

Übersicht über den Flugzeugabsturz-Datensatz

Beginnen wir damit, den gesamten Datensatz zu visualisieren, um einen allgemeinen Überblick über die Flugzeugabstürze zu erhalten.

# 7. Verwendung von PyGWalker zur Visualisierung (vorausgesetzt, Sie haben bereits config.json konfiguriert)
walker = pyg.walk(df, spec="config.json", use_preview=True)

Sie können die Online-HTML-Version der Daten hier ausprobieren.

Hier sind einige schnelle Datenvisualisierungen für den Flugzeugabsturz-Datensatz:

Übersicht über die Flugzeugabsturz-Vorfälle und die Anzahl der Todesopfer

Flugzeugabsturz-Daten nach Jahr

Flugzeugabsturz-Daten nach Monat

Flugzeugabsturz-Daten nach Tag

Flugzeugabsturz-Daten nach Stunde

Operatorspezifische Erkenntnisse

Um spezifischere Erkenntnisse zu gewinnen, konzentrieren wir uns auf einzelne Betreiber, insbesondere solche, die eine signifikante Anzahl von Einträgen in unserem Datensatz haben.

# Filtern Sie Betreiber mit weniger als 20 Einträgen
filtered_df = df.groupby('Operator').filter(lambda x: len(x) >= 20)
 
# Geben Sie das gefilterte DataFrame an PyGWalker für die Visualisierung weiter
walker_filtered = pyg.walk(filtered_df, spec="config1.json", use_preview=True)

Gesamtzahl der Todesopfer pro Betreiber

Das Verständnis der Gesamtzahl der Todesopfer pro Betreiber kann Aufschluss über die Schwere der von ihnen erlebten Abstürze geben.

# Berechnen Sie die Gesamtzahl der Todesopfer für jeden Betreiber
total_fatalities = filtered_df.groupby('Operator')['Fatalities'].sum().reset_index()
total_fatalities.columns = ['Operator', 'TotalFatalities']
 
# Geben Sie das DataFrame mit den Gesamtzahl der Todesopfer an PyGWalker für die Visualisierung weiter
walker_fatalities = pyg.walk(total_fatalities, spec="config2.json", use_preview=True)

Tiefenanalyse: Aeroflot Airline

Aeroflot, als ein bedeutender Betreiber in unserem Datensatz, verdient eine nähere Betrachtung. Wir werden die jährlichen Todesopfer im Zusammenhang mit Aeroflot analysieren, um den Sicherheitsrekord im Laufe der Jahre zu verstehen.

# Filtern nach der Fluggesellschaft 'Aeroflot'
aeroflot_df = filtered_df[filtered_df['Operator'].str.contains('AEROFLOT', case=False, na=False)]
 
# Berechnung der jährlichen Todesopfer für 'Aeroflot'
yearly_aeroflot_fatalities = aeroflot_df.groupby(aeroflot_df['DateTime'].dt.year)['Fatalities'].sum().reset_index()
yearly_aeroflot_fatalities.columns = ['Jahr', 'Todesopfer']
 
# Übergeben des jährlichen Todesopfer-Datenrahmens für 'Aeroflot' an pygwalker zur Visualisierung
walker_aeroflot = pyg.walk(yearly_aeroflot_fatalities, spec="config3.json", use_preview=True)

Fazit

In diesem Notebook haben wir interaktiv den Datensatz zu Flugzeugabstürzen mit Hilfe von PyGWalker untersucht. Unsere Visualisierungen haben Einblicke in allgemeine Trends von Flugzeugabstürzen, musterbezogene Muster und den Sicherheitsrekord großer Betreiber wie Aeroflot gegeben. Solche Erkenntnisse sind von unschätzbarem Wert, um den historischen Kontext der Flugsicherheit zu verstehen und zukünftige Forschung und politische Entscheidungen in der Luftfahrtindustrie zu unterstützen.

FAQs

1. Warum ist die visuelle Exploration für die Analyse von Flugzeugabsturzdaten wichtig?

Die visuelle Exploration erleichtert das schnellere und intuitivere Verständnis komplexer Datensätze. Im Kontext von Flugzeugabsturzdaten hilft sie dabei, Muster, Zeitrahmen häufiger Vorfälle und Hochrisikobetreiber zu identifizieren. Durch die visuelle Analyse der Daten können Stakeholder fundierte Entscheidungen treffen und proaktive Sicherheitsmaßnahmen ergreifen.

2. Was macht PyGWalker im Vergleich zu anderen Datenauswertungstools besonders?

PyGWalker ist einzigartig in seiner Herangehensweise, indem es einen Pandas-Datenrahmen direkt in eine interaktive Benutzeroberfläche ähnlich wie Tableau umwandelt. Es eliminiert die Notwendigkeit umfangreicher Programmierung bei der Erstellung umfassender Visualisierungen, was es sowohl für Datenwissenschaftler effizient als auch für nicht-technische Benutzer zugänglich macht.

3. Ist PyGWalker für große Datensätze geeignet?

Ja, PyGWalker ist darauf ausgelegt, große Datensätze effektiv zu verarbeiten. Seine intuitive Benutzeroberfläche gewährleistet eine reibungslose Navigation und Exploration unabhängig von der Größe des Datensatzes. Die Leistung kann jedoch je nach Ressourcen des Systems und Komplexität der Daten variieren.

FAQ:

1. Welche Daten gibt es zu Flugzeugabstürzen?

   • Antwort: Die Daten zu Flugzeugabstürzen variieren je nach Quelle und Untersuchungszeitraum. Verschiedene Agenturen und Organisationen wie die Aviation Safety Network und die National Transportation Safety Board (NTSB) führen Aufzeichnungen über Flugvorfälle und -unfälle. Detaillierte Statistiken finden Sie auf ihren jeweiligen Websites.

2. Wie viele Flüge stürzen pro Tag ab?

   • Antwort: Die genaue Anzahl kann variieren, aber es ist wichtig zu beachten, dass der Luftverkehr äußerst sicher ist. Im Durchschnitt gibt es weltweit weniger als zwei große kommerzielle Passagierjet-Unfälle pro Jahr. Angesichts von über 100.000 kommerziellen Flügen pro Tag ist die Absturzrate äußerst gering.

3. Wie viele Flugzeugabstürze gibt es pro Jahr?

   • Antwort: Im Durchschnitt gibt es weltweit weniger als 20 Unfälle mit kommerziellen Passagier- und Frachtflugzeugen pro Jahr. Diese Zahl kann jedoch je nach mehreren Faktoren und den Kriterien für das, was als "Absturz" gilt, variieren.

4. Wie viele Flugzeugabstürze gab es insgesamt in der Geschichte?

   • Antwort: Seit Beginn der Luftfahrt hat es Tausende von Flugzeugabstürzen gegeben, von kleineren Zwischenfällen bis hin zu schweren Unfällen. Detaillierte Statistiken und konkrete Zahlen finden Sie in umfassenden Datenbanken von Organisationen wie dem Aviation Safety Network.