【问题标题】：Generate a random date between two other dates在其他两个日期之间生成一个随机日期
【发布时间】：2010-10-07 21:17:33
【问题描述】：

如何生成一个必须在另外两个给定日期之间的随机日期？

函数的签名应该是这样的：

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
是的，可能问题是关于插值的，发现它的每个人都想要一个随机日期:)

标签： python datetime random

【解决方案1】：

将两个字符串都转换为时间戳（以您选择的分辨率，例如毫秒、秒、小时、天等等），从后面减去前面的，然后乘以您的随机数（假设它分布在 range [0, 1] 中）差异，并再次添加到前面的那个。将时间戳转换回日期字符串，并且您在该范围内有一个随机时间。

Python 示例（输出几乎是您指定的格式，除了 0 填充 - 归咎于美国时间格式约定）：

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

    start and end should be strings specifying times formatted 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, time_format))
    etime = time.mktime(time.strptime(end, time_format))

    ptime = stime + prop * (etime - stime)

    return time.strftime(time_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()))

【讨论】：

这不支持 1900 年之前的日期。

【解决方案2】：

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

【讨论】：

在这种情况下使用start 变量是完全正确的。我在代码中看到的唯一问题是使用生成的delta 中的seconds 属性。这不会返回整个间隔中的总秒数；相反，它只是“时间”组件的秒数（介于 0 到 60 之间）； timedelta 对象有一个 total_seconds 方法，应该使用它。
@emyller：不，我使用的是(delta.days * 24 * 60 * 60) + delta.seconds，这会导致总秒数。 total_seconds() 方法是 python 2.7 中的新方法，并且在我回答问题时在 2009 年不存在。如果你有 python 2.7，你应该使用它，但代码可以正常工作。
我不知道在 2.7- 中不存在这种方法。我刚刚检查了 timedelta 对象基本上由天数和秒数组成，所以你是对的。 :-)
@emyller：为了完整起见，timedelta 对象由天、秒和微秒组成。上面随机日期生成代码的精度高达秒，但可以更改，正如我在答案中提到的那样。

【解决方案3】：

一个小版本。

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 对象。如果你有字符串，它很容易转换。其他答案点有一些方法可以做到这一点。

【讨论】：

【解决方案4】：

更新答案

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

【讨论】：

赞成建议 faker 模块。我用来生成配置文件但没有使用日期实用程序 faker 在测试时是一个非常好的模块。
我得到这种格式的输出datetime.date(2039, 3, 16) 但我想要这样的输出2039-03-16。该怎么做？
你的意思是，你想要一个字符串？非常简单（只需相应地格式化）：fake.date_between(start_date='today', end_date='+30y').strftime('%Y-%m-%d').
支持使用令人难以置信的库，即使您必须安装它。这将实现的复杂性降低到基本上 4 行。
@KubiK888：当然，请参阅我的更新答案。您应该简单地明确提供 start_date。

【解决方案5】：

这是一种不同的方法 - 那种工作..

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

【讨论】：

第一种方法永远不会选择以 29、30 或 31 结束的日期，而第二种方法不考虑闰年，当年份为 366 天时，即如果 startdate + 1年份在闰年经过 12 月 31 日，此代码将永远不会在一年后选择相同的日期。这两种方法都只允许您指定开始日期和未来多少年，而问题是关于指定两个日期，我认为这是一个更有用的 API。

【解决方案6】：

由于 Python 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()

【讨论】：

【解决方案7】：

加入我使用的基于 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)

【讨论】：

你将如何优雅地创建一个随机的日期时间系列（即，不为每个元素迭代你的函数）？
好吧，也许可以修改函数以生成delta 值的数组并将它们一次全部映射到时间戳。不过，就我个人而言，我更喜欢像pd.Series([5] * 10, [random_date('2014-01-01', '2014-01-30') for i in range(10)]) 这样的事情。

【解决方案8】：

将您的日期转换为时间戳并使用时间戳调用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 库的date_time_between_dates，where I stole this code from，正如另一个答案所暗示的那样。

【讨论】：

【解决方案9】：

这里是标题字面意思的答案，而不是这个问题的正文：

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 会产生一个包含范围。

【解决方案10】：

您可以使用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))

【讨论】：

语法发生了一些变化，不知道上面的怎么做，但是一个 django 对象会像这样填充一个随机日期：client = mixer.blend(Client, date=mixer.RANDOM)
@tutuDajuju : 客户代表什么？
根据their docs，可以是Django、SQLAlchemy或Mongoengine模型类。

【解决方案11】：

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

【讨论】：

【解决方案12】：

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

【讨论】：

简单，不需要去时间戳和返回。如果您确切想要date 而不是datetime，这将非常有用。

【解决方案13】：

将输入日期转换为数字（int，float，任何最适合的您的使用情况）
在两个日期数字之间选择一个数字。
将此数字转换回日期。

许多操作系统中已经提供了许多用于将日期转换为数字和从数字转换为数字的算法。

【讨论】：

【解决方案14】：

你需要随机数做什么？通常（取决于语言）您可以从日期中获取 Epoch 的秒数/毫秒数。因此，对于 startDate 和 endDate 之间的随机日期，您可以这样做：

以毫秒为单位计算时间开始日期和结束日期 (endDate.toMilliseconds() - startDate.toMilliseconds())
生成一个介于 0 和您在 1 中获得的数字之间的数字
生成一个新的日期，时间偏移 = startDate.toMilliseconds() + 2 中获得的数字

【讨论】：

【解决方案15】：

