Verschiedene Datenanalyseprobleme

PythonPythonBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, mit verschiedenen Python-Datencontainern zu arbeiten und Listen-, Mengen- und Wörterbuch-Komprehensionen zu nutzen. Sie werden auch das collections-Modul erkunden, das nützliche Werkzeuge für die Datenverarbeitung bietet.

Python bietet leistungsstarke Werkzeuge für die Datenmanipulation und -analyse. In diesem Lab üben Sie die Verwendung von Python's integrierten Datenstrukturen und speziellen Werkzeugen zur Analyse verschiedener Datensätze. Beginnen Sie mit einem einfachen Portfoliodatensatz und gehen Sie dann zur Analyse der Busdaten der Chicago Transit Authority über, um sinnvolle Erkenntnisse zu gewinnen.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/DataScienceandMachineLearningGroup(["Data Science and Machine Learning"]) python(("Python")) -.-> python/ControlFlowGroup(["Control Flow"]) python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FileHandlingGroup(["File Handling"]) python(("Python")) -.-> python/PythonStandardLibraryGroup(["Python Standard Library"]) python/ControlFlowGroup -.-> python/list_comprehensions("List Comprehensions") python/DataStructuresGroup -.-> python/lists("Lists") python/DataStructuresGroup -.-> python/dictionaries("Dictionaries") python/DataStructuresGroup -.-> python/sets("Sets") python/FileHandlingGroup -.-> python/file_reading_writing("Reading and Writing Files") python/FileHandlingGroup -.-> python/file_operations("File Operations") python/PythonStandardLibraryGroup -.-> python/data_collections("Data Collections") python/DataScienceandMachineLearningGroup -.-> python/data_analysis("Data Analysis") subgraph Lab Skills python/list_comprehensions -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} python/lists -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} python/dictionaries -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} python/sets -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} python/file_reading_writing -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} python/file_operations -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} python/data_collections -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} python/data_analysis -.-> lab-132438{{"Verschiedene Datenanalyseprobleme"}} end

Arbeiten mit Wörterbüchern und CSV-Daten

Beginnen wir damit, einen einfachen Datensatz über Aktienbesitz zu untersuchen. In diesem Schritt lernen Sie, wie Sie Daten aus einer CSV-Datei lesen und mithilfe von Wörterbüchern in einem strukturierten Format speichern.

Eine CSV (Comma-Separated Values, Komma-separierte Werte)-Datei ist eine gängige Methode, um tabellarische Daten zu speichern, wobei jede Zeile eine Zeile darstellt und die Werte durch Kommas getrennt sind. Wörterbücher in Python sind eine leistungsstarke Datenstruktur, die es Ihnen ermöglicht, Schlüssel-Wert-Paare zu speichern. Indem wir Wörterbücher verwenden, können wir die Daten aus der CSV-Datei auf eine sinnvollere Weise organisieren.

Erstellen Sie zunächst eine neue Python-Datei in der WebIDE, indem Sie die folgenden Schritte ausführen:

  1. Klicken Sie auf die Schaltfläche "Neue Datei" in der WebIDE.
  2. Benennen Sie die Datei readport.py.
  3. Kopieren und fügen Sie den folgenden Code in die Datei ein:
## readport.py

import csv

## A function that reads a file into a list of dictionaries
def read_portfolio(filename):
    portfolio = []
    with open(filename) as f:
        rows = csv.reader(f)
        headers = next(rows)   ## Skip the header row
        for row in rows:
            record = {
                'name': row[0],
                'shares': int(row[1]),
                'price': float(row[2])
            }
            portfolio.append(record)
    return portfolio

