import time
time.sleep(7)
print(11)

让主程序暂时11秒后，再继续执行

time.sleep(0.1) # sleep 0.1秒

 
import time  
from tpf import log

def task_to_run():  
    print("Task is running at the specified time (or close to it).")  


def run(wait_time = 24*60*60):
    current_time = time.time()  
    target_time = current_time + wait_time  
        
    while True:  
        if time.time() >= target_time:  
            task_to_run()  
            break  # 执行完毕后退出循环  
        else:  
            time.sleep(3*60)  # 每3*60秒检查一次时间
            log("sleep",fil="run.log")

run()
    

 
run.sh 
nohup /data/jupyter/pyuban/bin/python /opt/wks/jupyter/test/run.py >/tmp/run.log 2>&1 &

下面的方式不一定生效
!sh run.sh 

可采用下面的方式
import os 
os.system("sh /opt/wks/jupyter/test/run.sh ")

天数相减

 
import datetime
day1 = datetime.datetime.now()
day3 = datetime.datetime.now() - datetime.timedelta(days=3)
day = day1 - day3 
day.days

输出：
2

两个日期之间的天数

 
from datetime import datetime
start_date = "2023-01-01"
end_date = "2023-07-14"

start_datetime = datetime.strptime(start_date, "%Y-%m-%d")
end_datetime = datetime.strptime(end_date, "%Y-%m-%d")

delta = end_datetime - start_datetime
days = delta.days
days
194

9小时前时间

 
import time
from datetime import datetime, timedelta

nine_hours_ago_str = (datetime.now() - timedelta(hours=9)).strftime("%Y-%m-%d %H:%M:%S")
print("9小时前时间:", nine_hours_ago_str)

time.time

 
import time
start_time = time.time() # 记录程序开始时间

y=model(X=index)

end_time = time.time()  # 记录程序结束时间
tim_ms = round((end_time - start_time)*1000,2)

print("程序运行时间为", tim_ms, "毫秒")

datetime.datetime.now()

 
import datetime
start_time = datetime.datetime.now() # 记录程序开始时间

y=model(X=index)

end_time = datetime.datetime.now() # 记录程序结束时间
tim = (end_time - start_time)
print(type(tim))  # class 'datetime.timedelta'

print("程序运行时间为", tim.total_seconds() *1000,"毫秒")

timeit：可精确到微秒

 
import timeit

# 只能写简单的代码，不能写方法，不能对象调用 
code_to_test = """
for i in range(10000):
    pass
"""

elapsed_time = timeit.timeit(code_to_test, number=1)

print("代码执行1次的平均时间为：", round(elapsed_time*1000*1000), "微秒")

 
代码执行1次的平均时间为： 184 微秒

profile

 
import profile
def foo():
    for i in range(10000000):
        pass

profile.run("foo()")


5 function calls in 0.234 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.234    0.234    0.234    0.234 2673007575.py:3(foo)
        1    0.000    0.000    0.234    0.234 :0(exec)
        1    0.000    0.000    0.000    0.000 :0(setprofile)
        1    0.000    0.000    0.234    0.234 string:1(module)
        1    0.000    0.000    0.234    0.234 profile:0(foo())
        0    0.000             0.000          profile:0(profiler)

cProfile : c语言版的profile

 
import cProfile

def foo():
    for i in range(10000):
        pass

cProfile.run("foo()")


4 function calls in 0.001 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.001    0.001    0.001    0.001 1155913500.py:3(foo)
        1    0.000    0.000    0.001    0.001 string:1(module)
        1    0.000    0.000    0.001    0.001 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

使用time.time()

 
import time

def format_time(seconds):
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    seconds = seconds % 60
    return f"{hours:02d}:{minutes:02d}:{seconds:05.2f}"

# 记录开始时间
start_time = time.time()

# 模拟一段耗时操作
sum_value = 0
for i in range(1, 1000000):
    sum_value += i

# 记录结束时间
end_time = time.time()

# 计算运行时间（秒）
elapsed_time = end_time - start_time

# 转换为时分秒格式
formatted_time = format_time(elapsed_time)
print(f"程序运行时间: {formatted_time}")

使用time.perf_counter()（更高精度）

 
import time

def format_time(seconds):
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    seconds = seconds % 60
    return f"{hours:02d}:{minutes:02d}:{seconds:05.2f}"

# 记录开始时间
start_time = time.perf_counter()

# 模拟一段耗时操作
sum_value = 0
for i in range(1, 1000000):
    sum_value += i

# 记录结束时间
end_time = time.perf_counter()

# 计算运行时间（秒）
elapsed_time = end_time - start_time

# 转换为时分秒格式
formatted_time = format_time(elapsed_time)
print(f"程序运行时间: {formatted_time}")

 
time.time()：返回当前时间的时间戳（从1970年1月1日开始的秒数），适合测量时间间隔。
time.perf_counter()：返回性能计数器的值（以秒为单位），包括睡眠时间，适合高精度计时。
format_time函数：将秒数转换为HH:MM:SS.ss格式，其中：
HH表示小时（2位数字，不足补零）。
MM表示分钟（2位数字，不足补零）。
SS.ss表示秒和毫秒（5位数字，其中小数点后保留2位）。

 
如果程序运行时间为1.234秒，输出为：
程序运行时间: 00:00:01.23

注意事项

 
对于非常短的时间间隔（如微秒级），time.time()可能不够精确，建议使用time.perf_counter()。
如果需要更友好的时间格式（如“1小时2分3秒”），可以调整format_time函数的返回值。

 
import datetime
t=datetime.datetime.now().isocalendar()
y,x,d = t 
if d == 0:
    d = '日'
print(f"今天是{y}年第{x}个星期，星期{d}") # 今天是2023年第21个星期，星期4

 
from datetime import datetime

# 获取当前日期时间
now = datetime.now()

# 使用 isocalendar() 获取年、周数、星期几
year, week_num, weekday = now.isocalendar()

print(f"今天是 {year} 年的第 {week_num} 周")

    

 
from datetime import datetime

now = datetime.now()

# %U: 一年中的第几周（以周日为一周的开始）
week_sunday = now.strftime("%U")

# %W: 一年中的第几周（以周一为一周的开始）
week_monday = now.strftime("%W")

print(f"使用 %U（周日为起点）: 第 {week_sunday} 周")
print(f"使用 %W（周一为起点）: 第 {week_monday} 周")

%U：周数从 周日 开始计算，00 表示第一周不足一周的部分
%W：周数从 周一 开始计算，00 表示第一周不足一周的部分

    

 
import datetime

date = datetime.datetime(2025, 1, 1)
year, week, weekday = date.isocalendar()
print(f"2025年1月1日属于 {year} 年的第 {week} 周")
    

 
----------------------------------------------------------------------------------