दो अन्य तिथियों के बीच एक यादृच्छिक तारीख उत्पन्न करें


138

मैं एक यादृच्छिक तारीख कैसे उत्पन्न करूँगा जो दो अन्य दी गई तारीखों के बीच होनी चाहिए?

फ़ंक्शन का हस्ताक्षर कुछ इस तरह होना चाहिए:

random_date("1/1/2008 1:30 PM", "1/1/2009 4:50 AM", 0.34)
                   ^                       ^          ^

            date generated has  date generated has  a random number
            to be after this    to be before this

और इस तरह की तारीख लौटाएगा: 2/4/2008 7:20 PM


जिस तरह से प्रश्न को फिलहाल प्रस्तुत किया गया है, यह स्पष्ट नहीं है कि आप केवल तारीख या समय यादृच्छिक होना चाहते हैं या नहीं। आपका उदाहरण बताता है कि आप एक समय की तलाश में हैं। यदि आपको दो तारीखों के बीच में रहना है तो आप अपनी आवश्यकताओं के अनुरूप अभी तक दिए गए उत्तरों को संशोधित कर सकते हैं और अंत और प्रारंभ समय को छोड़ सकते हैं। अंत में, अधिकांश उत्तरों में, जैसे कि स्वीकार किए जाते हैं, कोड int के लिए ट्रंक करने के कारण एक डेटाइम अनन्य एंडटाइम आउटपुट देता है। एक समय उत्पन्न करने के लिए जो उत्तर में अंत को शामिल कर सकता है कोड को ptime = stime + prop * (etime - stime) + 0.5
बदलकर

जवाबों:


149

दोनों स्ट्रिंग्स को टाइमस्टैम्प में कनवर्ट करें (अपने चुने हुए रिज़ॉल्यूशन में, जैसे कि मिलीसेकंड, सेकंड, घंटे, दिन, जो भी हो), पहले वाले को बाद में से घटाएं, अपने रैंडम नंबर को गुणा करें (यह मानते हुए कि यह range [0, 1]उस अंतर में वितरित है ), और फिर से जोड़ें पहले वाला। टाइमस्टैम्प को वापस स्ट्रिंग में परिवर्तित करें और आपके पास उस श्रेणी में एक यादृच्छिक समय है।

पायथन उदाहरण (आउटपुट आपके द्वारा निर्दिष्ट प्रारूप में, 0पैडिंग के अलावा - अमेरिकी समय प्रारूप परंपराओं को दोष देता है):

import random
import time

def str_time_prop(start, end, format, prop):
    """Get a time at a proportion of a range of two formatted times.

    start and end should be strings specifying times formated in the
    given format (strftime-style), giving an interval [start, end].
    prop specifies how a proportion of the interval to be taken after
    start.  The returned time will be in the specified format.
    """

    stime = time.mktime(time.strptime(start, format))
    etime = time.mktime(time.strptime(end, format))

    ptime = stime + prop * (etime - stime)

    return time.strftime(format, time.localtime(ptime))


def random_date(start, end, prop):
    return str_time_prop(start, end, '%m/%d/%Y %I:%M %p', prop)

print(random_date("1/1/2008 1:30 PM", "1/1/2009 4:50 AM", random.random()))

यह दृष्टिकोण 1970 से पहले शुरू होने वाली तारीखों का समर्थन नहीं करता है।
कोम्बोन

114
from random import randrange
from datetime import timedelta

def random_date(start, end):
    """
    This function will return a random datetime between two datetime 
    objects.
    """
    delta = end - start
    int_delta = (delta.days * 24 * 60 * 60) + delta.seconds
    random_second = randrange(int_delta)
    return start + timedelta(seconds=random_second)

सटीक सेकंड है। यदि आप चाहें, तो आप माइक्रोसेकंड तक की सटीकता बढ़ा सकते हैं, या घटा सकते हैं, कह सकते हैं, आधे घंटे। उसके लिए बस अंतिम पंक्ति की गणना को बदलें।

उदाहरण रन:

from datetime import datetime

d1 = datetime.strptime('1/1/2008 1:30 PM', '%m/%d/%Y %I:%M %p')
d2 = datetime.strptime('1/1/2009 4:50 AM', '%m/%d/%Y %I:%M %p')

print(random_date(d1, d2))

उत्पादन:

