Làm thế nào tôi có thể tạo một ngày ngẫu nhiên phải ở giữa hai ngày đã cho khác?

Chữ ký của hàm phải giống như thế này:

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

và sẽ trả lại một ngày như: 2/4/2008 7:20 PM

Chuyển đổi cả hai chuỗi thành dấu thời gian (ở độ phân giải bạn đã chọn, ví dụ: mili giây, giây, giờ, ngày, bất cứ thứ gì), trừ đi trước đó sau, nhân số ngẫu nhiên của bạn (giả sử nó được phân phối trong range [0, 1] ) với sự khác biệt đó và thêm lại vào cái trước Chuyển đổi dấu thời gian trở lại chuỗi ngày và bạn có thời gian ngẫu nhiên trong phạm vi đó.

Ví dụ về Python (đầu ra gần như ở định dạng bạn đã chỉ định, ngoài phần 0đệm - đổ lỗi cho các quy ước định dạng thời gian của Mỹ):

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)

Độ chính xác là giây. Bạn có thể tăng độ chính xác lên đến micro giây, hoặc giảm xuống, nói, nửa giờ, nếu bạn muốn. Cho rằng chỉ cần thay đổi tính toán của dòng cuối cùng.

chạy ví dụ:

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

đầu ra:

2008-12-04 01:50:17

Một phiên bản nhỏ.

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

Lưu ý rằng cả hai startvà endđối số nên là datetimeđối tượng. Nếu bạn có chuỗi thay thế, nó khá dễ dàng để chuyển đổi. Các câu trả lời khác chỉ ra một số cách để làm như vậy.

Cập nhật câu trả lời

Nó thậm chí còn đơn giản hơn khi sử dụng Faker .

Cài đặt

pip install faker

Sử dụng:

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

Câu trả lời cũ

Nó rất đơn giản sử dụng radar

Cài đặt

pip install radar

Sử dụng

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

Đây là một cách tiếp cận khác - loại công việc đó ..

from random import randint
import datetime

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

TIẾP CẬN TỐT HƠN

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

Vì Python 3 timedeltahỗ trợ nhân với số float, nên bây giờ bạn có thể làm:

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

cho rằng startvà endlà loại datetime.datetime. Ví dụ: để tạo một datetime ngẫu nhiên trong ngày tiếp theo:

import random
from datetime import datetime, timedelta

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

Để sử dụng chip trong giải pháp dựa trên gấu trúc, tôi sử dụng:

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

Tôi thích nó, vì sự tốt đẹp pd.Timestamp tính năng cho phép tôi ném các công cụ và định dạng khác nhau vào nó. Hãy xem xét một vài ví dụ sau đây ...

Chữ ký của bạn.

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

Vị trí ngẫu nhiên.

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

Định dạng khác nhau.

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

Vượt qua gấu trúc / đối tượng datetime trực tiếp.

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

Đây là một câu trả lời cho nghĩa đen của tiêu đề chứ không phải là nội dung của câu hỏi này:

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)

Mã này dựa trên câu trả lời được chấp nhận.

Bạn có thể sử dụng Mixer,

pip install mixer

và,

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

Chuyển đổi ngày của bạn thành dấu thời gian và gọi random.randintbằng dấu thời gian, sau đó chuyển đổi dấu thời gian được tạo ngẫu nhiên trở lại thành ngày:

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)

Sau đó, bạn có thể sử dụng nó như thế này

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

Nếu bạn quan tâm đến múi giờ, bạn chỉ nên sử dụng date_time_between_datestừ Fakerthư viện, nơi tôi đã đánh cắp mã này , như một câu trả lời khác đã gợi ý.

1. Chuyển đổi ngày nhập của bạn thành số (int, float, bất cứ điều gì tốt nhất cho việc sử dụng của bạn)
2. Chọn một số giữa hai số ngày của bạn.
3. Chuyển đổi số này trở lại một ngày.

Nhiều thuật toán để chuyển đổi ngày sang và từ số đã có sẵn trong nhiều hệ điều hành.

Bạn cần số ngẫu nhiên để làm gì? Thông thường (tùy thuộc vào ngôn ngữ), bạn có thể nhận được số giây / mili giây từ Kỷ nguyên từ một ngày. Vì vậy, đối với một ngày ngẫu nhiên giữa startDate và endDate bạn có thể làm:

1. tính thời gian tính bằng ms giữa startDate và endDate (endDate.toMilliseconds () - startDate.toMilliseconds ())
2. tạo một số từ 0 đến số bạn nhận được trong 1
3. tạo một Ngày mới với thời gian bù = startDate.toMilliseconds () + số thu được trong 2

