Wie generiert man mit Python k zufällige Daten zwischen zwei Daten?

Das Generieren von Zufallsdaten ist im Bereich der Datenwissenschaft sehr wichtig. Beim Erstellen neuronaler Netzwerkvorhersagen, Börsendaten usw. wird normalerweise das Datum als einer der Parameter verwendet. Für die statistische Analyse müssen wir möglicherweise Zufallszahlen zwischen zwei Daten generieren. In diesem Artikel wird gezeigt, wie man k zufällige Daten zwischen zwei bestimmten Daten generiert

Verwenden Sie Zufalls- und Datum/Uhrzeit-Module

Datetime ist Pythons integrierte Bibliothek für die Verarbeitungszeit. Andererseits hilft das Zufallsmodul bei der Generierung von Zufallszahlen. Wir können also Zufalls- und Datum/Uhrzeit-Module kombinieren, um ein zufälliges Datum zwischen zwei Daten zu generieren.

Grammatik

random.randint(start, end, k)

Der Zufall bezieht sich hier auf die Python-Zufallsbibliothek. Die Randint-Methode benötigt drei wichtige Parameter: Start, Ende und k (Anzahl der Elemente). Start und Ende geben den Zahlenbereich an, den wir zur Generierung von Zufallszahlen benötigen. k definiert die Anzahl der Zahlen, die wir generieren müssen

Beispiel

Im folgenden Beispiel erstellen wir eine Funktion namens „generate_random_dates“, die als Parameter das Startdatum, das Enddatum und die Anzahl der zu generierenden Zufallsdaten verwendet. Für k Zufallszahlen verwenden Sie das Zufallsmodul. Wir addieren diese Zahl zum Startdatum, jedoch innerhalb des Enddatumsbereichs.

import random
from datetime import timedelta, datetime
def generate_random_dates(start_date, end_date, k):
    random_dates = []
    date_range = end_date - start_date
    for _ in range(k):
        random_days = random.randint(0, date_range.days)
        random_date = start_date + timedelta(days=random_days)
        random_dates.append(random_date)
    return random_dates
start_date = datetime(2023, 5, 25)
end_date = datetime(2023, 5, 31)
random_dates = generate_random_dates(start_date, end_date, 5)
print("The random dates generated are:")
for index, date in enumerate(random_dates):
    print(f"{index+1}. {date.strftime('%Y-%m-%d')}")

Ausgabe

The random dates generated are:
1. 2023-05-27
2. 2023-05-26
3. 2023-05-27
4. 2023-05-25
5. 2023-05-29

Verwendung von Datetime- und Hash-Methoden

Hash-Funktionen in Python generieren eine Zeichenfolge fester Länge, die als Hash-Wert bezeichnet wird. Wir können Hash-Funktionen verwenden, um Zufälligkeit einzuführen. Eine Hash-Funktion generiert auf Grundlage ihrer Eingabe scheinbar zufällige Werte. Durch Anwenden der Modulo-Operation auf date_range wird der resultierende Hash-Wert auf einen Bereich möglicher Werte innerhalb des gewünschten Datumsbereichs beschränkt.

Grammatik

hash(str(<some value>)) % <range of dates>

Abhängig von der zugrunde liegenden Architektur kann eine Hash-Funktion eine Zeichenfolge annehmen und einen Hash-Wert zurückgeben. % ist der Modulo-Operator, der zur Berechnung des Rests eines Werts verwendet wird. Dadurch wird sichergestellt, dass die Ergebnisse immer mindestens im gewünschten Bereich liegen.

Beispiel

Im folgenden Code iterieren wir k-mal. Wir verwenden eine Hash-Funktion, um den Hash-Wert einer Zeichenfolge zu generieren. Als Nächstes blockieren wir den Datumsbereich, um sicherzustellen, dass die Daten innerhalb bestimmter Start- und Enddaten liegen. Wir hängen die generierten Zufallsdaten an eine Liste namens random_dates

an

from datetime import timedelta, datetime

def generate_random_dates(start_date, end_date, k):
   random_dates = []
   date_range = (end_date - start_date).days + 1

   for _ in range(k):
      random_days = hash(str(_)) % date_range
      random_date = start_date + timedelta(days=random_days)
      random_dates.append(random_date)

   return random_dates

# Example usage
start_date = datetime(2023, 5, 25)
end_date = datetime(2023, 5, 31)
random_dates = generate_random_dates(start_date, end_date, 5)

print("The random dates generated are:")
for index, date in enumerate(random_dates):
   print(f"{index+1}. {date.strftime('%Y-%m-%d')}")

Ausgabe

The random dates generated are:
1. 2023-05-28
2. 2023-05-28
3. 2023-05-25
4. 2023-05-27
5. 2023-05-28

Verwendung von NumPy- und Pandas-Bibliotheken