执行此操作的最简单方法是将两个数字都转换为时间戳，然后将它们设置为随机数生成器的最小和最大界限。

一个简单的 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);
}

该函数利用@987654321@将日期时间描述转换为Unix时间戳，并利用@987654322@将生成的随机时间戳变成有效日期。

【讨论】：

如果有人能用 python 写那将是有帮助的。

【解决方案16】：

只是添加另一个：

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，您就在安全的网站上。

【讨论】：

【解决方案17】：

它是@(Tom Alsberg) 的修改方法。我修改它以获取毫秒的日期。

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

【讨论】：

【解决方案18】：

这是一个从 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 时间戳......几乎任何事情都可以。

【讨论】：

【解决方案19】：

使用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']

【讨论】：

【解决方案20】：

从概念上讲，这很简单。根据您使用的语言，您将能够将这些日期转换为一些参考 32 位或 64 位整数，通常表示自纪元（1970 年 1 月 1 日）以来的秒数，也称为“Unix 时间”或自其他任意日期以来的毫秒数。只需在这两个值之间生成一个随机的 32 或 64 位整数。这应该是任何语言的单行。

在某些平台上，您可以将时间生成为双精度（日期是整数部分，时间是小数部分是一种实现方式）。除了处理单精度或双精度浮点数（C、Java 和其他语言中的“浮点数”或“双精度数”）外，同样的原则适用。减去差，乘以随机数（0

【讨论】：

【解决方案21】：

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

（需要pythondateutil库-pip install python-dateutil）

【讨论】：

【解决方案22】：

使用 ApacheCommonUtils 在给定范围内生成随机长整数，然后用那么长的时间创建日期。

例子：

导入 org.apache.commons.math.random.RandomData;

导入 org.apache.commons.math.random.RandomDataImpl;

public Date nextDate(Date min, Date max) {

RandomData randomData = new RandomDataImpl();

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

}

【讨论】：

问题被标记为“python”

【解决方案23】：

我使用随机和时间为另一个项目制作了这个。我使用了一种通用格式，您可以查看文档here 以获取 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))

【讨论】：

【解决方案24】：

Pandas + numpy 解决方案

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 之间的 pandas timedelta，并将其添加到开始时间戳。

【讨论】：

【解决方案25】：

根据 mouviciel 的回答，这里是一个使用 numpy 的矢量化解决方案。将开始日期和结束日期转换为整数，在它们之间生成一个随机数数组，并将整个数组转换回日期。

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

【讨论】：

【解决方案26】：

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

refer

【讨论】：

【解决方案27】：

获取 start_date 和 end_date 之间的随机日期。如果其中任何一个为无，则获取之间的随机日期今天和过去 100 年。

class GetRandomDateMixin:
    def get_random_date(self, start_date=None, end_date=None):
        """
        get random date between start_date and end_date.
        If any of them is None, then get random date between
        today and past 100 years.
        :param start_date: datetime obj.
            eg: datetime.datetime(1940, 1, 1).date()
        :param end_date: datetime obj
        :return: random date
        """
        if start_date is None or end_date is None:

            end_date = datetime.datetime.today().date()
            start_date = end_date - datetime.timedelta(
                days=(100 * 365)
            )

        delta = end_date - start_date
        random_days = random.randint(1, delta.days)
        new_date = start_date + datetime.timedelta(
            days=random_days
        )

        return new_date

【讨论】：

【解决方案28】：

以@Pieter Bos 的回答为基础：

import random
import datetime

start = datetime.date(1980, 1, 1)
end = datetime.date(2000, 1, 1)

random_date = start + (end - start) * random.random()
random_date = datetime.datetime.combine(random_date, datetime.datetime.min.time())

【讨论】：

【解决方案29】：

怎么样

import datetime
import random


def random_date(begin: datetime.datetime, end: datetime.datetime):
    epoch = datetime.datetime(1970, 1, 1)
    begin_seconds = int((begin - epoch).total_seconds())
    end_seconds = int((end - epoch).total_seconds())
    dt_seconds = random.randint(begin_seconds, end_seconds)

    return datetime.datetime.fromtimestamp(dt_seconds)

没有尝试过与 1970 年不同的“纪元”年份，但它可以完成工作

【讨论】：

【解决方案30】：

使用我的randomtimestamp 模块。它有 3 个函数，randomtimestamp、random_time 和 random_date。

下面是randomtimestamp函数的签名。它可以生成两年之间的随机时间戳，或者两个日期时间对象（如果你喜欢精确的话）。

可以选择将时间戳作为日期时间对象或字符串。还支持自定义模式（如 strftime）

randomtimestamp(
    start_year: int = 1950,
    end_year: int = None,
    text: bool = False,
    start: datetime.datetime = None,
    end: datetime.datetime = None,
    pattern: str = "%d-%m-%Y %H:%M:%S"
  ) -> Union[datetime, str]:

示例：

>>> randomtimestamp(start_year=2020, end_year=2021)
datetime.datetime(2021, 1, 10, 5, 6, 19)

>>> start = datetime.datetime(2020, 1, 1, 0, 0, 0)
>>> end = datetime.datetime(2021, 12, 31, 0, 0, 0)

>>> randomtimestamp(start=start, end=end)
datetime.datetime(2020, 7, 14, 14, 12, 32)

为什么不做假？

因为 randomtimestamp 轻量且快速。只要随机时间戳是您唯一需要的东西，faker 就是一种矫枉过正而且很重（功能丰富）。

【讨论】：

请查看self-promotion 上的规则。您必须声明与您在回答中推广的任何包的关联。