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
Jawaban:
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
startvariabel dalam kasus itu sangat tepat. Satu-satunya masalah yang saya lihat di kode adalah penggunaan secondsatribut dari resultan delta. Itu tidak akan mengembalikan jumlah total detik di seluruh interval; sebaliknya, ini hanya jumlah detik dari komponen 'waktu' (antara 0 dan 60); sebuah timedeltaobjek memiliki total_secondsmetode, yang harus digunakan sebagai gantinya.
(delta.days * 24 * 60 * 60) + delta.secondsyang menghasilkan total detik. The total_seconds()metode yang baru di python 2,7 dan tidak ada kembali pada tahun 2009 ketika saya menjawab pertanyaan itu. Jika Anda memiliki python 2.7 Anda harus menggunakannya sebagai gantinya, tetapi kodenya berfungsi dengan baik apa adanya.
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.
Bahkan lebih sederhana menggunakan 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')
Sangat sederhana menggunakan radar
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()
datetime.date(2039, 3, 16)Tapi saya ingin keluaran seperti ini 2039-03-16. Bagaimana cara melakukannya?
fake.date_between(start_date='today', end_date='+30y').strftime('%Y-%m-%d').
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))
startdate+ 1 tahun melewati 31 Desember pada tahun kabisat, ini kode tidak akan pernah memilih tanggal yang sama persis setahun kemudian. Kedua pendekatan hanya memungkinkan Anda menentukan tanggal mulai dan berapa tahun ke depan, sedangkan pertanyaannya menanyakan tentang menentukan dua tanggal, dan menurut saya itu adalah API yang lebih berguna.
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)
deltanilai dan memetakan semuanya sekaligus ke cap waktu. Secara pribadi, saya lebih suka melakukan sesuatu seperti pd.Series([5] * 10, [random_date('2014-01-01', '2014-01-30') for i in range(10)]).
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.
ptime = random.randint(stime, etime)sedikit lebih tepat karena randintmenghasilkan rentang inklusif.
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))
client = mixer.blend(Client, date=mixer.RANDOM)
#!/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.
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:
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
# 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']
ptime = stime + prop * (etime - stime) + 0.5