Numpy und Pandas sind beliebte Python-Bibliotheken für mathematische Berechnungen und Datenanalysen. Die NumPy-Bibliothek verfügt über eine Zufallsmethode, mit der wir Zufallszahlen generieren können. Andererseits können wir die Pandas-Bibliothek verwenden, um Datumsbereiche zu generieren.

Grammatik

numpy.random.randint(start, end , size=<size of the output array> ,
dtype=<data type of the elements>, other parameters.....)

Random Numbers ist ein Modul der NumPy-Bibliothek. Die Randint-Methode verwendet start und end als erforderliche Parameter. Es definiert den Zahlenbereich, den wir benötigen, um Zufallszahlen zu finden. size definiert die Größe des Ausgabearrays und dtype repräsentiert den Datentyp des Elements.

Beispiel

Im folgenden Code haben wir eine Funktion namens „generate_random_dates“ erstellt, die das Startdatum, das Enddatum und die Anzahl der Tage als Parameter verwendet und eine Reihe zufälliger Daten in Form einer Liste zurückgibt. Wir verwenden die Pandas-Bibliothek zum Initialisieren des Datums und die Numpy-Bibliothek zum Generieren der Zahlen.

import numpy as np
import pandas as pd
def generate_random_dates(start_date, end_date, k):
   date_range = (end_date - start_date).days + 1
   random_days = np.random.randint(date_range, size=k)
   random_dates = pd.to_datetime(start_date) + pd.to_timedelta(random_days, unit='d')
   return random_dates
start_date = datetime(2021, 5, 25)
end_date = datetime(2021, 5, 31)
print("The random dates generated are:")
random_dates = generate_random_dates(start_date, end_date, 5)
for index,date in enumerate(random_dates):
   print(f"{index+1}. {date.strftime('%Y-%m-%d')}")

Ausgabe

The random dates generated are:
1. 2021-05-26
2. 2021-05-27
3. 2021-05-27
4. 2021-05-25
5. 2021-05-27

Verwenden Sie Zufalls- und Pfeilbibliotheken

Arrow ist eine Python-Bibliothek. Dies bietet eine bessere und optimiertere Möglichkeit, Datums- und Uhrzeitangaben zu verarbeiten. Wir können die Get-Methode von Arrow verwenden, um die Uhrzeit im Datumsformat abzurufen, und eine Zufallsbibliothek verwenden, um zufällig k Zahlen zwischen dem Startdatum und dem Enddatum abzurufen.

Grammatik

arrow.get(date_string, format=<format of the date string> , tzinfo=<time
zone information>)

Der Pfeil stellt das Pfeilmodul von Python dar. date_string stellt die Datums- und Uhrzeitzeichenfolge dar, die wir analysieren müssen. Es sollte jedoch in einem Format vorliegen, das vom Pfeilmodul erkannt wird. format definiert das Format von date_string. tzinfo stellt Zeitzoneninformationen bereit.

Beispiel

Wir haben im folgenden Code die Pfeilmethode verwendet, um zufällige Daten zu generieren. Wir definieren eine benutzerdefinierte Funktion namens „generate_random_dates“. Wir iterieren k-mal innerhalb der Funktion. Wir verwenden für jede Iteration eine einheitliche Methode, um zufällige Daten zu generieren. Wir verschieben das Datum auf ein zufälliges Datum, sodass das zufällige Datum in diesen Bereich fällt. Wir hängen das Datum an die Liste „random_dates“ an und geben den Wert zurück.

import random
import arrow

def generate_random_dates(start_date, end_date, k):
   random_dates = []
   date_range = (end_date - start_date).days

   for _ in range(k):
      random_days = random.uniform(0, date_range)
      random_date = start_date.shift(days=random_days)
      random_dates.append(random_date)

   return random_dates
start_date = arrow.get('2023-01-01')
end_date = arrow.get('2023-12-31')
random_dates = generate_random_dates(start_date, end_date, 7)
print("The random dates generated are:")
for index,date in enumerate(random_dates):
    print(f"{index+1}. {date.strftime('%Y-%m-%d')}")

Ausgabe

The random dates generated are:
1. 2023-02-05
2. 2023-10-17
3. 2023-10-08
4. 2023-04-18
5. 2023-04-02
6. 2023-08-22
7. 2023-01-01

Fazit

In diesem Artikel haben wir besprochen, wie man mithilfe verschiedener Python-Bibliotheken ein zufälliges Datum zwischen zwei gegebenen Daten generiert. Das Generieren zufälliger Daten ohne Verwendung einer integrierten Bibliothek ist eine mühsame Aufgabe. Daher wird empfohlen, zur Ausführung dieser Aufgabe Bibliotheken und Methoden zu verwenden. Wir können zufällige Daten mithilfe von Datetime, Numpy Pandas usw. generieren. Diese Codes sind keine Methoden usw.

Das obige ist der detaillierte Inhalt vonWie generiert man mit Python k zufällige Daten zwischen zwei Daten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!