Bagaimana saya menghasilkan tanggal acak yang harus berada di antara dua tanggal tertentu lainnya?

Tanda tangan fungsinya harus seperti ini:

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

dan akan mengembalikan tanggal seperti: 2/4/2008 7:20 PM

Ubah kedua string menjadi stempel waktu (dalam resolusi yang Anda pilih, mis. Milidetik, detik, jam, hari, apa pun), kurangi yang sebelumnya dari yang kemudian, kalikan nomor acak Anda (dengan asumsi itu didistribusikan di range [0, 1]) dengan perbedaan itu, dan tambahkan lagi ke yang sebelumnya. Ubah stempel waktu kembali ke string tanggal dan Anda memiliki waktu acak dalam rentang itu.

Contoh Python (keluaran hampir dalam format yang Anda tentukan, selain 0padding - salahkan konvensi format waktu Amerika):

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)

Presisinya hanya beberapa detik. Anda dapat meningkatkan presisi hingga mikrodetik, atau menurunkan, katakanlah, setengah jam, jika Anda mau. Untuk itu ubah saja perhitungan baris terakhir.

contoh run:

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

keluaran:

2008-12-04 01:50:17

Versi kecil.

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

Perhatikan bahwa argumen startdan keduanya endharus berupa datetimeobjek. Jika Anda memiliki string, cukup mudah untuk mengubahnya. Jawaban lain menunjukkan beberapa cara untuk melakukannya.

Jawaban yang diperbarui

Bahkan lebih sederhana menggunakan Faker .

Instalasi

pip install faker

Pemakaian:

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

Jawaban lama

Sangat sederhana menggunakan radar

Instalasi

pip install radar

Pemakaian

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

Ini adalah pendekatan yang berbeda - pekerjaan semacam itu ..

from random import randint
import datetime

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

PENDEKATAN YANG LEBIH BAIK

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

Karena Python 3 timedeltamendukung perkalian dengan float, jadi sekarang Anda dapat melakukan:

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

mengingat itu startdan endmerupakan tipe datetime.datetime. Misalnya, untuk menghasilkan tanggal waktu acak dalam hari berikutnya:

import random
from datetime import datetime, timedelta

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

Untuk memasukkan solusi berbasis panda, saya menggunakan:

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

Saya menyukainya, karena pd.Timestampfiturnya yang bagus yang memungkinkan saya menampilkan berbagai hal dan format yang berbeda. Perhatikan beberapa contoh berikut ...

Tanda tangan Anda.

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

Posisi acak.

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

Format berbeda.

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

Meneruskan objek pandas / datetime secara langsung.

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

Berikut adalah jawaban untuk arti literal dari judul daripada isi dari pertanyaan ini:

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)

Kode ini didasarkan secara longgar pada jawaban yang diterima.

Anda dapat Menggunakan Mixer,

pip install mixer

dan,

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

Ubah tanggal Anda menjadi stempel waktu dan panggil random.randintdengan stempel waktu, lalu ubah stempel waktu yang dibuat secara acak kembali menjadi tanggal:

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)

Kemudian Anda bisa menggunakannya seperti ini

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

Jika Anda peduli dengan zona waktu, Anda sebaiknya menggunakan date_time_between_datesdari Fakerperpustakaan, tempat saya mencuri kode ini , seperti yang sudah disarankan oleh jawaban yang berbeda.

1. Ubah tanggal masukan Anda menjadi angka (int, float, apa pun yang terbaik untuk penggunaan Anda)
2. Pilih nomor di antara dua nomor tanggal Anda.
3. Ubah nomor ini kembali menjadi tanggal.

Banyak algoritme untuk mengubah tanggal ke dan dari angka sudah tersedia di banyak sistem operasi.

Untuk apa Anda membutuhkan nomor acak? Biasanya (tergantung pada bahasanya) Anda bisa mendapatkan jumlah detik / milidetik dari Epoch dari sebuah tanggal. Jadi untuk tanggal acak antara startDate dan endDate Anda bisa melakukan:

1. hitung waktu dalam ms antara startDate dan endDate (endDate.toMilliseconds () - startDate.toMilliseconds ())
2. menghasilkan angka antara 0 dan angka yang Anda peroleh di 1
3. menghasilkan Tanggal baru dengan waktu offset = startDate.toMilliseconds () + angka yang diperoleh dalam 2

Cara termudah untuk melakukannya adalah dengan mengonversi kedua angka menjadi stempel waktu, lalu menetapkannya sebagai batas minimum dan maksimum pada generator angka acak.

Contoh singkat PHP adalah:

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

Fungsi ini digunakan strtotime()untuk mengubah deskripsi waktu ke waktu menjadi stempel waktu Unix, dan date()untuk membuat tanggal yang valid dari stempel waktu acak yang telah dibuat.

Hanya untuk menambahkan satu sama lain:

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

Penanganan hari perlu beberapa pertimbangan. Dengan 28 Anda berada di situs aman.

Berikut adalah solusi yang dimodifikasi dari pendekatan emiler yang mengembalikan serangkaian tanggal acak pada resolusi apa pun

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

Bagian dari apa yang menyenangkan tentang pendekatan ini adalah yang np.datetime64sangat baik dalam memaksa hal-hal sampai tanggal, sehingga Anda dapat menentukan tanggal mulai / akhir sebagai string, waktu, cap waktu panda ... hampir semua hal akan berhasil.

Secara konseptual cukup sederhana. Bergantung pada bahasa yang Anda gunakan, Anda akan dapat mengonversi tanggal tersebut menjadi beberapa referensi bilangan bulat 32 atau 64 bit, biasanya mewakili detik sejak periode (1 Januari 1970) atau dikenal sebagai "waktu Unix" atau milidetik sejak beberapa tanggal arbitrer lainnya. Cukup buat bilangan bulat 32 atau 64 bit acak di antara kedua nilai tersebut. Ini harus menjadi satu baris dalam bahasa apa pun.

Pada beberapa platform Anda dapat menghasilkan waktu sebagai ganda (tanggal adalah bagian integer, waktu adalah bagian pecahan adalah salah satu implementasi). Prinsip yang sama berlaku kecuali Anda berurusan dengan bilangan floating point presisi tunggal atau ganda ("float" atau "doubles" dalam C, Java, dan bahasa lain). Kurangi selisihnya, kalikan dengan angka acak (0 <= r <= 1), tambahkan waktu mulai dan selesai.

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

(membutuhkan dateutilperpustakaan python - pip install python-dateutil)

Gunakan ApacheCommonUtils untuk membuat panjang acak dalam rentang tertentu, lalu buat Tanggal dari panjang itu.

Contoh:

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

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

Tanggal publik nextDate (Tanggal min, Tanggal max) {

RandomData randomData = new RandomDataImpl();

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

}

Saya membuat ini untuk proyek lain menggunakan waktu dan acak. Saya menggunakan format umum dari waktu Anda dapat melihat dokumentasi di sini untuk argumen pertama di strftime (). Bagian kedua adalah fungsi random.range. Ini mengembalikan integer antara argumen. Ubah ke rentang yang sesuai dengan string yang Anda inginkan. Anda harus memiliki argumen yang bagus di tupel arugment kedua.

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 + solusi 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 adalah perbedaan antara cap waktu dalam detik (float). Ini kemudian digunakan untuk membuat pandas timedelta antara 0 dan dts, yang ditambahkan ke stempel waktu mulai.

Berdasarkan jawaban mouviciel, berikut adalah solusi vektorisasi menggunakan numpy. Konversikan tanggal mulai dan akhir menjadi int, buat array angka acak di antara keduanya, dan ubah seluruh array kembali ke tanggal.

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

Ini metode yang dimodifikasi dari @ (Tom Alsberg). Saya memodifikasinya untuk mendapatkan tanggal dengan milidetik.

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)

Contoh:

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

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

lihat

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

Cara alternatif untuk membuat tanggal acak antara dua tanggal menggunakan np.random.randint(), pd.Timestamp().valuedan pd.to_datetime()dengan 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)

Keluaran

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