将UT（世界时）转换为JD（儒略日）的Python代码问题排查

Hey there! Let's troubleshoot your UT to JD conversion issue together. It’s super common to hit snags with date conversions—let’s break down the problem and fix it step by step.

The standard formula for converting a Gregorian date (with UT time) to Julian Day (JD) accounts for the fact that JD counts days starting at noon UTC, and adjusts for early-year months. Here’s the breakdown:

1. If the month is January or February, subtract 1 from the year and add 12 to the month (since these are treated as months 13 and 14 of the previous year in the formula).
2. Calculate adjustment terms for the Gregorian calendar:
   • A = floor(year / 100)
   • B = 2 - A + floor(A / 4)
3. Compute the base JD for the date (without time):
   JD_base = floor(365.25 * (year + 4716)) + floor(30.6001 * (month + 1)) + day + B - 1524.5
4. Add the fractional day from the UT time:
   fractional_day = (hours + minutes / 60) / 24
final_JD = JD_base + fractional_day

Chances are your code is missing one of these critical steps:

• Incorrect date parsing: Your dates use MM/DD/YYYY format—if you accidentally parse them as DD/MM/YYYY, every date will be shifted, leading to wildly wrong JD values.
• Skipping month/year adjustment: For January/February dates, failing to adjust the year and month will throw off the base JD calculation.
• Time conversion errors: Forgetting to convert minutes to a fraction of an hour, or dividing by 100 instead of 60, will mess up the fractional day.
• Using integer truncation instead of floor: int() in Python truncates towards zero, which works for positive numbers here, but math.floor() is safer (and matches the formula’s intent).

Here’s a tested implementation that fixes these pitfalls, using datetime to safely parse your date strings:

import math
from datetime import datetime

def ut_to_jd(ut_datetime_str):
    # Parse the input string (format: 'MM/DD/YYYY HH:MM')
    dt = datetime.strptime(ut_datetime_str, '%m/%d/%Y %H:%M')
    year, month, day = dt.year, dt.month, dt.day
    hour, minute = dt.hour, dt.minute
    
    # Adjust for Jan/Feb being months 13/14 of the previous year
    if month < 3:
        year -= 1
        month += 12
    
    # Calculate Gregorian adjustment terms
    A = math.floor(year / 100)
    B = 2 - A + math.floor(A / 4)
    
    # Base JD calculation (date only)
    jd_base = math.floor(365.25 * (year + 4716)) + math.floor(30.6001 * (month + 1)) + day + B - 1524.5
    
    # Add fractional day from UT time
    fractional_day = (hour + minute / 60) / 24
    final_jd = jd_base + fractional_day
    
    return final_jd

# Test with your sample dates
dates = [
    '4/01/2018 01:06', '4/01/2018 01:10', '4/09/2018 00:37',
    '4/09/2018 00:41', '4/22/2018 00:28', '4/22/2018 00:33',
    '4/22/2018 00:37', '4/24/2018 00:40', '4/24/2018 00:44',
    '4/24/2018 00:51'
]

for date_str in dates:
    jd = ut_to_jd(date_str)
    print(f"UT: {date_str} → JD: {jd:.6f}")

For your first test date 4/01/2018 01:06, the correct JD is 2458209.545833. If you run the code, that’s exactly what you’ll get—this matches verified JD calculators.

If your original code was missing the month/year adjustment or parsed dates incorrectly, switching to this implementation should fix the issue.

内容的提问来源于stack exchange，提问作者Billiam