Python 计算出a在时间b之后的时间

我需要一种方法来找出一个日期时间有多长。时间在另一个日期时间之后。时间很简单，但是。。。问题是我的时间值是24小时的，所以它不像从一个值到另一个值求反那么简单。相反，我需要计算出时间a之后的时间b是多长，如果我在时间上向前计数，在午夜时间循环，即

time_a = 09:00
time_b = 04:00

这里的时间是时间a后19小时

def time_after_time(time_a, time_b):

    a_hour = time_a.hour
    a_minute = time_a.minute
    b_hour = time_b.hour
    b_minute = time_b.minute

    out_hour = b_hour - a_hour
    out_minute = b_minute - a_minute

    if out_hour < 0:
        out_hour += 24

    if out_minute < 0:
        out_hour -= 1
        out_minute += 60

    return datetime.time(out_hour, out_minute)

def time_-after_-time（time_a，time_b）：
一小时=一小时的时间
一分钟=一分钟
小时=时间
分钟=时间分钟
外出时间=休息时间-休息时间
out_minute=b_minute-a_minute
如果超时时间<0：
外出时间+=24小时
如果输出时间小于0分钟：
外出时间-=1
分钟外+=60
return datetime.time（out\u小时，out\u分钟）

这是我第一次尝试，但结果是错误的

有人能想出一个更干净/正确的方法吗

timedif = DATETIME_1 - DATETIME_2
print timedif

请确保使用datetime.datetime时间

您可以使用将datetime.time转换为datetime

datetime.datetime.combine(datetime.datetime.now().date(),datetimeTime_obj)

---

09:00-10:00=1小时还是25小时？那么最长是24小时吗

import datetime

time_a = datetime.time(9,00)
time_b = datetime.time(5,0)
dte = datetime.datetime.now().date()

dt_a = datetime.datetime.combine(dte,time_a)

dt_b = datetime.datetime.combine(dte,time_b)
time_dif = dt_b - dt_a
time_dif2 = dt_a - dt_b
print "TimeDif:",time_dif,time_dif2
#output: 20:00:00 , 04:00:00

请确保使用datetime.datetime时间

您可以使用将datetime.time转换为datetime

datetime.datetime.combine(datetime.datetime.now().date(),datetimeTime_obj)

---

09:00-10:00=1小时还是25小时？那么最长是24小时吗

import datetime

time_a = datetime.time(9,00)
time_b = datetime.time(5,0)
dte = datetime.datetime.now().date()

dt_a = datetime.datetime.combine(dte,time_a)

dt_b = datetime.datetime.combine(dte,time_b)
time_dif = dt_b - dt_a
time_dif2 = dt_a - dt_b
print "TimeDif:",time_dif,time_dif2
#output: 20:00:00 , 04:00:00

根据我的经验，无论何时从外部来源收到基于24小时的时间戳，都必须立即在内部将其转换为绝对时间，例如1970年的秒数。有关执行此操作的方法，请参见

C

中的示例

一旦你这样做了，那么简单的时间减法就变得简单有效了

如果不这样做，则时间戳相差48小时的问题最终会出现

例如，如果您正在对历史存档数据进行分析或回放，则这种转换有时不应以当前日期/时间为基础。

根据我的经验，当您从外部来源收到基于24小时的时间戳时，必须立即在内部将其转换为绝对时间，比如1970年的秒数。有关执行此操作的方法，请参见

C

中的示例

一旦你这样做了，那么简单的时间减法就变得简单有效了

如果不这样做，则时间戳相差48小时的问题最终会出现

例如，如果您正在对历史存档数据进行分析或回放，则这种转换有时不应基于当前日期/时间。

第二个答案（由于第一个答案中给出的原因，我不建议这样做）。在

C

中，您可以：

int time1MinusTime2Positive(int t1, int t2) { // returns dt from 0 to <24 hours
    return fmod(t1 - t2 + 100 * 24 * 60 * 60, 24 * 60 * 60);
}

int time1MinusTime2(int t1, int t2) { // returns dt between -12 and +12 hours
    const int dt = t1 - t2;
    if (dt > 24 * 60 * 60 / 2)
       return dt - 24 * 60 * 60;
    else if (dt < -24 * 60 * 60 / 2)
       return dt + 24 * 60 * 60;
    else
       return dt;
}

