Verwenden von NumPy zum Durchführen von Datums- und Zeitberechnungen

Bild vom Autor | Canva

Datum und Uhrzeit sind der Kern unzähliger Datenanalyseaufgaben, von der Verfolgung finanzieller Transaktionen bis zur Echtzeitüberwachung von Sensordaten. Dennoch kann die Handhabung von Datums- und Uhrzeitberechnungen oft wie das Navigieren durch ein Labyrinth erscheinen.

Zum Glück haben wir mit NumPy Glück. Die robusten Datums- und Zeitfunktionen von NumPy erleichtern diese Aufgaben und bieten eine Reihe von Methoden, die den Prozess enorm vereinfachen.

Mit NumPy können Sie beispielsweise ganz einfach Datumsarrays erstellen, Datums- und Zeitberechnungen durchführen und mit nur wenigen Codezeilen zwischen verschiedenen Zeiteinheiten umrechnen. Müssen Sie die Differenz zwischen zwei Datumsangaben ermitteln? Mit NumPy ist das mühelos möglich. Möchten Sie Ihre Zeitreihendaten auf eine andere Frequenz umrechnen? Mit NumPy sind Sie auf der sicheren Seite. Diese Benutzerfreundlichkeit und Leistung machen NumPy zu einem unverzichtbaren Werkzeug für alle, die mit Datums- und Zeitberechnungen arbeiten. Es macht aus einer einst komplexen Herausforderung eine einfache Aufgabe.

Dieser Artikel führt Sie durch die Durchführung von Datums- und Zeitberechnungen mit NumPy. Wir behandeln Folgendes: Datum/Uhrzeit ist und wie es dargestellt wird, wo Datum und Uhrzeit üblicherweise verwendet werden, häufige Schwierigkeiten und Probleme bei der Verwendung sowie bewährte Vorgehensweisen.

Was ist DateTime?

DateTime bezeichnet die Darstellung von Datum und Uhrzeit in einem einheitlichen Format. Dazu gehören bestimmte Kalenderdaten und -zeiten, oft bis auf Sekundenbruchteile genau. Diese Kombination ist sehr wichtig für die genaue Aufzeichnung und Verwaltung zeitlicher Daten, wie Zeitstempel in Protokollen, das Planen von Ereignissen und die Durchführung zeitbasierter Analysen.

In der allgemeinen Programmierung und Datenanalyse Datum/Uhrzeit wird normalerweise durch spezielle Datentypen oder Objekte dargestellt, die eine strukturierte Möglichkeit zur Verarbeitung von Datums- und Zeitangaben bieten. Diese Objekte ermöglichen eine einfache Bearbeitung, Vergleiche und Rechenoperationen mit Datums- und Zeitangaben.

NumPy und andere Bibliotheken wie Pandas bieten robuste Unterstützung für Datum/Uhrzeit Dadurch wird das Arbeiten mit zeitlichen Daten in verschiedenen Formaten und das Durchführen komplexer Berechnungen einfach und präzise.

In NumPy dreht sich die Datums- und Zeitbehandlung hauptsächlich um die datetime64 Datentyp und zugehörige Funktionen. Sie fragen sich vielleicht, warum der Datentyp heißt datetime64. Das liegt daran, Datum/Uhrzeit ist bereits von der Python-Standardbibliothek belegt.

So funktioniert es im Einzelnen:

datetime64-Datentyp

• Darstellung: NumPys datetime64 dtype stellt Datums- und Uhrzeitangaben als 64-Bit-Ganzzahlen dar und ermöglicht so eine effiziente Speicherung und Bearbeitung zeitlicher Daten.
• Format: Termine und Uhrzeiten in datetime64 Format werden mit einer Zeichenfolge angegeben, die die gewünschte Genauigkeit angibt, wie zum Beispiel YYYY-MM-DD für Termine oder YYYY-MM-DD HH:mm:ss für Zeitstempel bis auf die Sekunde genau.

Zum Beispiel:

import numpy as np

# Making a datetime64 array
dates = np.array(('2024-07-15', '2024-07-16', '2024-07-17'), dtype="datetime64")

# Performing arithmetic operations
next_day = dates + np.timedelta64(1, 'D')

print("Authentic Dates:", dates)
print("Subsequent Day:", next_day)

Merkmale von datetime64 in NumPy

