将Python datetime对象格式化为参数

Question

我对Python比较新，但正在尝试将其用于卫星轨道分析。我真的不太理解datetime对象和方法。我想能够将datetime对象传递给一个函数，该函数接受与datetime相同格式的参数（年、月、日、小时、分钟、秒）。下面的代码虽然可以工作，但一定有更好的方法。请启迪我。谢谢！

import jday
import datetime

jdate = jday.JD(2015,12,1,22,8,0) # example

now1 = datetime.datetime.now().strftime("%Y,%m,%d,%H,%M,%S")
now2 = now1.split(",")
now3 = [int(i) for i in now2]
jdatenow = jday.JD(*now3)
print jdatenow

jday模块是从David Vallado的天体动力学源代码的Matlab版本移植而来。

import math as m

def JD(yr, mon, day, hr, min, sec):
        jd = 367.0 * yr - m.floor( 
        (7 * (yr + m.floor( (mon + 9) / 12.0) ) ) * 0.25 ) + m.floor(
        275 * mon / 9.0 ) + day + 1721013.5 + (
        (sec/60.0 + min ) / 60.0 + hr ) / 24.0
        return jd

- Jesse Reich

---

对你来说使用内联版本会更好吗？例如 now=[int(i) for i in datetime.datetime.now().strftime("%Y,%m,%d,%H,%M,%S").split(",")] - Antonio Ragagnin

公式在1900年和2100年整整错了一天，请参见我的回答中的详细信息。 - jfs

Answer 1

给定你已经移植了JD代码，并且作为模块jday进行了控制，也许装饰器是你要寻找的。这样做的明显好处是不会破坏函数的原始签名（对于现有客户端代码），但可以添加所需的日期参数，从而增加方便性。

还创建了一个jday2模块，它与原始的jday模块相同，但其JD()函数直接接受日期对象。如果您不需要任何向后兼容性，这是最简单的解决方案。

请参见下面的工作示例代码：

jday.py

import math as m
import functools

def date_support_wrapper(f):
    """ Wraps JD and provides a way to pass a date param

    :param f: the original function
    :return: the wrapper around the original function
    """

    @functools.wraps(f)
    def wrap(*args, **kwargs):
        if 'date' in kwargs:
            d = kwargs['date']
            return f(yr=d.year, mon=d.month, day=d.day, hr=d.hour, min=d.minute, sec=d.second)

        return f(*args, **kwargs)

    return wrap


@date_support_wrapper
def JD(yr, mon, day, hr, min, sec):
    jd = 367.0 * yr - m.floor(
        (7 * (yr + m.floor((mon + 9) / 12.0))) * 0.25) + m.floor(
        275 * mon / 9.0) + day + 1721013.5 + (
                                                 (sec / 60.0 + min) / 60.0 + hr) / 24.0
    return jd

jday2.py

import math as m

def JD(dt):
    """ Same calculation as JD but accepts a date object argument

    :param dt: the date object
    :return: the JD result
    """
    yr, mon, day, hr, min, sec = dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second
    jd = 367.0 * yr - m.floor(
        (7 * (yr + m.floor((mon + 9) / 12.0))) * 0.25) + m.floor(
        275 * mon / 9.0) + day + 1721013.5 + (
                                                 (sec / 60.0 + min) / 60.0 + hr) / 24.0
    return jd

以下是一个客户端代码示例：

client.py

import datetime
import jday
import jday2

# The date we are interested in
a = dict(year=2015, month=12, day=1, hour=22, minute=8, second=0)
dt = datetime.datetime(**a)  # 2015-12-01 22:08:00

# The original signature of the function
jdate1 = jday.JD(a['year'], a["month"], a["day"], a["hour"], a["minute"], a["second"])
# 2457358.422222222

# The new signature that accepts a normal date object
# Note that we use keyword "date" argument
jdate2 = jday.JD(date=dt)
# 2457358.422222222

# The new signature that accepts a normal date object
jdate3 = jday2.JD(dt)
# 2457358.422222222

- arcseldon

---

我需要更多地了解装饰器的概念，但我认为这就是我希望做的。将jday函数更改为接受日期对象。谢谢。 - Jesse Reich

@JesseReich - 请您标记此回答为已接受的答案 :) 装饰器是使用“面向方面编程”（AOP）的绝佳方式，可以在不实际更改函数本身的情况下添加/修改给定函数的现有行为。这取决于您的需求 - 如果您没有理由支持两种函数参数类型，则只需修改现有的JD签名以接受日期对象，并从该日期对象中解析出所需的参数即可。 - arcseldon

@JesseReich - 我刚刚更新了答案（终于...），包括一个单独的jday2.py模块，如果你认为装饰器对你来说太多了，那么这可能是你所需要的。 - arcseldon

Answer 2

您可以将其重写而无需使用math.floor()函数：