2008-12-04 01:50:17

3
startउस मामले में चर का उपयोग पूरी तरह से सही है। एकमात्र समस्या जो मुझे कोड में दिख रही है, secondsवह परिणामी से विशेषता का उपयोग है delta। यह पूरे अंतराल में कुल सेकंड में नहीं लौटेगा; इसके बजाय, यह 'समय' घटक (0 और 60 के बीच कुछ) से सेकंड की संख्या है; एक timedeltaऑब्जेक्ट में एक total_secondsविधि है, जिसका उपयोग इसके बजाय किया जाना चाहिए।
एमिलर

7
@ दुश्मन: नहीं, मैं (delta.days * 24 * 60 * 60) + delta.secondsकुल सेकंड में जो परिणाम का उपयोग कर रहा हूँ । total_seconds()पाइथन 2.7 में यह विधि नई है और जब मैंने सवाल का जवाब दिया तो 2009 में वापस मौजूद नहीं था। यदि आपके पास अजगर 2.7 है, तो आपको इसके बजाय इसका उपयोग करना चाहिए, लेकिन कोड ठीक उसी तरह काम करता है जैसा वह है।
nosklo

मैं 2.7 में वापस इस विधि के अस्तित्व के बारे में पता नहीं था- मैंने अभी जाँच की है कि एक टाइमडेल्टा ऑब्जेक्ट मूल रूप से दिनों और सेकंड की संख्या से बना है, इसलिए आप सही हैं। :-)
एमिलर

@emyller: बस पूर्णता के लिए, टाइमडेल्टा ऑब्जेक्ट दिनों, सेकंड और माइक्रोसेकंड से बना है । रैंडम डेट जनरेटिंग कोड की शुद्धता कुछ सेकंड्स तक होती है, लेकिन इसे बदला जा सकता है, जैसा कि मैंने उत्तर में बताया है।
nosklo

83

एक छोटा संस्करण।

import datetime
import random


def random_date(start, end):
    """Generate a random datetime between `start` and `end`"""
    return start + datetime.timedelta(
        # Get a random amount of seconds between `start` and `end`
        seconds=random.randint(0, int((end - start).total_seconds())),
    )

ध्यान दें कि दोनों startऔर endतर्क datetimeवस्तुओं होना चाहिए । यदि आपको इसके बजाय तार मिले हैं, तो इसे रूपांतरित करना काफी आसान है। अन्य उत्तर कुछ तरीकों की ओर इशारा करते हैं।


54

अद्यतन उत्तर

यह Faker का उपयोग करके और भी सरल है ।

स्थापना

pip install faker

उपयोग:

from faker import Faker
fake = Faker()

fake.date_between(start_date='today', end_date='+30y')
# datetime.date(2025, 3, 12)

fake.date_time_between(start_date='-30y', end_date='now')
# datetime.datetime(2007, 2, 28, 11, 28, 16)

# Or if you need a more specific date boundaries, provide the start 
# and end dates explicitly.
import datetime
start_date = datetime.date(year=2015, month=1, day=1)
fake.date_between(start_date=start_date, end_date='+30y')

पुराना उत्तर

यह रडार का उपयोग करके बहुत सरल है

स्थापना

pip install radar

प्रयोग

import datetime

import radar 

# Generate random datetime (parsing dates from str values)
radar.random_datetime(start='2000-05-24', stop='2013-05-24T23:59:59')

# Generate random datetime from datetime.datetime values
radar.random_datetime(
    start = datetime.datetime(year=2000, month=5, day=24),
    stop = datetime.datetime(year=2013, month=5, day=24)
)

# Just render some random datetime. If no range is given, start defaults to 
# 1970-01-01 and stop defaults to datetime.datetime.now()
radar.random_datetime()

3
faker मॉड्यूल के सुझाव के लिए upvote .. मैं प्रोफ़ाइल बनाने के लिए उपयोग कर रहा था, लेकिन उपयोग की गई तारीख का उपयोग नहीं किया गया था परीक्षण के दौरान faker बहुत अच्छा मॉड्यूल है।
Gahan

मुझे इस प्रारूप में आउटपुट मिल datetime.date(2039, 3, 16)रहा है लेकिन मैं इस तरह से आउटपुट चाहता हूं 2039-03-16। उसको कैसे करे?
आयुष कुमार