NumPys datetime64 bietet robuste Funktionen zur Vereinfachung verschiedener Operationen. Von der flexiblen Auflösungsbehandlung bis hin zu leistungsstarken Rechenfunktionen, datetime64 macht das Arbeiten mit zeitlichen Daten einfach und effizient.

1. Flexibilität bei der Auflösung: datetime64 unterstützt verschiedene Auflösungen von Nanosekunden bis Jahren. Beispielsweisens (Nanosekunden), uns (Mikrosekunden), MS (Millisekunden), S (Sekunden), M (Minuten), H (Std), D (Tage), B (Wochen), M (Monate), Y (Jahre).

np.datetime64('2024-07-15T12:00', 'm')  # Minute decision
np.datetime64('2024-07-15', 'D')        # Day decision

2. Arithmetische Operationen: Führen Sie direkte Arithmetik durch auf datetime64 Objekte, etwa das Addieren oder Subtrahieren von Zeiteinheiten, beispielsweise das Hinzufügen von Tagen zu einem Datum.

date = np.datetime64('2024-07-15')
next_week = date + np.timedelta64(7, 'D')

3. Indizieren und Slicen: Verwenden Sie standardmäßige NumPy-Indizierungs- und Slicing-Techniken auf datetime64 Arrays. Beispielsweise das Extrahieren eines Datumsbereichs.

dates = np.array(('2024-07-15', '2024-07-16', '2024-07-17'), dtype="datetime64")
subset = dates(1:3)

4. Vergleichsoperationen: Vergleichen datetime64 Objekte, um die chronologische Reihenfolge zu bestimmen. Beispiel: Prüfen, ob ein Datum vor einem anderen liegt.

date1 = np.datetime64('2024-07-15')
date2 = np.datetime64('2024-07-16')
is_before = date1 < date2  # True

5. Konvertierungsfunktionen: Konvertieren zwischen datetime64 und andere Datums-/Zeitdarstellungen. Beispiel: Konvertieren eines datetime64 Objekt in eine Zeichenfolge.

date = np.datetime64('2024-07-15')
date_str = date.astype('str')

Wo verwenden Sie normalerweise Datum und Uhrzeit?

Datum und Uhrzeit können in zahlreichen Bereichen, beispielsweise im Finanzsektor, verwendet werden, um Aktienkurse zu verfolgen, Markttrends zu analysieren, die finanzielle Entwicklung im Zeitverlauf auszuwerten, Renditen zu berechnen, die Volatilität einzuschätzen und Muster in Zeitreihendaten zu erkennen.

Sie können Datum und Uhrzeit auch in anderen Bereichen, beispielsweise im Gesundheitswesen, verwenden, um Patientenakten mit zeitgestempelten Daten für die Krankengeschichte, Behandlungen und Medikamentenpläne zu verwalten.

Szenario: Analyse von E-Commerce-Verkaufsdaten

Stellen Sie sich vor, Sie sind Datenanalyst und arbeiten für ein E-Commerce-Unternehmen. Sie haben einen Datensatz mit Verkaufstransaktionen mit Zeitstempeln und müssen die Verkaufsmuster des letzten Jahres analysieren. So können Sie Folgendes nutzen: datetime64 in NumPy:

# Loading and Changing Knowledge
import numpy as np
import matplotlib.pyplot as plt

# Pattern information: timestamps of gross sales transactions
sales_data = np.array(('2023-07-01T12:34:56', '2023-07-02T15:45:30', '2023-07-03T09:12:10'), dtype="datetime64")

# Extracting Particular Time Intervals
# Extracting gross sales information for July 2023
july_sales = sales_data((sales_data >= np.datetime64('2023-07-01')) & (sales_data < np.datetime64('2023-08-01')))

# Calculating Every day Gross sales Counts
# Changing timestamps to dates
sales_dates = july_sales.astype('datetime64(D)')

# Counting gross sales per day
unique_dates, sales_counts = np.distinctive(sales_dates, return_counts=True)

# Analyzing Gross sales Traits
plt.plot(unique_dates, sales_counts, marker='o')
plt.xlabel('Date')
plt.ylabel('Variety of Gross sales')
plt.title('Every day Gross sales Counts for July 2023')
plt.xticks(rotation=45)  # Rotates x-axis labels for higher readability
plt.tight_layout()  # Adjusts format to forestall clipping of labels
plt.present()

In diesem Szenario datetime64 ermöglicht Ihnen die einfache Bearbeitung und Analyse der Verkaufsdaten und bietet Einblicke in tägliche Verkaufsmuster.