Dieser Code definiert eine Funktion read_portfolio, die mehrere wichtige Aufgaben ausführt:

  1. Sie öffnet eine CSV-Datei, die durch den Parameter filename angegeben wird. Die Funktion open wird verwendet, um auf die Datei zuzugreifen, und die with-Anweisung stellt sicher, dass die Datei ordnungsgemäß geschlossen wird, nachdem wir sie gelesen haben.
  2. Sie überspringt die Kopfzeile. Die Kopfzeile enthält normalerweise die Namen der Spalten in der CSV-Datei. Wir verwenden next(rows), um den Iterator zur nächsten Zeile zu bewegen und somit die Kopfzeile zu überspringen.
  3. Für jede Datenzeile erstellt sie ein Wörterbuch. Die Schlüssel des Wörterbuchs sind 'name', 'shares' und 'price'. Diese Schlüssel helfen uns, die Daten auf eine intuitivere Weise zuzugreifen.
  4. Sie konvertiert die Anzahl der Aktien in Ganzzahlen und die Preise in Gleitkommazahlen. Dies ist wichtig, da die aus der CSV-Datei gelesenen Daten zunächst im String-Format vorliegen und wir numerische Werte für Berechnungen benötigen.
  5. Sie fügt jedes Wörterbuch einer Liste namens portfolio hinzu. Diese Liste enthält alle Datensätze aus der CSV-Datei.
  6. Schließlich gibt sie die vollständige Liste der Wörterbücher zurück.

Nun erstellen wir eine Datei für die Transitdaten. Erstellen Sie eine neue Datei namens readrides.py mit folgendem Inhalt:

## readrides.py

import csv

def read_rides_as_dicts(filename):
    """
    Read the CTA bus data as a list of dictionaries
    """
    records = []
    with open(filename) as f:
        rows = csv.reader(f)
        headers = next(rows)   ## Skip header
        for row in rows:
            route = row[0]
            date = row[1]
            daytype = row[2]
            rides = int(row[3])
            record = {
                'route': route,
                'date': date,
                'daytype': daytype,
                'rides': rides
            }
            records.append(record)
    return records

Die Funktion read_rides_as_dicts funktioniert ähnlich wie die Funktion read_portfolio. Sie liest eine CSV-Datei, die sich auf die CTA-Busdaten bezieht, überspringt die Kopfzeile, erstellt für jede Datenzeile ein Wörterbuch und speichert diese Wörterbücher in einer Liste.

Nun testen wir die Funktion read_portfolio, indem wir in der WebIDE ein Terminal öffnen:

  1. Klicken Sie auf das Menü "Terminal" und wählen Sie "Neues Terminal" aus.
  2. Starten Sie den Python-Interpreter, indem Sie python3 eingeben.
  3. Führen Sie die folgenden Befehle aus:
>>> from readport import read_portfolio
>>> portfolio = read_portfolio('/home/labex/project/portfolio.csv')
>>> from pprint import pprint
>>> pprint(portfolio)
[{'name': 'AA', 'price': 32.2, 'shares': 100},
 {'name': 'IBM', 'price': 91.1, 'shares': 50},
 {'name': 'CAT', 'price': 83.44, 'shares': 150},
 {'name': 'MSFT', 'price': 51.23, 'shares': 200},
 {'name': 'GE', 'price': 40.37, 'shares': 95},
 {'name': 'MSFT', 'price': 65.1, 'shares': 50},
 {'name': 'IBM', 'price': 70.44, 'shares': 100}]

Die Funktion pprint (pretty print) wird hier verwendet, um die Daten in einem lesbareren Format anzuzeigen. Jedes Element in der Liste ist ein Wörterbuch, das einen Aktienbesitz darstellt. Das Wörterbuch hat die folgenden Schlüssel:

  • Ein Aktiensymbol (name): Dies ist die Abkürzung, die zur Identifizierung der Aktie verwendet wird.
  • Anzahl der gehaltenen Aktien (shares): Dies gibt an, wie viele Aktien der Aktie gehalten werden.
  • Kaufpreis pro Aktie (price): Dies ist der Preis, zu dem jede Aktie gekauft wurde.

Beachten Sie, dass einige Aktien wie 'MSFT' und 'IBM' mehrmals auftauchen. Dies repräsentiert verschiedene Käufe derselben Aktie, die möglicherweise zu verschiedenen Zeiten und zu verschiedenen Preisen getätigt wurden.

✨ Lösung prüfen und üben

Verwendung von Listen-, Mengen- und Wörterbuch-Komprehensionen