Cách dễ nhất để làm điều này là chuyển đổi cả hai số thành dấu thời gian, sau đó đặt chúng làm giới hạn tối thiểu và tối đa trên một trình tạo số ngẫu nhiên.

Một ví dụ nhanh về PHP sẽ là:

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

Hàm này sử dụng strtotime()để chuyển đổi một mô tả datetime thành dấu thời gian Unix và date()để tạo một ngày hợp lệ ra khỏi dấu thời gian ngẫu nhiên đã được tạo.

Chỉ cần thêm một cái khác:

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

Việc xử lý ngày cần một số cân nhắc. Với 28 bạn đang ở trên trang web an toàn.

Đây là một giải pháp được sửa đổi từ cách tiếp cận của emyller, trả về một mảng ngày ngẫu nhiên ở bất kỳ độ phân giải nào

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

Một phần của những gì hay ho về cách tiếp cận này là nó np.datetime64thực sự tốt trong việc ép buộc mọi thứ vào ngày, vì vậy bạn có thể chỉ định ngày bắt đầu / ngày kết thúc của mình là chuỗi, mốc thời gian, dấu thời gian của gấu trúc ... khá nhiều thứ sẽ hoạt động.

Về mặt khái niệm nó khá đơn giản. Tùy thuộc vào ngôn ngữ bạn đang sử dụng, bạn sẽ có thể chuyển đổi các ngày đó thành một số nguyên 32 hoặc 64 bit tham chiếu, thường biểu thị giây kể từ epoch (ngày 1 tháng 1 năm 1970) hay còn gọi là "thời gian Unix" hoặc mili giây kể từ một ngày tùy ý khác. Chỉ cần tạo một số nguyên ngẫu nhiên 32 hoặc 64 bit giữa hai giá trị đó. Đây phải là một lót trong bất kỳ ngôn ngữ.

Trên một số nền tảng, bạn có thể tạo thời gian là gấp đôi (ngày là phần nguyên, thời gian là phần phân số là một lần thực hiện). Nguyên tắc tương tự được áp dụng ngoại trừ bạn đang xử lý các số dấu phẩy động chính xác đơn hoặc kép ("số float" hoặc "nhân đôi" trong C, Java và các ngôn ngữ khác). Trừ đi sự khác biệt, nhân với số ngẫu nhiên (0 <= r <= 1), thêm vào thời gian bắt đầu và thực hiện.

Trong trăn:

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

(cần dateutilthư viện python - pip install python-dateutil)

Sử dụng ApacheCommonUtils để tạo một khoảng thời gian ngẫu nhiên trong một phạm vi nhất định và sau đó tạo Ngày từ đó.

Thí dụ:

nhập org.apache.commons.math.random.RandomData;

nhập org.apache.commons.math.random.RandomDataImpl;

ngày công khai nextDate (Ngày tối thiểu, ngày tối đa) {

RandomData randomData = new RandomDataImpl();

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

}

Tôi đã thực hiện điều này cho một dự án khác bằng cách sử dụng ngẫu nhiên và thời gian. Tôi đã sử dụng một định dạng chung theo thời gian bạn có thể xem tài liệu ở đây cho đối số đầu tiên trong strftime (). Phần thứ hai là một hàm Random.randrange. Nó trả về một số nguyên giữa các đối số. Thay đổi nó thành phạm vi phù hợp với chuỗi bạn muốn. Bạn phải có những lý lẽ tốt đẹp trong bộ dữ liệu thứ hai.

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

Giải pháp gấu trúc + 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 là sự khác biệt giữa dấu thời gian tính bằng giây (float). Sau đó, nó được sử dụng để tạo ra một thời gian gấu trúc giữa 0 và dts, được thêm vào dấu thời gian bắt đầu.

Dựa trên câu trả lời của mouviciel, đây là một giải pháp véc tơ sử dụng numpy. Chuyển đổi ngày bắt đầu và ngày kết thúc thành ints, tạo một mảng các số ngẫu nhiên giữa chúng và chuyển đổi toàn bộ mảng trở lại thành ngày.

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

Đó là phương pháp sửa đổi của @ (Tom Alsberg). Tôi đã sửa đổi nó để có được ngày với mili giây.

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)

Thí dụ:

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

Đầu ra: 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)))

tham khảo

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

Cách khác để tạo ra ngày ngẫu nhiên giữa hai ngày sử dụng np.random.randint(), pd.Timestamp().valuevà pd.to_datetime()với 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)

Đầu ra

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