क्या आपका मतलब है, आप एक स्ट्रिंग चाहते हैं? बहुत आसान (बस तदनुसार इसे प्रारूपित करें) fake.date_between(start_date='today', end_date='+30y').strftime('%Y-%m-%d'):।
आर्टूर बरसेघन

1
एक अविश्वसनीय पुस्तकालय का उपयोग करने के लिए अपवोट करें, भले ही आपको इसे स्थापित करना पड़े। यह अनिवार्य रूप से 4 लाइनों के लिए कार्यान्वयन की जटिलता को कम करता है।
ब्लेयरग 2323 25'18

1
@ KubiK888: ज़रूर, मेरे अपडेट का जवाब देखें। आपको बस स्पष्ट रूप से start_date प्रदान करना चाहिए।
Artur Barseghyan

24

यह एक अलग दृष्टिकोण है - इस तरह का काम ..

from random import randint
import datetime

date=datetime.date(randint(2005,2025), randint(1,12),randint(1,28))

बेहतर अप्रोच

startdate=datetime.date(YYYY,MM,DD)
date=startdate+datetime.timedelta(randint(1,365))

1
पहला दृष्टिकोण कभी भी 29, 30 या 31 तारीख को समाप्त होने वाली तारीख का चयन नहीं करेगा और आपका दूसरा दृष्टिकोण लीप वर्ष के लिए नहीं होगा, जब वर्ष 366 दिन होता है, अर्थात यदि startdate+ 1 वर्ष एक लीप वर्ष पर 31 दिसंबर से गुजरता है, तो कोड ने ठीक एक साल बाद उसी तारीख को कभी नहीं चुना। दोनों दृष्टिकोण केवल आपको एक आरंभ तिथि और भविष्य में कितने वर्ष निर्दिष्ट करते हैं, जबकि प्रश्न दो तिथियों को निर्दिष्ट करने के बारे में पूछ रहा था, और मेरी राय में यह एक अधिक उपयोगी एपीआई है।
बोरिस

15

चूंकि पायथन 3 timedeltaफ्लोट्स के साथ गुणा का समर्थन करता है, इसलिए अब आप यह कर सकते हैं:

import random
random_date = start + (end - start) * random.random()

यह दिया startऔर endप्रकार के हैं datetime.datetime। उदाहरण के लिए, अगले दिन के भीतर एक यादृच्छिक डेटाटाइम उत्पन्न करने के लिए:

import random
from datetime import datetime, timedelta

start = datetime.now()
end = start + timedelta(days=1)
random_date = start + (end - start) * random.random()

6

एक पांडा-आधारित समाधान में चिप लगाने के लिए मैं उपयोग करता हूं:

import pandas as pd
import numpy as np

def random_date(start, end, position=None):
    start, end = pd.Timestamp(start), pd.Timestamp(end)
    delta = (end - start).total_seconds()
    if position is None:
        offset = np.random.uniform(0., delta)
    else:
        offset = position * delta
    offset = pd.offsets.Second(offset)
    t = start + offset
    return t

मुझे यह पसंद है, क्योंकि अच्छा है pd.Timestamp विशेषताओं के है जो मुझे इस पर अलग-अलग सामान और प्रारूप फेंकने की अनुमति देते हैं। निम्नलिखित कुछ उदाहरणों पर विचार करें ...

आपके हस्ताक्षर।

>>> random_date(start="1/1/2008 1:30 PM", end="1/1/2009 4:50 AM", position=0.34)
Timestamp('2008-05-04 21:06:48', tz=None)

यादृच्छिक स्थिति।

>>> random_date(start="1/1/2008 1:30 PM", end="1/1/2009 4:50 AM")
Timestamp('2008-10-21 05:30:10', tz=None)

अलग प्रारूप।

>>> random_date('2008-01-01 13:30', '2009-01-01 4:50')
Timestamp('2008-11-18 17:20:19', tz=None)

पंडों / डेटाइम वस्तुओं को सीधे पास करना।

>>> random_date(pd.datetime.now(), pd.datetime.now() + pd.offsets.Hour(3))
Timestamp('2014-03-06 14:51:16.035965', tz=None)