Python-Komprehensionen sind eine sehr nützliche und kompakte Methode, um neue Sammlungen (Collections) auf der Grundlage bestehender zu erstellen. Sammlungen in Python können Listen, Mengen oder Wörterbücher sein, die wie Container fungieren, die verschiedene Datentypen enthalten. Komprehensionen ermöglichen es Ihnen, bestimmte Daten auszufiltern, die Daten auf irgendeine Weise zu transformieren und sie effizienter zu organisieren. In diesem Teil werden wir unsere Portfoliodaten nutzen, um zu untersuchen, wie diese Komprehensionen funktionieren.

Zunächst müssen Sie ein Python-Terminal öffnen, genau wie Sie es im vorherigen Schritt getan haben. Sobald das Terminal geöffnet ist, geben Sie die folgenden Beispiele nacheinander ein. Dieser praktische Ansatz wird Ihnen helfen, zu verstehen, wie Komprehensionen in der Praxis funktionieren.

Listen-Komprehensionen

Eine Listen-Komprehension ist eine spezielle Syntax in Python, die eine neue Liste erstellt. Sie tut dies, indem sie einen Ausdruck auf jedes Element in einer bestehenden Sammlung anwendet.

Beginnen wir mit einem Beispiel. Zunächst importieren wir eine Funktion, um unsere Portfoliodaten zu lesen. Dann verwenden wir eine Listen-Komprehension, um bestimmte Anteile aus dem Portfolio auszufiltern.

>>> from readport import read_portfolio
>>> portfolio = read_portfolio('/home/labex/project/portfolio.csv')

## Find all holdings with more than 100 shares
>>> large_holdings = [s for s in portfolio if s['shares'] > 100]
>>> print(large_holdings)
[{'name': 'CAT', 'shares': 150, 'price': 83.44}, {'name': 'MSFT', 'shares': 200, 'price': 51.23}]

In diesem Code importieren wir zunächst die Funktion read_portfolio und verwenden sie, um die Portfoliodaten aus einer CSV-Datei zu lesen. Dann geht die Listen-Komprehension [s for s in portfolio if s['shares'] > 100] durch jedes Element s in der portfolio-Sammlung. Sie fügt das Element s nur zur neuen Liste large_holdings hinzu, wenn die Anzahl der Anteile in diesem Bestandteil größer als 100 ist.

Listen-Komprehensionen können auch zur Durchführung von Berechnungen verwendet werden. Hier sind einige Beispiele:

## Calculate the total cost of each holding (shares * price)
>>> holding_costs = [s['shares'] * s['price'] for s in portfolio]
>>> print(holding_costs)
[3220.0, 4555.0, 12516.0, 10246.0, 3835.15, 3255.0, 7044.0]

## Calculate the total cost of the entire portfolio
>>> total_portfolio_cost = sum([s['shares'] * s['price'] for s in portfolio])
>>> print(total_portfolio_cost)
44671.15

Im ersten Beispiel berechnet die Listen-Komprehension [s['shares'] * s['price'] for s in portfolio] die Gesamtkosten jedes Bestandteils, indem sie die Anzahl der Anteile mit dem Preis für jedes Element in der portfolio multipliziert. Im zweiten Beispiel verwenden wir die Funktion sum zusammen mit der Listen-Komprehension, um die Gesamtkosten des gesamten Portfolios zu berechnen.

Mengen-Komprehensionen

Eine Mengen-Komprehension wird verwendet, um eine Menge aus einer bestehenden Sammlung zu erstellen. Eine Menge ist eine Sammlung, die nur eindeutige Werte enthält.

Schauen wir uns an, wie es mit unseren Portfoliodaten funktioniert:

## Find all unique stock names
>>> unique_stocks = {s['name'] for s in portfolio}
>>> print(unique_stocks)
{'MSFT', 'IBM', 'AA', 'GE', 'CAT'}

In diesem Code geht die Mengen-Komprehension {s['name'] for s in portfolio} durch jedes Element s in der portfolio und fügt den Aktiennamen (s['name']) zur Menge unique_stocks hinzu. Da Mengen nur eindeutige Werte speichern, erhalten wir am Ende eine Liste aller verschiedenen Aktien in unserem Portfolio ohne Duplikate.