Häufige Schwierigkeiten bei der Verwendung von Datum und Uhrzeit

Während NumPy datetime64 ist ein leistungsstarkes Instrument für die Verarbeitung von Datum und Uhrzeit, aber es bringt auch seine Herausforderungen mit sich. Von der Analyse verschiedener Datumsformate bis zur Verwaltung von Zeitzonen stoßen Entwickler häufig auf mehrere Hürden, die ihre Datenanalyseaufgaben erschweren können. In diesem Abschnitt werden einige dieser typischen Probleme hervorgehoben.

1. Formate analysieren und konvertieren: Der Umgang mit verschiedenen Datums- und Zeitformaten kann eine Herausforderung sein, insbesondere wenn mit Daten aus mehreren Quellen gearbeitet wird.
2. Umgang mit Zeitzonen: datetime64 in NumPy werden Zeitzonen nicht nativ unterstützt.
3. Nicht übereinstimmende Auflösungen: Verschiedene Teile eines Datensatzes können Zeitstempel mit unterschiedlicher Auflösung haben (z. B. einige in Tagen, andere in Sekunden).

So führen Sie Datums- und Zeitberechnungen durch

Lassen Sie uns Beispiele für Datums- und Zeitberechnungen in NumPy untersuchen, von grundlegenden Operationen bis hin zu fortgeschritteneren Szenarien, um Ihnen zu helfen, das volle Potenzial von datetime64 für Ihre Datenanalyseanforderungen.

Hinzufügen von Tagen zu einem Datum

Das Ziel hier ist es, zu demonstrieren, wie man eine bestimmte Anzahl von Tagen hinzufügt (5 Tage in diesem Fall) auf ein bestimmtes Datum (15.07.2024)

import numpy as np

# Outline a date
start_date = np.datetime64('2024-07-15')

# Add 5 days to the date
end_date = start_date + np.timedelta64(5, 'D')

print("Begin Date:", start_date)
print("Finish Date after including 5 days:", end_date)

Ausgabe:

Startdatum: 15.07.2024
Enddatum nach Hinzufügen von 5 Tagen: 20.07.2024

Erläuterung:

• Wir definieren die start_date mit np.datetime64.
• Verwenden von np.timedelta64fügen wir hinzu 5 Tage (5, D) Zu start_date zu bekommen end_date.
• Zum Schluss drucken wir beide start_date Und end_date um das Ergebnis der Addition zu beobachten.

Berechnen der Zeitdifferenz zwischen zwei Daten

Berechnen Sie den Zeitunterschied in Stunden zwischen zwei bestimmten Daten (15.07.2024, 12:00 Uhr Und 17.07.2024, 10:30 Uhr)

import numpy as np

# Outline two dates
date1 = np.datetime64('2024-07-15T12:00')
date2 = np.datetime64('2024-07-17T10:30')

# Calculate the time distinction in hours
time_diff = (date2 - date1) / np.timedelta64(1, 'h')

print("Date 1:", date1)
print("Date 2:", date2)
print("Time distinction in hours:", time_diff)

Ausgabe:

Datum 1: 2024-07-15T12:00
Datum 2: 2024-07-17T10:30
Zeitunterschied in Stunden: 46,5

Erläuterung:

• Definieren date1 Und date2 mit np.datetime64 mit bestimmten Zeitstempeln.
• Berechnen time_diff durch Subtrahieren date1 aus date2 und dividiert durch np.timedelta64(1, 'h') um die Differenz in Stunden umzurechnen.
• Drucken Sie die Originaldaten und die berechnete Zeitdifferenz in Stunden aus.

Umgang mit Zeitzonen und Werktagen

Berechnen Sie die Anzahl der Werktage zwischen zwei Daten, ohne Wochenenden und Feiertage.

import numpy as np
import pandas as pd

# Outline two dates
start_date = np.datetime64('2024-07-01')
end_date = np.datetime64('2024-07-15')

# Convert to pandas Timestamp for extra complicated calculations
start_date_ts = pd.Timestamp(start_date)
end_date_ts = pd.Timestamp(end_date)

# Calculate the variety of enterprise days between the 2 dates
business_days = pd.bdate_range(begin=start_date_ts, finish=end_date_ts).measurement

print("Begin Date:", start_date)
print("Finish Date:", end_date)
print("Variety of Enterprise Days:", business_days)

Ausgabe:

Startdatum: 01.07.2024
Enddatum: 15.07.2024
Anzahl der Werktage: 11