और आप एक यादृच्छिक डेटाटाइम श्रृंखला को सुरुचिपूर्ण ढंग से कैसे बनाएंगे (यानी, प्रत्येक तत्व के लिए अपने फ़ंक्शन को पुन: प्रसारित किए बिना)?
dmvianna

खैर, deltaमानों की एक सरणी उत्पन्न करने के लिए फ़ंक्शन को संशोधित करना और टाइमस्टैम्प पर उन सभी को एक बार में मैप करना संभव है। हालांकि, व्यक्तिगत रूप से, मैं सिर्फ कुछ करना पसंद करूंगा pd.Series([5] * 10, [random_date('2014-01-01', '2014-01-30') for i in range(10)])
मेटाकार्टिट

3

इस प्रश्न के मुख्य भाग के बजाय शीर्षक के शाब्दिक अर्थ का उत्तर इस प्रकार है:

import time
import datetime
import random

def date_to_timestamp(d) :
  return int(time.mktime(d.timetuple()))

def randomDate(start, end):
  """Get a random date between two dates"""

  stime = date_to_timestamp(start)
  etime = date_to_timestamp(end)

  ptime = stime + random.random() * (etime - stime)

  return datetime.date.fromtimestamp(ptime)

यह कोड स्वीकृत उत्तर पर शिथिल आधारित है।


आप दूसरी अंतिम पंक्ति को बदल सकते हैं, ptime = random.randint(stime, etime)क्योंकि यह randintएक समावेशी श्रेणी का उत्पादन करता है।
बोरिस

3

आप उपयोग कर सकते हैं Mixer,

pip install mixer

तथा,

from mixer import generators as gen
print gen.get_datetime(min_datetime=(1900, 1, 1, 0, 0, 0), max_datetime=(2020, 12, 31, 23, 59, 59))

1
वाक्यविन्यास थोड़ा बदल गया है, यह सुनिश्चित नहीं है कि ऊपर कैसे करना है, लेकिन एक django ऑब्जेक्ट में एक यादृच्छिक तारीख भरी जाएगी जैसे:client = mixer.blend(Client, date=mixer.RANDOM)
tutuDajuju

@tutuDajuju: क्लाइंट किसके लिए खड़ा है?
निमा सोरोश

उनके डॉक्स के अनुसार , यह एक Django, SQLAlchemy या Mongoengine मॉडल वर्ग हो सकता है।
टुटुअज्जु

2
#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""Create random datetime object."""

from datetime import datetime
import random


def create_random_datetime(from_date, to_date, rand_type='uniform'):
    """
    Create random date within timeframe.

    Parameters
    ----------
    from_date : datetime object
    to_date : datetime object
    rand_type : {'uniform'}

    Examples
    --------
    >>> random.seed(28041990)
    >>> create_random_datetime(datetime(1990, 4, 28), datetime(2000, 12, 31))
    datetime.datetime(1998, 12, 13, 23, 38, 0, 121628)
    >>> create_random_datetime(datetime(1990, 4, 28), datetime(2000, 12, 31))
    datetime.datetime(2000, 3, 19, 19, 24, 31, 193940)
    """
    delta = to_date - from_date
    if rand_type == 'uniform':
        rand = random.random()
    else:
        raise NotImplementedError('Unknown random mode \'{}\''
                                  .format(rand_type))
    return from_date + rand * delta


if __name__ == '__main__':
    import doctest
    doctest.testmod()

2

अपनी तिथियों को टाइमस्टैम्प में परिवर्तित करें और टाइमस्टैम्प के random.randintसाथ कॉल करें , फिर बेतरतीब ढंग से उत्पन्न टाइमस्टैम्प को एक तिथि में परिवर्तित करें:

from datetime import datetime
import random

def random_date(first_date, second_date):
    first_timestamp = int(first_date.timestamp())
    second_timestamp = int(second_date.timestamp())
    random_timestamp = random.randint(first_timestamp, second_timestamp)
    return datetime.fromtimestamp(random_timestamp)

फिर आप इसे इस तरह से उपयोग कर सकते हैं

from datetime import datetime

d1 = datetime.strptime("1/1/2018 1:30 PM", "%m/%d/%Y %I:%M %p")
d2 = datetime.strptime("1/1/2019 4:50 AM", "%m/%d/%Y %I:%M %p")

random_date(d1, d2)

random_date(d2, d1)  # ValueError because the first date comes after the second date