Wörterbuch-Komprehensionen

Eine Wörterbuch-Komprehension erstellt ein neues Wörterbuch, indem sie Ausdrücke anwendet, um Schlüssel-Wert-Paare zu erstellen.

Hier ist ein Beispiel für die Verwendung einer Wörterbuch-Komprehension, um die Gesamtanzahl der Anteile für jede Aktie in unserem Portfolio zu zählen:

## Create a dictionary to count total shares for each stock
>>> totals = {s['name']: 0 for s in portfolio}
>>> for s in portfolio:
...     totals[s['name']] += s['shares']
...
>>> print(totals)
{'AA': 100, 'IBM': 150, 'CAT': 150, 'MSFT': 250, 'GE': 95}

In der ersten Zeile erstellt die Wörterbuch-Komprehension {s['name']: 0 for s in portfolio} ein Wörterbuch, in dem jeder Aktienname (s['name']) ein Schlüssel ist und der anfängliche Wert für jeden Schlüssel 0 ist. Dann verwenden wir eine for-Schleife, um durch jedes Element in der portfolio zu gehen. Für jedes Element addieren wir die Anzahl der Anteile (s['shares']) zum entsprechenden Wert im totals-Wörterbuch.

Diese Komprehensionen sind sehr leistungsstark, da sie es Ihnen ermöglichen, Daten mit nur wenigen Codezeilen zu transformieren und zu analysieren. Sie sind ein großartiges Werkzeug in Ihrem Python-Programmierwerkzeugkasten.

Erkundung des collections-Moduls

In Python sind die eingebauten Container wie Listen, Wörterbücher und Mengen sehr nützlich. Allerdings geht das collections-Modul von Python einen Schritt weiter, indem es spezialisierte Container-Datentypen bereitstellt, die die Funktionalität dieser eingebauten Container erweitern. Werfen wir einen genaueren Blick auf einige dieser nützlichen Datentypen.

Sie werden weiterhin in Ihrem Python-Terminal arbeiten und den untenstehenden Beispielen folgen.

Counter

Die Counter-Klasse ist eine Unterklasse des Wörterbuchs. Ihr Hauptzweck besteht darin, hashbare Objekte zu zählen. Sie bietet eine bequeme Möglichkeit, Elemente zu zählen und unterstützt eine Vielzahl von Operationen.

Zunächst müssen wir die Counter-Klasse und eine Funktion zum Lesen eines Portfolios importieren. Dann lesen wir ein Portfolio aus einer CSV-Datei.

>>> from collections import Counter
>>> from readport import read_portfolio
>>> portfolio = read_portfolio('/home/labex/project/portfolio.csv')

Jetzt erstellen wir ein Counter-Objekt, um die Anzahl der Anteile für jede Aktie anhand ihres Namens zu zählen.

## Create a counter to count shares by stock name
>>> totals = Counter()
>>> for s in portfolio:
...     totals[s['name']] += s['shares']
...
>>> print(totals)
Counter({'MSFT': 250, 'IBM': 150, 'CAT': 150, 'AA': 100, 'GE': 95})

Eines der großartigen Merkmale des Counter-Objekts ist, dass es neue Schlüssel automatisch mit einer Anzahl von 0 initialisiert. Dies bedeutet, dass Sie nicht prüfen müssen, ob ein Schlüssel existiert, bevor Sie seine Anzahl erhöhen, was den Code zum Akkumulieren von Zählungen vereinfacht.

Counters verfügen auch über spezielle Methoden. Beispielsweise ist die most_common()-Methode für die Datenanalyse sehr nützlich.

## Get the two stocks with the most shares
>>> most_common_stocks = totals.most_common(2)
>>> print(most_common_stocks)
[('MSFT', 250), ('IBM', 150)]

Darüber hinaus können Zähler mithilfe von arithmetischen Operationen kombiniert werden.

## Create another counter
>>> more = Counter()
>>> more['IBM'] = 75
>>> more['AA'] = 200
>>> more['ACME'] = 30
>>> print(more)
Counter({'AA': 200, 'IBM': 75, 'ACME': 30})

