根据 python 中的时间段为 运行 的脚本生成一些 "random" 开始时间
Generate some "random" start times for scripts to run based on a period of time in python
我正在尝试生成一些随机播种时间来告诉我的脚本何时从主脚本中触发每个脚本。
我想设置一个时间范围：
START_TIME = "02:00"
END_TIME = "03:00"
当它到达开始时间时，它需要查看我们有多少脚本 运行:
script1.do_proc()
script2.alter()
script3.noneex()
在这种情况下，有 3 到 运行，因此需要生成 3 个随机时间来启动这些脚本，每个脚本之间的 最小 间隔为 5 分钟但时间必须在START_TIME和END_TIME
中设置的时间之内
但是，它还需要知道 script1.main 始终是第一个触发的脚本，其他脚本可以随意调整（随机）
所以我们可能有 script1 运行ning 在 01:43 然后 script3 运行ning 在 01:55 然后 script2 可能 运行 在 02:59
我们还可以在 01:35 处设置 script1 运行ning，然后在 01:45 处设置 script3 运行ning，然后 script2 可能 运行 在 01:45 这也很好。
到目前为止我的脚本可以在下面找到：
import random
import pytz
from time import sleep
from datetime import datetime
import script1
import script2
import script3
START_TIME = "01:21"
END_TIME = "03:00"
while 1:
try:
# Set current time & dates for GMT, London
CURRENT_GMTTIME = datetime.now(pytz.timezone('Europe/London')).strftime("%H%M")
CURRENT_GMTDAY = datetime.now(pytz.timezone('Europe/London')).strftime("%d%m%Y")
sleep(5)
# Grab old day for comparisons
try:
with open("DATECHECK.txt", 'rb') as DATECHECK:
OLD_DAY = DATECHECK.read()
except IOError:
with open("DATECHECK.txt", 'wb') as DATECHECK:
DATECHECK.write("0")
OLD_DAY = 0
# Check for new day, if it's a new day do more
if int(CURRENT_GMTDAY) != int(OLD_DAY):
print "New Day"
# Check that we are in the correct period of time to start running
if int(CURRENT_GMTTIME) <= int(START_TIME.replace(":", "")) and int(CURRENT_GMTTIME) >= int(END_TIME.replace(":", "")):
print "Correct time, starting"
# Unsure how to seed the start times for the scripts below
script1.do_proc()
script2.alter()
script3.noneex()
# Unsure how to seed the start times for above
# Save the current day to prevent it from running again today.
with open("DATECHECK.txt", 'wb') as DATECHECK:
DATECHECK.write(CURRENT_GMTDAY)
print "Completed"
else:
pass
else:
pass
except Exception:
print "Error..."
sleep(60)
编辑 2016 年 3 月 31 日
假设我添加了以下内容
SCRIPTS = ["script1.test()", "script2.test()", "script3.test()"]
MAIN_SCRIPT = "script1.test()"
TIME_DIFFERENCE = datetime.strptime(END_TIME, "%H:%M") - datetime.strptime(START_TIME, "%H:%M")
TIME_DIFFERENCE = TIME_DIFFERENCE.seconds
- 我们现在有脚本数量 运行
- 我们有 运行 的脚本列表。
- 我们有主要脚本的名称，第一个是 运行。
- 我们有时间（以秒为单位）来显示我们总共有多少时间来 运行 中的所有脚本。
当然有一种方法我们可以插入某种循环来完成这一切..
for i in range(len(SCRIPTS))，也就是3倍- 生成 3 个种子，确保最短时间为
300，并且 3 个种子加在一起不得超过 TIME_DIFFERENCE
- 根据
RUN_TIME = START_TIME创建开始时间，然后RUN_TIME = RUN_TIME + SEED[i]
- 第一个循环将检查
MAIN_SCRIPT 是否存在于 SCRIPTS 中，如果存在，那么它将首先 运行 该脚本，从 SCRIPTS 中删除自身，然后继续next 循环，因为它在 SCRIPTS 中不存在，它将切换为随机调用其他脚本之一。
播种时代
以下似乎可行，但可能有更简单的方法。
CALCULATE_SEEDS = 0
NEW_SEED = 0
SEEDS_SUCESSS = False
SEEDS = []
while SEEDS_SUCESSS == False:
# Generate a new seed number
NEW_SEED = random.randrange(0, TIME_DIFFERENCE)
# Make sure the seed is above the minimum number
if NEW_SEED > 300:
SEEDS.append(NEW_SEED)
# Make sure we have the same amount of seeds as scripts before continuing.
if len(SEEDS) == len(SCRIPTS):
# Calculate all of the seeds together
for SEED in SEEDS:
CALCULATE_SEEDS += SEED
# Make sure the calculated seeds added together is smaller than the total time difference
if CALCULATE_SEEDS >= TIME_DIFFERENCE:
# Reset and try again if it's not below the number
SEEDS = []
else:
# Exit while loop if we have a correct amount of seeds with minimum times.
SEEDS_SUCESSS = True
使用datetime.timedelta计算时差。此代码假定所有三个进程 运行 在同一天
from datetime import datetime, timedelta
from random import randint
YR, MO, DY = 2016, 3, 30
START_TIME = datetime( YR, MO, DY, 1, 21, 00 ) # "01:21"
END_TIME = datetime( YR, MO, DY, 3, 0, 0 ) # "3:00"
duration_all = (END_TIME - START_TIME).seconds
d1 = ( duration_all - 600 ) // 3
#
rnd1 = randint(0,d1)
rnd2 = rnd1 + 300 + randint(0,d1)
rnd3 = rnd2 + 300 + randint(0,d1)
#
time1 = START_TIME + timedelta(seconds=rnd1)
time2 = START_TIME + timedelta(seconds=rnd2)
time3 = START_TIME + timedelta(seconds=rnd3)
#
print (time1)
print (time2)
print (time3)
rnd1、rnd2 和 rnd3 的值至少相隔 5 分钟（300 秒）。
rnd3 的值不能大于总时间间隔 (3 * d1 + 600)。所以所有三个时间都发生在区间内。
注意您没有指定每个脚本需要多少时间 运行s。这就是为什么我没有使用 time.sleep。一个可能的选项是 threading.Timer（参见 python 文档）。
假设您将所有 method.func() 存储在一个数组中，并且如您所述，后续脚本必须在脚本 1 之后至少 5 分钟。它们可以随机执行，所以我们可以启动多个进程，让它们休眠一段时间，然后它们才能自动启动。 （计时以秒为单位）
from multiprocessing import Process
import os
import random
import time
#store all scripts you want to execute here
eval_scripts = ["script1.test()","script2.test()", "script3.test()"]
#run job on different processes. non-blocking
def run_job(eval_string,time_sleep):
#print out script + time to test
print eval_string + " " + str(time_sleep)
time.sleep(time_sleep) #wait to be executed
#time to start
eval(eval_string)
def do_my_jobs():
start_time = []
#assume the duration between start_time and end_time is 60 mins, leave some time for other jobs after the first job (5-10 mins). This is just to be careful in case random.randrange returns the largest number
#adjust this according to the duration between start_time and end_time since calculating (end_time - star_time) is trivial.
proc1_start_time = random.randrange(60*60 - 10*60)
start_time.append(proc1_start_time)
#randomize timing for other procs != first script
for i in range(len(eval_scripts)-1):
#randomize time from (proc1_start_time + 5 mins) to (end_time - star_time)
start_time.append(random.randint(proc1_start_time+5*60, 60*60))
for i in range(len(eval_scripts)):
p_t = Process(target = run_job, args = (eval_scripts[i],start_time[i],))
p_t.start()
p_t.join()
现在您需要做的就是每天在 START_TIME 调用 do_my_jobs() 一次。
我正在尝试生成一些随机播种时间来告诉我的脚本何时从主脚本中触发每个脚本。
我想设置一个时间范围：
START_TIME = "02:00"
END_TIME = "03:00"
当它到达开始时间时，它需要查看我们有多少脚本 运行:
script1.do_proc()
script2.alter()
script3.noneex()
在这种情况下，有 3 到 运行，因此需要生成 3 个随机时间来启动这些脚本，每个脚本之间的 最小 间隔为 5 分钟但时间必须在START_TIME和END_TIME
但是，它还需要知道 script1.main 始终是第一个触发的脚本，其他脚本可以随意调整（随机）
所以我们可能有 script1 运行ning 在 01:43 然后 script3 运行ning 在 01:55 然后 script2 可能 运行 在 02:59
我们还可以在 01:35 处设置 script1 运行ning，然后在 01:45 处设置 script3 运行ning，然后 script2 可能 运行 在 01:45 这也很好。
到目前为止我的脚本可以在下面找到：
import random
import pytz
from time import sleep
from datetime import datetime
import script1
import script2
import script3
START_TIME = "01:21"
END_TIME = "03:00"
while 1:
try:
# Set current time & dates for GMT, London
CURRENT_GMTTIME = datetime.now(pytz.timezone('Europe/London')).strftime("%H%M")
CURRENT_GMTDAY = datetime.now(pytz.timezone('Europe/London')).strftime("%d%m%Y")
sleep(5)
# Grab old day for comparisons
try:
with open("DATECHECK.txt", 'rb') as DATECHECK:
OLD_DAY = DATECHECK.read()
except IOError:
with open("DATECHECK.txt", 'wb') as DATECHECK:
DATECHECK.write("0")
OLD_DAY = 0
# Check for new day, if it's a new day do more
if int(CURRENT_GMTDAY) != int(OLD_DAY):
print "New Day"
# Check that we are in the correct period of time to start running
if int(CURRENT_GMTTIME) <= int(START_TIME.replace(":", "")) and int(CURRENT_GMTTIME) >= int(END_TIME.replace(":", "")):
print "Correct time, starting"
# Unsure how to seed the start times for the scripts below
script1.do_proc()
script2.alter()
script3.noneex()
# Unsure how to seed the start times for above
# Save the current day to prevent it from running again today.
with open("DATECHECK.txt", 'wb') as DATECHECK:
DATECHECK.write(CURRENT_GMTDAY)
print "Completed"
else:
pass
else:
pass
except Exception:
print "Error..."
sleep(60)
编辑 2016 年 3 月 31 日
假设我添加了以下内容
SCRIPTS = ["script1.test()", "script2.test()", "script3.test()"]
MAIN_SCRIPT = "script1.test()"
TIME_DIFFERENCE = datetime.strptime(END_TIME, "%H:%M") - datetime.strptime(START_TIME, "%H:%M")
TIME_DIFFERENCE = TIME_DIFFERENCE.seconds
- 我们现在有脚本数量 运行
- 我们有 运行 的脚本列表。
- 我们有主要脚本的名称，第一个是 运行。
- 我们有时间（以秒为单位）来显示我们总共有多少时间来 运行 中的所有脚本。
当然有一种方法我们可以插入某种循环来完成这一切..
for i in range(len(SCRIPTS))，也就是3倍- 生成 3 个种子，确保最短时间为
300，并且 3 个种子加在一起不得超过TIME_DIFFERENCE - 根据
RUN_TIME = START_TIME创建开始时间，然后RUN_TIME = RUN_TIME + SEED[i] - 第一个循环将检查
MAIN_SCRIPT是否存在于SCRIPTS中，如果存在，那么它将首先 运行 该脚本，从SCRIPTS中删除自身，然后继续next 循环，因为它在SCRIPTS中不存在，它将切换为随机调用其他脚本之一。
播种时代
以下似乎可行，但可能有更简单的方法。
CALCULATE_SEEDS = 0
NEW_SEED = 0
SEEDS_SUCESSS = False
SEEDS = []
while SEEDS_SUCESSS == False:
# Generate a new seed number
NEW_SEED = random.randrange(0, TIME_DIFFERENCE)
# Make sure the seed is above the minimum number
if NEW_SEED > 300:
SEEDS.append(NEW_SEED)
# Make sure we have the same amount of seeds as scripts before continuing.
if len(SEEDS) == len(SCRIPTS):
# Calculate all of the seeds together
for SEED in SEEDS:
CALCULATE_SEEDS += SEED
# Make sure the calculated seeds added together is smaller than the total time difference
if CALCULATE_SEEDS >= TIME_DIFFERENCE:
# Reset and try again if it's not below the number
SEEDS = []
else:
# Exit while loop if we have a correct amount of seeds with minimum times.
SEEDS_SUCESSS = True
使用datetime.timedelta计算时差。此代码假定所有三个进程 运行 在同一天
from datetime import datetime, timedelta
from random import randint
YR, MO, DY = 2016, 3, 30
START_TIME = datetime( YR, MO, DY, 1, 21, 00 ) # "01:21"
END_TIME = datetime( YR, MO, DY, 3, 0, 0 ) # "3:00"
duration_all = (END_TIME - START_TIME).seconds
d1 = ( duration_all - 600 ) // 3
#
rnd1 = randint(0,d1)
rnd2 = rnd1 + 300 + randint(0,d1)
rnd3 = rnd2 + 300 + randint(0,d1)
#
time1 = START_TIME + timedelta(seconds=rnd1)
time2 = START_TIME + timedelta(seconds=rnd2)
time3 = START_TIME + timedelta(seconds=rnd3)
#
print (time1)
print (time2)
print (time3)
rnd1、rnd2 和 rnd3 的值至少相隔 5 分钟（300 秒）。
rnd3 的值不能大于总时间间隔 (3 * d1 + 600)。所以所有三个时间都发生在区间内。
注意您没有指定每个脚本需要多少时间 运行s。这就是为什么我没有使用 time.sleep。一个可能的选项是 threading.Timer（参见 python 文档）。
假设您将所有 method.func() 存储在一个数组中，并且如您所述，后续脚本必须在脚本 1 之后至少 5 分钟。它们可以随机执行，所以我们可以启动多个进程，让它们休眠一段时间，然后它们才能自动启动。 （计时以秒为单位）
from multiprocessing import Process
import os
import random
import time
#store all scripts you want to execute here
eval_scripts = ["script1.test()","script2.test()", "script3.test()"]
#run job on different processes. non-blocking
def run_job(eval_string,time_sleep):
#print out script + time to test
print eval_string + " " + str(time_sleep)
time.sleep(time_sleep) #wait to be executed
#time to start
eval(eval_string)
def do_my_jobs():
start_time = []
#assume the duration between start_time and end_time is 60 mins, leave some time for other jobs after the first job (5-10 mins). This is just to be careful in case random.randrange returns the largest number
#adjust this according to the duration between start_time and end_time since calculating (end_time - star_time) is trivial.
proc1_start_time = random.randrange(60*60 - 10*60)
start_time.append(proc1_start_time)
#randomize timing for other procs != first script
for i in range(len(eval_scripts)-1):
#randomize time from (proc1_start_time + 5 mins) to (end_time - star_time)
start_time.append(random.randint(proc1_start_time+5*60, 60*60))
for i in range(len(eval_scripts)):
p_t = Process(target = run_job, args = (eval_scripts[i],start_time[i],))
p_t.start()
p_t.join()
现在您需要做的就是每天在 START_TIME 调用 do_my_jobs() 一次。