Как бы я сгенерировал случайную дату, которая должна быть между двумя другими данными датами?
Подпись функции должна выглядеть примерно так:
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
Преобразуйте обе строки во временные метки (в выбранном вами разрешении, например, в миллисекундах, секундах, часах, днях и т.д.), Вычтите предыдущее из более позднего, умножьте ваше случайное число (предполагая, что оно распределено в range [0, 1]) с этой разницей, и добавьте еще раз к предыдущему. Преобразуйте метку времени обратно в строку даты, и у вас будет случайное время в этом диапазоне.
Пример Python (вывод почти в указанном вами формате, кроме заполнения 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()))
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
Маленькая версия.
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 объектов. Если
у вас есть строки вместо этого, это довольно легко конвертировать. Другая точка ответа
для некоторых способов сделать это.
Это еще проще, используя 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()
Это другой подход - такие работы..
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))
Так как Python 3 timedelta поддерживает умножение с помощью float, теперь вы можете сделать:
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()
Для чипа в решении на основе pandas я использую:
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)
Передача непосредственно объектов pandas/datetime.
>>> random_date(pd.datetime.now(), pd.datetime.now() + pd.offsets.Hour(3))
Timestamp('2014-03-06 14:51:16.035965', tz=None)
Вот ответ на буквальное значение названия, а не на тело этого вопроса:
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)
Этот код основан на принятом ответе.
Вы можете использовать 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))
#!/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()
Многие алгоритмы преобразования даты и из числа уже доступны во многих операционных системах.
Для чего вам нужно случайное число? Обычно (в зависимости от языка) вы можете получить количество секунд/миллисекунд из Эпохи с даты. Итак, для случайной даты между startDate и endDate вы можете сделать:
Самый простой способ сделать это - преобразовать оба числа в метки времени, а затем установить их как минимальную и максимальную границы для генератора случайных чисел.
Быстрый пример 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() для преобразования описания даты и времени в временную метку Unix и date(), чтобы сделать допустимую дату из созданной случайной метки времени.
Просто добавьте еще один:
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 вы находитесь на защищенном сайте.
Здесь решение, модифицированное с помощью метода emyller, которое возвращает массив случайных дат при любом разрешении
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 действительно хорош в принуждении к датам, поэтому вы можете указать даты начала и окончания как строки, даты, временные метки pandas... почти все будет работать.
Концептуально это довольно просто. В зависимости от того, какой язык вы используете, вы сможете преобразовать эти даты в какое-либо ссылочное 32 или 64-битное целое число, обычно представляющее секунды с эпохи (1 января 1970 года), иначе называемые "Unix time" или миллисекунды с какой-либо другой произвольной даты. Просто создайте случайное 32 или 64-битное целое число между этими двумя значениями. Это должен быть один лайнер на любом языке.
На некоторых платформах вы можете сгенерировать время как двойное (дата - целочисленная часть, время - дробная часть - одна реализация). Тот же принцип применяется, за исключением того, что вы имеете дело с одиночными или двойными точками с плавающей запятой ( "плавает" или "удваивается" на языках C, Java и других языках). Вычтите разницу, умножьте на случайное число (0 <= r <= 1), добавьте к времени начала и закончите.
В python:
>>> 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 dateutil - pip install python-dateutil)
Используйте ApacheCommonUtils для генерации случайного длинного в пределах заданного диапазона, а затем создать дату из этого долгого времени.
Пример:
import org.apache.commons.math.random.RandomData;
import org.apache.commons.math.random.RandomDataImpl;
public Дата nextDate (Дата min, Date max) {
RandomData randomData = new RandomDataImpl();
return new Date(randomData.nextLong(min.getTime(), max.getTime()));
}
Я сделал это для другого проекта, используя случайные и временные. Я использовал общий формат со времени, когда вы можете просмотреть документацию здесь для первого аргумента в 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))
Pandas + numpy solution
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 - разница между метками времени в секундах (float). Затем он используется для создания pandas timedelta между 0 и dts, который добавляется к отметке времени начала.
Основываясь на ответе mouviciel, вот векторное решение с использованием numpy. Преобразуйте даты начала и конца в int, создайте массив случайных чисел между ними и преобразуйте весь массив в даты.
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
Он изменил метод @(Том Альсберг). Я изменил его, чтобы получить дату с миллисекундами.
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
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)))
Преобразуйте свои даты в временные метки и вызовите 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
Если вы заботитесь о часовых поясах, вам следует просто использовать библиотеку faker, где я украл этот код из, как уже предлагает другой ответ.