यदि आप टाइमज़ोन के बारे में परवाह करते हैं, तो आपको लाइब्रेरी date_time_between_datesसे उपयोग करना चाहिए Faker, जहां मैं इस कोड को चुरा लेता हूं , जैसा कि पहले से ही एक अलग उत्तर बताता है।


1
  1. अपनी इनपुट तिथियों को संख्याओं में बदलें (int, float, जो आपके उपयोग के लिए सबसे अच्छा है)
  2. अपनी दो तारीखों के बीच की संख्या चुनें।
  3. इस नंबर को वापस तिथि में परिवर्तित करें।

कई ऑपरेटिंग सिस्टमों में पहले से और बाद के दिनों को परिवर्तित करने के लिए कई एल्गोरिदम उपलब्ध हैं।


1

क्या आप के लिए यादृच्छिक संख्या की आवश्यकता है? आमतौर पर (भाषा के आधार पर) आप एक तारीख से एपोच से सेकंड / मिली सेकंड की संख्या प्राप्त कर सकते हैं। तो शुरू और अंत के बीच एक यादृच्छिक तारीख के लिए आप कर सकते हैं:

  1. एमएस में प्रारंभ और अंत के बीच के समय की गणना करें
  2. 0 और आपके द्वारा 1 में प्राप्त संख्या के बीच एक संख्या उत्पन्न करें
  3. समय ऑफसेट = startDate.toMilliseconds () + 2 में प्राप्त संख्या के साथ एक नई तारीख उत्पन्न करें

1

ऐसा करने का सबसे आसान तरीका दोनों संख्याओं को टाइमस्टैम्प में बदलना है, फिर इन्हें एक यादृच्छिक संख्या जनरेटर पर न्यूनतम और अधिकतम सीमा के रूप में सेट करें।

एक त्वरित PHP उदाहरण होगा:

// Find a randomDate between $start_date and $end_date
function randomDate($start_date, $end_date)
{
    // Convert to timetamps
    $min = strtotime($start_date);
    $max = strtotime($end_date);

    // Generate random number using above bounds
    $val = rand($min, $max);

    // Convert back to desired date format
    return date('Y-m-d H:i:s', $val);
}

यह फ़ंक्शन strtotime()एक डाइमटाइम विवरण को यूनिक्स टाइमस्टैम्प में परिवर्तित करने के लिए, और date()उत्पन्न होने वाले रैंडम टाइमस्टैम्प से वैध तिथि बनाने के लिए उपयोग करता है।


अगर कोई उस अजगर में लिख सकता है जो मददगार होगा।
quilby

1

बस एक और जोड़ने के लिए:

datestring = datetime.datetime.strftime(datetime.datetime( \
    random.randint(2000, 2015), \
    random.randint(1, 12), \
    random.randint(1, 28), \
    random.randrange(23), \
    random.randrange(59), \
    random.randrange(59), \
    random.randrange(1000000)), '%Y-%m-%d %H:%M:%S')

दिन संभालने के लिए कुछ विचारों की जरूरत होती है। 28 के साथ आप सुरक्षित साइट पर हैं।


1

यहां एमिलर के दृष्टिकोण से संशोधित समाधान है जो किसी भी रिज़ॉल्यूशन पर यादृच्छिक तिथियों की एक सरणी देता है

import numpy as np

def random_dates(start, end, size=1, resolution='s'):
    """
    Returns an array of random dates in the interval [start, end]. Valid 
    resolution arguments are numpy date/time units, as documented at: 
        https://docs.scipy.org/doc/numpy-dev/reference/arrays.datetime.html
    """
    start, end = np.datetime64(start), np.datetime64(end)
    delta = (end-start).astype('timedelta64[{}]'.format(resolution))
    delta_mat = np.random.randint(0, delta.astype('int'), size)
    return start + delta_mat.astype('timedelta64[{}]'.format(resolution))

इस दृष्टिकोण के बारे में जो अच्छा है, वह np.datetime64यह है कि तारीखों के लिए जबरदस्ती करना बहुत अच्छा है, इसलिए आप अपनी शुरुआत / समाप्ति तिथियों को तार, डेटाटाइम्स, पांडा टाइमस्टैम्प के रूप में निर्दिष्ट कर सकते हैं ... बहुत कुछ भी काम करेगा।


0

