Diğer iki tarih arasında olması gereken rastgele bir tarihi nasıl oluştururum?

İşlevin imzası şu şekilde olmalıdır:

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

ve aşağıdaki gibi bir tarih döndürür: 2/4/2008 7:20 PM

Her iki dizeyi de zaman damgalarına dönüştürün (seçtiğiniz çözünürlükte, örneğin milisaniye, saniye, saat, gün, her neyse), öncekini daha sonradan çıkarın, rastgele sayınızı çarpın ( range [0, 1] ) bu farkla ve tekrar ekleyin. önceki. Zaman damgasını tarih dizesine geri dönüştürün ve bu aralıkta rastgele bir zamanınız var.

Python örneği (çıktı, 0doldurma dışında neredeyse belirttiğiniz biçimdedir - Amerikan saat biçimi kurallarını suçlayın):

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()))

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)

Hassasiyet saniyedir. Hassasiyeti mikrosaniyeye kadar artırabilir veya isterseniz yarım saate düşürebilirsiniz. Bunun için sadece son satırın hesaplamasını değiştirin.

örnek çalıştırma:

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))

çıktı:

2008-12-04 01:50:17

Küçük bir versiyon.

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())),
    )

Her iki unutmayın startve endargümanlar olmalıdır datetimenesneler. Bunun yerine dizeleriniz varsa, dönüştürmek oldukça kolaydır. Diğer cevaplar bunu yapmanın bazı yollarına işaret ediyor.

Güncel cevap

Faker'i kullanmak daha da kolay .

Kurulum

pip install faker

Kullanımı:

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')

Eski cevap

Radar kullanmak çok basit

Kurulum

pip install radar

kullanım

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()

Bu farklı bir yaklaşım - bu tür işler ..

from random import randint
import datetime

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

DAHA İYİ YAKLAŞIM

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

Python 3 timedeltaşamandıralarla çarpmayı desteklediğinden, artık şunları yapabilirsiniz:

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

verilen startve endtürü vardır datetime.datetime. Örneğin, ertesi gün içinde rastgele bir tarih saati oluşturmak için:

import random
from datetime import datetime, timedelta

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

Panda tabanlı bir çözümü çiplemek için kullanıyorum:

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

Hoşuma gitti, hoşuma gitti pd.TimestampFarklı şeyler ve formatlar atmamı sağlayan özellikler . Aşağıdaki birkaç örneği ele alalım ...

İmzan.

>>> 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)

Rastgele konum.

>>> 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)

Farklı format.

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

Panda / datetime nesnelerini doğrudan iletme.

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

İşte bu sorunun gövdesinden ziyade başlığın gerçek anlamına bir cevap:

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)

Bu kod gevşek bir şekilde kabul edilen cevaba dayanmaktadır.

Kullanabilirsiniz Mixer,

pip install mixer

ve,

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))

#!/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()

Tarihlerinizi zaman damgalarına dönüştürün ve zaman damgalarıyla çağırın random.randint, ardından rastgele oluşturulan zaman damgasını tekrar tarihe dönüştürün:

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)

O zaman böyle kullanabilirsiniz

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

Eğer saat dilimleri önem veriyorsanız sadece kullanmalısınız date_time_between_datesgelen Fakerkütüphane, ben bu kodu çalan farklı bir cevap zaten anlaşılacağı gibi,.

1. Giriş tarihlerinizi sayılara dönüştürün (int, float, kullanımınız için en uygun olanı)
2. İki tarih numaranız arasından bir sayı seçin.
3. Bu sayıyı bir tarihe dönüştürün.

Sayıları ve sayıları dönüştürmek için birçok algoritma birçok işletim sisteminde zaten mevcuttur.

Rastgele sayı için neye ihtiyacınız var? Genellikle (dile bağlı olarak) Dönemden saniye / milisaniye sayısını bir tarihten alabilirsiniz. Yani startDate ve endDate arasındaki rastgele bir tarih için şunları yapabilirsiniz:

1. startDate ve endDate (endDate.toMilliseconds () - startDate.toMilliseconds ()) arasındaki ms cinsinden zamanı hesaplayın
2. 0 ile 1 arasında elde ettiğiniz sayı arasında bir sayı oluşturun
3. time offset = startDate.toMilliseconds () + 2 ile elde edilen sayı ile yeni bir Tarih oluşturma