## Add two counters together
>>> combined = totals + more
>>> print(combined)
Counter({'AA': 300, 'MSFT': 250, 'IBM': 225, 'CAT': 150, 'GE': 95, 'ACME': 30})

defaultdict

Das defaultdict ähnelt einem normalen Wörterbuch, hat aber ein einzigartiges Merkmal. Es bietet einen Standardwert für Schlüssel, die noch nicht existieren. Dies kann Ihren Code vereinfachen, da Sie nicht mehr prüfen müssen, ob ein Schlüssel existiert, bevor Sie ihn verwenden.

>>> from collections import defaultdict

## Group portfolio entries by stock name
>>> byname = defaultdict(list)
>>> for s in portfolio:
...     byname[s['name']].append(s)
...
>>> print(byname['IBM'])
[{'name': 'IBM', 'shares': 50, 'price': 91.1}, {'name': 'IBM', 'shares': 100, 'price': 70.44}]
>>> print(byname['AA'])
[{'name': 'AA', 'shares': 100, 'price': 32.2}]

Wenn Sie ein defaultdict(list) erstellen, erstellt es automatisch eine neue leere Liste für jeden neuen Schlüssel. So können Sie direkt an den Wert eines Schlüssels anhängen, auch wenn der Schlüssel vorher nicht existierte. Dies beseitigt die Notwendigkeit, zu prüfen, ob der Schlüssel existiert, und manuell eine leere Liste zu erstellen.

Sie können auch andere Standard-Fabrikfunktionen verwenden. Beispielsweise können Sie int, float oder sogar Ihre eigene benutzerdefinierte Funktion verwenden.

## Use defaultdict with int to count items
>>> word_counts = defaultdict(int)
>>> words = ['apple', 'orange', 'banana', 'apple', 'orange', 'apple']
>>> for word in words:
...     word_counts[word] += 1
...
>>> print(word_counts)
defaultdict(<class 'int'>, {'apple': 3, 'orange': 2, 'banana': 1})

Diese spezialisierten Container-Typen aus dem collections-Modul können Ihren Code kompakter und effizienter machen, wenn Sie mit Daten arbeiten.

Datenanalyse-Aufgabe mit Daten der Chicago Transit Authority

Nachdem Sie sich mit verschiedenen Python-Datenstrukturen und dem collections-Modul vertraut gemacht haben, ist es an der Zeit, diese Fähigkeiten in einer echten Datenanalyseaufgabe anzuwenden. In diesem Experiment werden wir die Fahrgastzahlen der Busse der Chicago Transit Authority (CTA) analysieren. Diese praktische Anwendung wird Ihnen helfen, zu verstehen, wie Sie Python nutzen können, um sinnvolle Informationen aus echten Datensätzen zu extrahieren.

Das Verständnis der Daten

Zunächst werfen wir einen Blick auf die Verkehrsdaten, mit denen wir arbeiten werden. Im Python-Terminal führen Sie Code aus, um die Daten zu laden und deren grundlegende Struktur zu verstehen.

>>> import readrides
>>> rows = readrides.read_rides_as_dicts('/home/labex/project/ctabus.csv')
>>> print(len(rows))
## This will show the number of records in the dataset

>>> ## Let's look at the first record to understand the structure
>>> import pprint
>>> pprint.pprint(rows[0])

Die Anweisung import readrides importiert ein benutzerdefiniertes Modul, das eine Funktion zum Lesen der Daten aus der CSV-Datei enthält. Die Funktion readrides.read_rides_as_dicts liest die Daten aus der angegebenen CSV-Datei und wandelt jede Zeile in ein Wörterbuch um. len(rows) gibt uns die Gesamtzahl der Datensätze im Datensatz. Indem wir den ersten Datensatz mit pprint.pprint(rows[0]) ausgeben, können wir die Struktur jedes Datensatzes deutlich sehen.

Die Daten enthalten tägliche Fahrgastzahlen für verschiedene Buslinien. Jeder Datensatz umfasst:

  • route: Die Busliniennummer
  • date: Das Datum im Format "YYYY - MM - DD"
  • daytype: Entweder "W" für Wochentag, "A" für Samstag oder "U" für Sonntag/Ferientag
  • rides: Die Anzahl der Fahrgäste an diesem Tag