वैचारिक रूप से यह काफी सरल है। इस बात पर निर्भर करता है कि आप किस भाषा का उपयोग कर रहे हैं, उन तिथियों को कुछ संदर्भ 32 या 64 बिट पूर्णांक में परिवर्तित करने में सक्षम होंगे, आमतौर पर युगों के बाद से सेकंड का प्रतिनिधित्व करते हैं (1 जनवरी 1970) अन्यथा "अनिक्स समय" या मिलीसेकंड के रूप में जाना जाता है जब से कुछ अन्य मनमाना तारीख। बस उन दो मूल्यों के बीच एक यादृच्छिक 32 या 64 बिट पूर्णांक उत्पन्न करते हैं। यह किसी भी भाषा में एक लाइनर होना चाहिए।

कुछ प्लेटफार्मों पर आप एक समय को डबल के रूप में उत्पन्न कर सकते हैं (तिथि पूर्णांक भाग है, समय आंशिक भाग एक कार्यान्वयन है)। एक ही सिद्धांत लागू होता है सिवाय इसके कि आप सिंगल या डबल प्रिसिजन फ़्लोटिंग पॉइंट नंबरों ("फ्लोट्स" या "डबल्स" को सी, जावा और अन्य भाषाओं में) के साथ डील कर रहे हैं। अंतर घटाएं, यादृच्छिक संख्या से गुणा करें (0 <= r <= 1), समय शुरू करने के लिए जोड़ें और किया।


0

अजगर में:

>>> from dateutil.rrule import rrule, DAILY
>>> import datetime, random
>>> random.choice(
                 list(
                     rrule(DAILY, 
                           dtstart=datetime.date(2009,8,21), 
                           until=datetime.date(2010,10,12))
                     )
                 )
datetime.datetime(2010, 2, 1, 0, 0)

(अजगर dateutilपुस्तकालय की जरूरत है - pip install python-dateutil)


0

ApacheCommonUtils का उपयोग किसी दी गई सीमा के भीतर यादृच्छिक रूप से उत्पन्न करने के लिए करें, और फिर उस लंबी तिथि का निर्माण करें।

उदाहरण:

आयात org.apache.commons.math.random.RandomData;

आयात org.apache.commons.math.random.RandomDataImpl;

सार्वजनिक दिनांक अगली तिथि (दिनांक मिनट, तिथि अधिकतम) {

RandomData randomData = new RandomDataImpl();

return new Date(randomData.nextLong(min.getTime(), max.getTime()));

}


1
प्रश्न को "अजगर" टैग किया गया है
डेविड मार्क्स

0

मैंने इसे यादृच्छिक और समय का उपयोग करते हुए एक अन्य परियोजना के लिए बनाया। मैं तुम्हें प्रलेखन देख सकते हैं समय से एक सामान्य प्रारूप का प्रयोग किया यहाँ strftime में पहला तर्क के लिए ()। दूसरा भाग एक random.randrange फंक्शन है। यह तर्कों के बीच एक पूर्णांक देता है। इसे उन सीमाओं में बदलें, जो आपके द्वारा पसंद किए जाने वाले तार से मेल खाती हैं। दूसरे तर्क के तुक में आपके पास अच्छे तर्क होने चाहिए।

import time
import random


def get_random_date():
    return strftime("%Y-%m-%d %H:%M:%S",(random.randrange(2000,2016),random.randrange(1,12),
    random.randrange(1,28),random.randrange(1,24),random.randrange(1,60),random.randrange(1,60),random.randrange(1,7),random.randrange(0,366),1))

0

पंडों + सुन्न समाधान

import pandas as pd
import numpy as np

def RandomTimestamp(start, end):
    dts = (end - start).total_seconds()
    return start + pd.Timedelta(np.random.uniform(0, dts), 's')

dts सेकंड (फ्लोट) में टाइमस्टैम्प के बीच का अंतर है। इसके बाद 0 और dts के बीच एक पांडा टाइमडेल्टा बनाने के लिए उपयोग किया जाता है, जो कि स्टार्ट टाइमस्टैम्प में जोड़ा जाता है।


0

माउविसील द्वारा उत्तर के आधार पर, यहां एक सदिश समाधान का उपयोग किया गया है। प्रारंभ और समाप्ति तिथियों को किलों में परिवर्तित करें, उनके बीच यादृच्छिक संख्याओं की एक सरणी उत्पन्न करें, और पूरे सरणी को तारीखों में परिवर्तित करें।