Erläuterung:

• NumPy- und Pandas-Import: NumPy wird importiert als np und Pandas als pd um deren Funktionen zur Datums- und Uhrzeitverarbeitung zu nutzen.
• Datumsdefinition: Definiert start_date Und end_date Verwenden Sie den NumPy-Code fashion=“background: #F5F5F5″ < np.datetime64, um das Begin- und Enddatum anzugeben ('01.07.2024‚ Und ‚15.07.2024‚, jeweils).
• Konvertierung in Pandas-Zeitstempel: Diese Konvertierung konvertiert start_date Und end_date aus np.datetime64 zu Pandas Zeitstempel Objekte (start_date_ts Und end_date_ts) für die Kompatibilität mit den erweiterten Datumsmanipulationsfunktionen von Pandas.
• Berechnung des Geschäftstages: Verwendet pd.bdate_range um einen Bereich von Geschäftsdaten (ausschließlich Wochenenden) zu generieren zwischen start_date_ts Und end_date_tsBerechnen Sie die Größe (Anzahl der Elemente) dieses Geschäftszeitraums (business_days), die die Anzahl der Werktage zwischen den beiden Daten darstellt.
• Drucken des Originals start_date Und end_date.
• Zeigt die berechnete Anzahl von Werktagen an (business_days) zwischen den angegebenen Daten.

Bewährte Vorgehensweisen bei der Verwendung datetime64

Wenn Sie mit Datums- und Zeitdaten in NumPy arbeiten, stellen Sie durch Befolgen bewährter Methoden sicher, dass Ihre Analysen genau, effizient und zuverlässig sind. Der richtige Umgang mit datetime64 können häufige Probleme verhindern und Ihre Datenverarbeitungs-Workflows optimieren. Hier sind einige wichtige Finest Practices, die Sie beachten sollten:

1. Stellen Sie vor der Verarbeitung sicher, dass alle Datums- und Zeitdaten in einem einheitlichen Format vorliegen. Dadurch werden Analysefehler und Inkonsistenzen vermieden.
2. Wählen Sie die Auflösung (‚D‚, ‚H‚, ‚M‚ usw.), die Ihren Datenanforderungen entspricht. Vermeiden Sie das Mischen unterschiedlicher Auflösungen, um Ungenauigkeiten bei den Berechnungen zu vermeiden.
3. Verwenden datetime64 um fehlende oder ungültige Daten darzustellen, und verarbeiten Sie Ihre Daten vorab, um diese Werte vor der Analyse zu berücksichtigen.
4. Wenn Ihre Daten mehrere Zeitzonen umfassen, standardisieren Sie alle Zeitstempel frühzeitig in Ihrem Verarbeitungsworkflow auf eine gemeinsame Zeitzone.
5. Überprüfen Sie, ob Ihre Daten innerhalb gültiger Bereiche für „datetime64“ liegen, um Überlauffehler und unerwartete Ergebnisse zu vermeiden.

Abschluss

Zusammenfassend lässt sich sagen, dass NumPy datetime64 dtype bietet ein robustes Framework für die Verwaltung von Datums- und Zeitdaten in numerischen Berechnungen. Es bietet Vielseitigkeit und Rechenleistung für verschiedene Anwendungen wie Datenanalyse, Simulationen und mehr.

Wir haben untersucht, wie man Datums- und Zeitberechnungen mit NumPy durchführt, und sind dabei auf die Kernkonzepte und deren Darstellung mit dem datetime64 Datentyp. Wir haben die gängigen Anwendungen von Datum und Uhrzeit in der Datenanalyse besprochen. Wir haben auch die üblichen Schwierigkeiten untersucht, die mit der Verarbeitung von Datums- und Uhrzeitdaten in NumPy verbunden sind, wie z. B. Formatinkonsistenzen, Zeitzonenprobleme und Auflösungsinkonsistenzen

Durch die Einhaltung dieser Finest Practices können Sie sicherstellen, dass Ihre Arbeit mit datetime64 ist präzise und effizient und führt zu zuverlässigeren und aussagekräftigeren Erkenntnissen aus Ihren Daten.

Shittu Olumide ist ein Softwareentwickler und technischer Autor, der mit Leidenschaft modernste Technologien nutzt, um überzeugende Geschichten zu schreiben, mit einem scharfen Auge für Particulars und einem Händchen für die Vereinfachung komplexer Konzepte. Sie finden Shittu auch auf Þjórsárden.