int-time1MinusTime2Positive（int-t1，int-t2）{//返回从0到24*60*60/2的dt）
返回dt-24*60*60；
否则如果（dt<-24*60*60/2）
返回dt+24*60*60；
其他的
返回dt；
}

这里的输入时间表示为从午夜开始的秒数，或者从1970年开始的秒数，或者从1900年开始的秒数——这无关紧要。输出以秒为单位，相对于“当前”午夜，无论“当前”是什么意思。

第二个答案（由于第一个答案中给出的原因，我不建议这样做）。在

C

中，您可以：

int time1MinusTime2Positive(int t1, int t2) { // returns dt from 0 to <24 hours
    return fmod(t1 - t2 + 100 * 24 * 60 * 60, 24 * 60 * 60);
}

int time1MinusTime2(int t1, int t2) { // returns dt between -12 and +12 hours
    const int dt = t1 - t2;
    if (dt > 24 * 60 * 60 / 2)
       return dt - 24 * 60 * 60;
    else if (dt < -24 * 60 * 60 / 2)
       return dt + 24 * 60 * 60;
    else
       return dt;
}

int-time1MinusTime2Positive（int-t1，int-t2）{//返回从0到24*60*60/2的dt）
返回dt-24*60*60；
否则如果（dt<-24*60*60/2）
返回dt+24*60*60；
其他的
返回dt；
}

这里的输入时间表示为从午夜开始的秒数，或者从1970年开始的秒数，或者从1900年开始的秒数——这无关紧要。输出以秒为单位，相对于“当前”午夜，无论“当前”是什么意思。

以下是我的解决方案：

def time_after_time(time_a, time_b):
    time_a_min = time_a.hour * 60 + time_a.minute
    time_b_min = time_b.hour * 60 + time_b.minute
    out_min = time_b_min - time_a_min
    if out_min < 0:
        out_min += 24 * 60
    return datetime.time(out_min / 60, out_min % 60)

def time_-after_-time（time_a，time_b）：
时间每分钟=时间每小时*60+时间每分钟
time_b_min=time_b.hour*60+time_b.minute
out\u min=time\u b\u min-time\u a\u min
如果out_min<0：
out_min+=24*60
return datetime.time（out\u min/60，out\u min%60）

您可以对其进行测试。

以下是我的解决方案：

def time_after_time(time_a, time_b):
    time_a_min = time_a.hour * 60 + time_a.minute
    time_b_min = time_b.hour * 60 + time_b.minute
    out_min = time_b_min - time_a_min
    if out_min < 0:
        out_min += 24 * 60
    return datetime.time(out_min / 60, out_min % 60)

def time_-after_-time（time_a，time_b）：
时间每分钟=时间每小时*60+时间每分钟
time_b_min=time_b.hour*60+time_b.minute
out\u min=time\u b\u min-time\u a\u min
如果out_min<0：
out_min+=24*60
return datetime.time（out\u min/60，out\u min%60）

---

您可以在上进行测试。

为什么不使用

datetime.timedelta

time\u b-time\u a

将生成

timedelta

。这适用于datetime.datetime对象，但不适用于datetime.time对象unfortunatley@MartijnPieters看起来假设时间是同一天。。。所以，不太确定预期的答案是什么…是09:00-10:00=1小时还是25小时？那么最长是24小时吗？那么如果

a

=09:00和

b

=10:00，那么

b

是

a

之后的1小时，但是

a

是

b

之后的23小时，如果这是合理的，为什么不使用

datetime.timedelta

time\u b-time\u a

将生成

timedelta

。这适用于datetime.datetime对象，但不适用于datetime.time对象unfortunatley@MartijnPieters看起来假设时间是同一天。。。所以，不太确定预期的答案是什么…是09:00-10:00=1小时还是25小时？那么最长是24小时吗？因此，如果

a

=09:00和

b

=10:00，那么

b

是

a

之后的1小时，但是

a

是

b

之后的23小时，如果这是合理的，则其时差不得超过23:59小时。。。根据他的问题statement@JoranBeasley：也许我是盲人，但我在问题陈述中看不到这一点。如果是这样的话，这就不会是一个现实世界的问题。但不幸的是，我也看到了许多不正确的“现实世界”解决方案。这对我建议的解决方案没有影响。时代应该改变