Bunu yapmanın en kolay yolu, her iki sayıyı da zaman damgalarına dönüştürmek ve ardından bunları rastgele bir sayı üretecinde minimum ve maksimum sınırlar olarak ayarlamaktır.

Hızlı bir PHP örneği:

// 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);
}

Bu işlev, strtotime()datetime açıklamasını Unix zaman damgasına dönüştürmek ve date()oluşturulan rasgele zaman damgasından geçerli bir tarih oluşturmak için kullanır.

Başka bir tane daha eklemek için:

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')

Günlük kullanım bazı hususlara ihtiyaç duyar. 28 ile güvenli sitedesiniz.

İşte emyller yaklaşımından değiştirilen ve herhangi bir çözünürlükte rastgele tarih dizisi döndüren bir çözüm

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))

Bu yaklaşımla ilgili güzel olan şey np.datetime64, şeyleri tarihlere zorlamakta gerçekten iyi olmasıdır, bu nedenle başlangıç ​​/ bitiş tarihlerinizi dize, tarih, panda zaman damgası olarak belirtebilirsiniz ... hemen hemen her şey işe yarayacaktır.

Kavramsal olarak oldukça basit. Hangi dili kullandığınıza bağlı olarak, bu tarihleri ​​referans olarak 32 veya 64 bit tamsayıya dönüştürebilirsiniz. Bu iki değer arasında rastgele bir 32 veya 64 bit tam sayı oluşturun. Bu, herhangi bir dilde tek bir astar olmalıdır.

Bazı platformlarda çift olarak zaman oluşturabilirsiniz (tarih tamsayı kısmıdır, zaman kesirli kısmı bir uygulamadır). Aynı ilke, tek veya çift kesinlikli kayar nokta sayılarıyla (C, Java ve diğer dillerde "çift" veya "çift") ilgilenmemeniz dışında da geçerlidir. Farkı çıkarın, rastgele sayıyla çarpın (0 <= r <= 1), başlangıç ​​zamanına ekleyin ve bitti.

Python'da:

>>> 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)

(python dateutilkitaplığına ihtiyacınız var - pip install python-dateutil)

Belirli bir aralık içinde rastgele bir uzun oluşturmak için ApacheCommonUtils kullanın ve sonra o uzun dışında Tarih oluşturun.

Misal:

import org.apache.commons.math.random.RandomData;

import org.apache.commons.math.random.RandomDataImpl;

herkese açık Tarih nextDate (Tarih min, Tarih maksimum) {

RandomData randomData = new RandomDataImpl();

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

}

Bunu rastgele ve zaman kullanarak başka bir proje için yaptım. Ben strftime () ilk argüman için burada belgeleri görebilirsiniz zaman genel bir biçim kullandım . İkinci bölüm rastgele bir rasgele işlevdir. Bağımsız değişkenler arasında bir tamsayı döndürür. İstediğiniz dizelerle eşleşen aralıklara değiştirin. İkinci argümanın demetinde hoş tartışmalar olmalı.

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))

Pandalar + numpy çözümü

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 saniye cinsinden zaman damgaları arasındaki farktır (float). Daha sonra başlangıç ​​zaman damgasına eklenen 0 ile dts arasında bir pandalar timedelta oluşturmak için kullanılır.

Mouviciel'in cevabına dayanarak, burada numpy kullanarak vektörleştirilmiş bir çözüm var. Başlangıç ​​ve bitiş tarihlerini ints'e dönüştürün, aralarında rasgele sayılar dizisi oluşturun ve dizinin tamamını tarihlere dönüştürün.

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

@ (Tom Alsberg) 'in modifiye edilmiş yöntemi. Milisaniye ile tarih almak için değiştirdim.

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)

Misal:

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())

Çıktı: 2028/07/08 12:34:49.977963

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)))

başvurmak

    # 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")))

Alternatif bir yol kullanarak iki tarih arasındaki rasgele tarihleri oluşturmak için np.random.randint(), pd.Timestamp().valueve pd.to_datetime()ile 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)

Çıktı

['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']