Analyseaufgaben

Lösen wir die einzelnen Aufgaben nacheinander:

Frage 1: Wie viele Buslinien gibt es in Chicago?

Um diese Frage zu beantworten, müssen wir alle eindeutigen Liniennummern im Datensatz finden. Hierfür verwenden wir eine Mengen-Komprehension.

>>> ## Get all unique route numbers using a set comprehension
>>> unique_routes = {row['route'] for row in rows}
>>> print(len(unique_routes))

Eine Mengen-Komprehension ist eine kompakte Methode, um eine Menge zu erstellen. In diesem Fall iterieren wir über jede Zeile in der rows-Liste und extrahieren den route-Wert. Da eine Menge nur eindeutige Elemente speichert, erhalten wir am Ende eine Menge aller eindeutigen Liniennummern. Das Ausgeben der Länge dieser Menge gibt uns die Gesamtzahl der eindeutigen Buslinien.

Wir können auch einige dieser Linien anzeigen:

>>> ## Print a few of the route numbers
>>> print(list(unique_routes)[:10])

Hier wandeln wir die Menge der eindeutigen Linien in eine Liste um und geben dann die ersten 10 Elemente dieser Liste aus.

Frage 2: Wie viele Menschen fuhren am 2. Februar 2011 mit der Linie 22?

Für diese Frage müssen wir die Daten filtern, um den spezifischen Datensatz zu finden, der der angegebenen Linie und dem Datum entspricht.

>>> ## Find rides on route 22 on February 2, 2011
>>> target_date = "2011-02-02"
>>> target_route = "22"
>>>
>>> for row in rows:
...     if row['route'] == target_route and row['date'] == target_date:
...         print(f"Rides on route {target_route} on {target_date}: {row['rides']}")
...         break

Wir definieren zunächst die Variablen target_date und target_route. Dann iterieren wir über jede Zeile in der rows-Liste. Für jede Zeile prüfen wir, ob die route und das date unseren Zielwerten entsprechen. Wenn eine Übereinstimmung gefunden wird, geben wir die Anzahl der Fahrgäste aus und brechen die Schleife ab, da wir den gesuchten Datensatz gefunden haben.

Sie können dies ändern, um jede Linie an jedem beliebigen Datum zu überprüfen, indem Sie die Variablen target_date und target_route ändern.

Frage 3: Wie viele Fahrgäste nutzen insgesamt jede Buslinie?

Wir verwenden einen Counter, um die Gesamtzahl der Fahrgäste pro Linie zu berechnen. Ein Counter ist eine Unterklasse des Wörterbuchs aus dem collections-Modul, das zum Zählen von hashbaren Objekten verwendet wird.

>>> from collections import Counter
>>>
>>> ## Initialize a counter
>>> total_rides_by_route = Counter()
>>>
>>> ## Sum up rides for each route
>>> for row in rows:
...     total_rides_by_route[row['route']] += row['rides']
...
>>> ## View the top 5 routes by total ridership
>>> for route, rides in total_rides_by_route.most_common(5):
...     print(f"Route {route}: {rides:,} total rides")

Wir importieren zunächst die Counter-Klasse aus dem collections-Modul. Dann initialisieren wir einen leeren Zähler namens total_rides_by_route. Während wir über jede Zeile in der rows-Liste iterieren, addieren wir die Anzahl der Fahrgäste für jede Linie zum Zähler. Schließlich verwenden wir die Methode most_common(5), um die 5 Linien mit der höchsten Gesamtzahl der Fahrgäste zu erhalten und die Ergebnisse auszugeben.

Frage 4: Welche fünf Buslinien hatten die größte Zunahme der Fahrgastzahl von 2001 bis 2011?

Dies ist eine komplexere Aufgabe. Wir müssen die Fahrgastzahlen von 2001 mit denen von 2011 für jede Linie vergleichen.