def jdate(year, month, day, hour, minute, second):
    day_fraction = ((second + 60 * minute) + 3600 * hour) / 86400.
    return (367 * year - (7 * (year + (month + 9) // 12)) // 4 +
            275 * month // 9 + day + (1721013.5 + day_fraction))

你可以简化它；如果你使用datetime算术：

#!/usr/bin/env python3
from datetime import datetime, timedelta

DAY = timedelta(1)
JULIAN_EPOCH = datetime(2000, 1, 1, 12)  # noon (the epoch name is unrelated)
J2000_JD = timedelta(2451545)  # julian epoch in julian dates

def JD(dt):
    """Julian Date: JD(UTC)."""
    return (dt - JULIAN_EPOCH + J2000_JD) / DAY

为了将一个datetime对象传递给jdate()，您可以使用.timetuple()方法：

import math

for time_tuple in [(1961, 1, 1), (1968, 2, 1), (1972, 1, 1), (1996, 1, 1)]:
    dt = datetime(*time_tuple)
    a, b = jdate(*dt.timetuple()[: 6]), JD(dt)
    print("{} UTC -> {} JD(UTC)".format(dt, b))
    assert math.isclose(a, b), (a, b)

此外，如有需要，您可以使用dt.year，dt.month，dt.day等属性。

输出

1961-01-01 00:00:00 UTC -> 2437300.5 JD(UTC)
1968-02-01 00:00:00 UTC -> 2439887.5 JD(UTC)
1972-01-01 00:00:00 UTC -> 2441317.5 JD(UTC)
1996-01-01 00:00:00 UTC -> 2450083.5 JD(UTC)

根据国际地球自转事务中心提供的建议“儒略日”定义，这是正确的。

---

这些公式在1900年3月之前和2100年2月之后的日期产生不同的结果：

import jdcal  # pip install jdcal
import astropy.time  # pip install astropy

print("                UTC |    matlab |  datetime |   astropy | jdcal")
for year in [1900, 2000, 2100]:
    for time_tuple in [(year, 2, 28, 12), (year, 3, 1, 12)]:
        dt = datetime(*time_tuple)
        matlabJD = jdate(*dt.timetuple()[:6])
        datetimeJD = JD(dt)
        jdcalJD = sum(jdcal.gcal2jd(*dt.timetuple()[:3])) + .5
        astropyJD = astropy.time.Time(dt)
        print("{dt} | {matlabJD} | {datetimeJD} | {astropyJD.jd} | {jdcalJD}"
              .format(**vars()))

输出

                UTC |    matlab |  datetime |   astropy | jdcal
1900-02-28 12:00:00 | 2415078.0 | 2415079.0 | 2415079.0 | 2415079.0
1900-03-01 12:00:00 | 2415080.0 | 2415080.0 | 2415080.0 | 2415080.0
2000-02-28 12:00:00 | 2451603.0 | 2451603.0 | 2451603.0 | 2451603.0
2000-03-01 12:00:00 | 2451605.0 | 2451605.0 | 2451605.0 | 2451605.0
2100-02-28 12:00:00 | 2488128.0 | 2488128.0 | 2488128.0 | 2488128.0
2100-03-01 12:00:00 | 2488130.0 | 2488129.0 | 2488129.0 | 2488129.0

jdate()公式认为1900、2100是闰年。在这里，datetime实现、astropy和jdcal库产生相同的结果。

注意：儒略日是一个整数。JD()计算包含一天中分数的儒略日期，详情请参见链接中的定义。

如链接中讨论所述，应使用已有的库并在必要时发送补丁程序，而不是重复造轮子，以避免因闰年、浮点问题、错误的时间刻度、对术语“儒略日”的定义略有差异等简单错误。

- jfs

---

在卫星轨道分析中，一秒钟的时间差异可能具有重要意义，而且根据计算的细节，可能会选择几种不同的时间尺度。无论最终选择哪种解决方案，输出都应该正确标注时间尺度。如果简单地标记为“UTC”，那么接收输出的人会产生怀疑，因为各种试图支持儒略日的软件库对闰秒的处理方式不同。 - Gerard Ashton

@GerardAshton：UTC 在我的回答中指协调世界时。请点击回答中的 IERS 链接。 - jfs

AJ.F. Sebastian: [一个IAU来源] http://www.iausofa.org/sofa_ts_c.pdf 表明UTC始于1960年，因此将1900年的输出标记为UTC本身就很可疑。 - Gerard Ashton

@GerardAshton：1900年的目的是为了比较不同的实现方式：这个差异是一个整整的一天，远远大于任何时间尺度之间的差异（如UT1、TAI）。 - jfs

@GerardAshton：如果您需要亚秒级别的精度，那么建议使用统一时间标准（如GPS），正如IERS链接中所推荐的那样。UTC是非统一的（由于闰秒）。 - jfs

Answer 3

很遗憾，您不能直接将日期时间对象传递给期望整数的函数。您不能使用日期时间提供的字段调用该函数吗？

now = datetime.now()
jdatenow = jday.JD(now.year, now.month, now.day, now.hour, now.minute, now.second)

如果那太麻烦的话，就把它包起来：

from datetime import datetime

def my_JD(dt):
    return jday.JD(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)
jdatenow = my_JD(datetime.now())

这可能比较容易理解，不需要解释。

jdatenow = jday.JD(*list(datetime.now().timetuple())[:-3])

- Aaron B

---

好的，确实不太了解Python或日期时间，无法以那种方式使用这些字段。谢谢。 - Jesse Reich

Answer 4

我能想到的最简短的方法是：

现在 = list(datetime.datetime.now().timetuple())[:-3]

- Alex