import time
import datetime
import numpy as np

n_rows = 10

start_time = "01/12/2011"
end_time = "05/08/2017"

date2int = lambda s: time.mktime(datetime.datetime.strptime(s,"%d/%m/%Y").timetuple())
int2date = lambda s: datetime.datetime.fromtimestamp(s).strftime('%Y-%m-%d %H:%M:%S')

start_time = date2int(start_time)
end_time = date2int(end_time)

random_ints = np.random.randint(low=start_time, high=end_time, size=(n_rows,1))
random_dates = np.apply_along_axis(int2date, 1, random_ints).reshape(n_rows,1)

print random_dates

0

यह @ (टॉम अल्सबर्ग) की संशोधित विधि है। मैंने इसे मिलीसेकंड के साथ तारीख करने के लिए संशोधित किया।

import random
import time
import datetime

def random_date(start_time_string, end_time_string, format_string, random_number):
    """
    Get a time at a proportion of a range of two formatted times.
    start and end should be strings specifying times formated in the
    given format (strftime-style), giving an interval [start, end].
    prop specifies how a proportion of the interval to be taken after
    start.  The returned time will be in the specified format.
    """
    dt_start = datetime.datetime.strptime(start_time_string, format_string)
    dt_end = datetime.datetime.strptime(end_time_string, format_string)

    start_time = time.mktime(dt_start.timetuple()) + dt_start.microsecond / 1000000.0
    end_time = time.mktime(dt_end.timetuple()) + dt_end.microsecond / 1000000.0

    random_time = start_time + random_number * (end_time - start_time)

    return datetime.datetime.fromtimestamp(random_time).strftime(format_string)

उदाहरण:

print TestData.TestData.random_date("2000/01/01 00:00:00.000000", "2049/12/31 23:59:59.999999", '%Y/%m/%d %H:%M:%S.%f', random.random())

आउटपुट: 2028/07/08 12:34:49.977963


0
start_timestamp = time.mktime(time.strptime('Jun 1 2010  01:33:00', '%b %d %Y %I:%M:%S'))
end_timestamp = time.mktime(time.strptime('Jun 1 2017  12:33:00', '%b %d %Y %I:%M:%S'))
time.strftime('%b %d %Y %I:%M:%S',time.localtime(randrange(start_timestamp,end_timestamp)))

उल्लेख


0
    # needed to create data for 1000 fictitious employees for testing code 
    # code relating to randomly assigning forenames, surnames, and genders
    # has been removed as not germaine to the question asked above but FYI
    # genders were randomly assigned, forenames/surnames were web scrapped,
    # there is no accounting for leap years, and the data stored in mySQL

    import random 
    from datetime import datetime
    from datetime import timedelta

    for employee in range(1000):
        # assign a random date of birth (employees are aged between sixteen and sixty five)
        dlt = random.randint(365*16, 365*65)
        dob = datetime.today() - timedelta(days=dlt)
        # assign a random date of hire sometime between sixteenth birthday and yesterday
        doh = datetime.today() - timedelta(days=random.randint(1, dlt-365*16))
        print("born {} hired {}".format(dob.strftime("%d-%m-%y"), doh.strftime("%d-%m-%y")))

0

वैकल्पिक रास्ते का उपयोग कर दो तिथियों के बीच यादृच्छिक दिनांकों बनाने के लिए np.random.randint(), pd.Timestamp().valueऔर pd.to_datetime()साथ for loop:

# Import libraries
import pandas as pd

# Initialize
start = '2020-01-01' # Specify start date
end = '2020-03-10' # Specify end date
n = 10 # Specify number of dates needed

# Get random dates
x = np.random.randint(pd.Timestamp(start).value, pd.Timestamp(end).value,n)
random_dates = [pd.to_datetime((i/10**9)/(60*60)/24, unit='D').strftime('%Y-%m-%d')  for i in x]

print(random_dates)

उत्पादन

['2020-01-06',
 '2020-03-08',
 '2020-01-23',
 '2020-02-03',
 '2020-01-30',
 '2020-01-05',
 '2020-02-16',
 '2020-03-08',
 '2020-02-09',
 '2020-01-04']
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.