>>> ## Create dictionaries to store total annual rides by route
>>> rides_2001 = Counter()
>>> rides_2011 = Counter()
>>>
>>> ## Collect data for each year
>>> for row in rows:
...     if row['date'].startswith('2001-'):
...         rides_2001[row['route']] += row['rides']
...     elif row['date'].startswith('2011-'):
...         rides_2011[row['route']] += row['rides']
...
>>> ## Calculate increases
>>> increases = {}
>>> for route in unique_routes:
...     if route in rides_2001 and route in rides_2011:
...         increase = rides_2011[route] - rides_2001[route]
...         increases[route] = increase
...
>>> ## Find the top 5 routes with the biggest increases
>>> import heapq
>>> top_5_increases = heapq.nlargest(5, increases.items(), key=lambda x: x[1])
>>>
>>> ## Display the results
>>> print("Top 5 routes with the greatest ridership increase from 2001 to 2011:")
>>> for route, increase in top_5_increases:
...     print(f"Route {route}: increased by {increase:,} rides")
...     print(f"  2001 rides: {rides_2001[route]:,}")
...     print(f"  2011 rides: {rides_2011[route]:,}")
...     print()

Wir erstellen zunächst zwei Counter-Objekte, rides_2001 und rides_2011, um die Gesamtzahl der Fahrgäste für jede Linie in 2001 bzw. 2011 zu speichern. Während wir über jede Zeile in der rows-Liste iterieren, prüfen wir, ob das Datum mit '2001 -' oder '2011 -' beginnt und fügen die Fahrgäste dem entsprechenden Zähler hinzu.

Dann erstellen wir ein leeres Wörterbuch increases, um die Zunahme der Fahrgastzahl für jede Linie zu speichern. Wir iterieren über die eindeutigen Linien und berechnen die Zunahme, indem wir die Fahrgäste von 2001 von denen von 2011 subtrahieren.

Um die 5 Linien mit der größten Zunahme zu finden, verwenden wir die Funktion heapq.nlargest. Diese Funktion nimmt die Anzahl der zurückzugebenden Elemente (in diesem Fall 5), das Iterable (increases.items()) und eine Schlüsselfunktion (lambda x: x[1]), die angibt, wie die Elemente verglichen werden sollen.

Schließlich geben wir die Ergebnisse aus, wobei wir die Liniennummer, die Zunahme der Fahrgastzahl und die Anzahl der Fahrgäste in 2001 und 2011 anzeigen.

Diese Analyse zeigt, welche Buslinien in der Dekade die stärkste Zunahme der Fahrgastzahl verzeichnet haben, was auf sich ändernde Bevölkerungsmuster, Verbesserungen des Fahrplans oder andere interessante Trends hinweisen könnte.

Sie können diese Analysen auf viele Weise erweitern. Beispielsweise möchten Sie möglicherweise:

  • Die Fahrgastmuster nach Wochentag analysieren
  • Linien mit abnehmender Fahrgastzahl finden
  • Die saisonalen Schwankungen der Fahrgastzahl vergleichen

Die Techniken, die Sie in diesem Lab gelernt haben, bilden eine solide Grundlage für diese Art von Datenexploration und -analyse.

✨ Lösung prüfen und üben

Zusammenfassung

In diesem Lab haben Sie mehrere wichtige Techniken zur Datenmanipulation in Python gelernt. Dazu gehören das Lesen und Verarbeiten von CSV-Daten in Wörterbüchern, die Verwendung von Listen-, Mengen- und Wörterbuch-Komprehensionen zur Datenumwandlung sowie die Nutzung spezieller Containertypen aus dem collections-Modul. Sie haben diese Fähigkeiten auch eingesetzt, um sinnvolle Datenanalysen durchzuführen.

Diese Techniken sind grundlegend für die Datenanalyse in Python und von Wert in verschiedenen realen Szenarien. Die Fähigkeit, Daten zu verarbeiten, umzuwandeln und Erkenntnisse daraus zu gewinnen, ist für Python-Programmierer von entscheidender Bedeutung. Üben Sie weiterhin mit Ihren eigenen Datensätzen, um Ihre Kompetenz in der Python-Datenanalyse zu verbessern.