Python sxtwl库详解：轻松实现农历与公历转换的实用工具

pip install sxtwl

import sxtwl
print(sxtwl.__version__)

import sxtwl

# 创建一个公历日期对象，参数分别为年、月、日
# 这里以2023年10月1日为例
g_date = sxtwl.fromSolar(2023, 10, 1)

# 获取农历信息
# 农历年
l_year = g_date.getLunarYear()
# 农历月（如果是闰月，会在月份前加一个'闰'字，这里用数字表示，闰月则月份为负数，如闰二月表示为-2）
l_month = g_date.getLunarMonth()
# 农历日
l_day = g_date.getLunarDay()
# 是否为闰月
is_leap = g_date.isLeap()

print(f"公历2023年10月1日对应的农历是：{l_year}年{'闰' if is_leap else ''}{abs(l_month)}月{l_day}日")

# 获取干支信息
gan_zhi_year = g_date.getGanZhiYear()  # 年干支
gan_zhi_month = g_date.getGanZhiMonth()  # 月干支
gan_zhi_day = g_date.getGanZhiDay()  # 日干支
print(f"年干支：{gan_zhi_year}，月干支：{gan_zhi_month}，日干支：{gan_zhi_day}")

# 获取生肖
shengxiao = g_date.getShengXiao()
print(f"生肖：{shengxiao}")

公历2023年10月1日对应的农历是：2023年八月十七日
年干支：癸卯，月干支：辛酉，日干支：庚辰
生肖：兔

import sxtwl

# 测试2000年2月29日（闰年）
date1 = sxtwl.fromSolar(2000, 2, 29)
print(f"公历2000年2月29日对应的农历是：{date1.getLunarYear()}年{'闰' if date1.isLeap() else ''}{abs(date1.getLunarMonth())}月{date1.getLunarDay()}日")

# 测试2012年1月23日（春节附近）
date2 = sxtwl.fromSolar(2012, 1, 23)
print(f"公历2012年1月23日对应的农历是：{date2.getLunarYear()}年{'闰' if date2.isLeap() else ''}{abs(date2.getLunarMonth())}月{date2.getLunarDay()}日")

# 测试2020年4月4日（清明节）
date3 = sxtwl.fromSolar(2020, 4, 4)
print(f"公历2020年4月4日对应的农历是：{date3.getLunarYear()}年{'闰' if date3.isLeap() else ''}{abs(date3.getLunarMonth())}月{date3.getLunarDay()}日")

import sxtwl

# 农历2023年八月十七日对应的公历日期
# 参数分别为农历年、农历月、农历日、是否为闰月（0表示不是闰月，1表示是闰月）
l_date = sxtwl.fromLunar(2023, 8, 17, 0)

# 获取公历信息
g_year = l_date.getSolarYear()
g_month = l_date.getSolarMonth()
g_day = l_date.getSolarDay()

print(f"农历2023年八月十七日对应的公历是：{g_year}年{g_month}月{g_day}日")

农历2023年八月十七日对应的公历是：2023年10月1日

import sxtwl

# 农历2020年闰四月初五对应的公历日期
l_date_leap = sxtwl.fromLunar(2020, 4, 5, 1)
g_year_leap = l_date_leap.getSolarYear()
g_month_leap = l_date_leap.getSolarMonth()
g_day_leap = l_date_leap.getSolarDay()
print(f"农历2020年闰四月初五对应的公历是：{g_year_leap}年{g_month_leap}月{g_day_leap}日")

# 农历2020年四月初五对应的公历日期（非闰月）
l_date_normal = sxtwl.fromLunar(2020, 4, 5, 0)
g_year_normal = l_date_normal.getSolarYear()
g_month_normal = l_date_normal.getSolarMonth()
g_day_normal = l_date_normal.getSolarDay()
print(f"农历2020年四月初五对应的公历是：{g_year_normal}年{g_month_normal}月{g_day_normal}日")

import sxtwl

year = 2023
# 获取指定年份的所有节气
terms = sxtwl.getYearTerms(year)

print(f"{year}年的二十四节气如下：")
for i in range(0, len(terms), 2):
    # 每个节气包含名称和对应的公历日期（月、日）
    term_name = terms[i]
    month = terms[i+1]
    day = terms[i+2] if i+2 < len(terms) else ""
    # 注意：实际返回的terms结构可能需要根据库的具体实现调整，这里仅为示例
    print(f"{term_name}：{month}月{day}日")

import sxtwl

# 以2023年6月1日为例，查询该日期前后的节气
date = sxtwl.fromSolar(2023, 6, 1)

# 获取该日期之后的第一个节气
next_term = date.getNextTerm()
print(f"2023年6月1日之后的第一个节气是：{next_term.getName()}，时间是{next_term.getSolarYear()}年{next_term.getSolarMonth()}月{next_term.getSolarDay()}日")

# 获取该日期之前的最后一个节气
prev_term = date.getPrevTerm()
print(f"2023年6月1日之前的最后一个节气是：{prev_term.getName()}，时间是{prev_term.getSolarYear()}年{prev_term.getSolarMonth()}月{prev_term.getSolarDay()}日")

import sxtwl

# 以2023年10月1日为例
date = sxtwl.fromSolar(2023, 10, 1)

# 获取年干支
year_ganzhi = date.getGanZhiYear()
print(f"2023年10月1日的年干支是：{year_ganzhi}")

# 获取月干支
month_ganzhi = date.getGanZhiMonth()
print(f"2023年10月1日的月干支是：{month_ganzhi}")

# 获取日干支
day_ganzhi = date.getGanZhiDay()
print(f"2023年10月1日的日干支是：{day_ganzhi}")

import sxtwl

# 查询不同年份的生肖
years = [2020, 2021, 2022, 2023, 2024, 2025]
for year in years:
    # 任意取该年的一天创建日期对象
    date = sxtwl.fromSolar(year, 1, 1)
    shengxiao = date.getShengXiao()
    print(f"{year}年的生肖是：{shengxiao}")

import sxtwl

# 定义一个包含多个公历日期的列表，每个元素为（年、月、日）
solar_dates = [
    (2023, 1, 1),
    (2023, 2, 14),
    (2023, 5, 1),
    (2023, 10, 1),
    (2024, 2, 10)
]

print("批量公历转农历结果：")
for date in solar_dates:
    year, month, day = date
    g_date = sxtwl.fromSolar(year, month, day)
    l_year = g_date.getLunarYear()
    l_month = g_date.getLunarMonth()
    l_day = g_date.getLunarDay()
    is_leap = g_date.isLeap()
    print(f"公历{year}年{month}月{day}日 -> 农历{l_year}年{'闰' if is_leap else ''}{abs(l_month)}月{l_day}日")

import sxtwl

def is_date_valid(year, month, day, is_lunar=False):
    """
    检查日期是否在sxtwl库支持的范围内
    :param year: 年
    :param month: 月
    :param day: 日
    :param is_lunar: 是否为农历日期，True为农历，False为公历
    :return: 布尔值，True表示有效，False表示无效
    """
    try:
        if is_lunar:
            # 尝试创建农历日期对象，如果出错则说明日期无效
            sxtwl.fromLunar(year, month, day, 0)
            # 检查闰月情况
            if month < 0:
                sxtwl.fromLunar(year, abs(month), day, 1)
        else:
            # 尝试创建公历日期对象，如果出错则说明日期无效
            sxtwl.fromSolar(year, month, day)
        return True
    except:
        return False

# 测试一些日期
test_dates = [
    (2000, 2, 29, False),  # 公历2000年2月29日（有效）
    (2023, 13, 1, False),  # 公历2023年13月1日（无效）
    (2023, 2, 30, False),  # 公历2023年2月30日（无效）
    (2023, 8, 17, True),   # 农历2023年8月17日（有效）
    (2023, 13, 1, True),   # 农历2023年13月1日（无效）
    (2023, 2, 30, True)    # 农历2023年2月30日（无效）
]

for date in test_dates:
    year, month, day, is_lunar = date
    date_type = "农历" if is_lunar else "公历"
    if is_date_valid(year, month, day, is_lunar):
        print(f"{date_type}{year}年{month}月{day}日 是有效的日期")
    else:
        print(f"{date_type}{year}年{month}月{day}日 是无效的日期")

import sxtwl
import calendar

def generate_lunar_calendar(year, month):
    """
    生成包含农历信息的月历
    :param year: 公历年
    :param month: 公历月
    :return: 包含农历信息的月历字符串
    """
    # 获取该月的公历日历
    cal = calendar.monthcalendar(year, month)
    lunar_cal = []

    # 添加月份标题
    lunar_cal.append(f"====== {year}年{month}月 日历 ======")
    lunar_cal.append("日 一 二 三 四 五 六")

    for week in cal:
        week_str = ""
        for day in week:
            if day == 0:
                # 不是当月的日期
                week_str += "   "
            else:
                # 获取对应的农历信息
                g_date = sxtwl.fromSolar(year, month, day)
                l_day = g_date.getLunarDay()
                # 只显示农历日，不足两位的补空格
                l_day_str = f"{l_day:2d}"
                week_str += f"{l_day_str} "
        lunar_cal.append(week_str)

    return "\n".join(lunar_cal)

# 生成2023年10月的包含农历的日历
lunar_calendar = generate_lunar_calendar(2023, 10)
print(lunar_calendar)

import sxtwl
from datetime import datetime, timedelta

# 定义一些传统节日（农历）
traditional_festivals = {
    (1, 1): "春节",
    (1, 15): "元宵节",
    (5, 5): "端午节",
    (7, 7): "七夕节",
    (8, 15): "中秋节",
    (9, 9): "重阳节",
    (12, 8): "腊八节",
    (12, 23): "小年"
}

def get_upcoming_festivals(days=30):
    """
    获取未来指定天数内的传统节日
    :param days: 未来的天数
    :return: 包含节日信息的列表
    """
    upcoming_festivals = []
    today = datetime.now()

    for i in range(days + 1):
        # 计算未来i天的日期
        future_date = today + timedelta(days=i)
        year = future_date.year
        month = future_date.month
        day = future_date.day

        # 转换为农历日期
        g_date = sxtwl.fromSolar(year, month, day)
        l_month = g_date.getLunarMonth()
        l_day = g_date.getLunarDay()
        # 处理闰月，这里只考虑农历月份，不区分是否为闰月
        l_month_abs = abs(l_month)

        # 检查是否为传统节日
        for (fest_month, fest_day), fest_name in traditional_festivals.items():
            if l_month_abs == fest_month and l_day == fest_day:
                upcoming_festivals.append({
                    "date": future_date.strftime("%Y年%m月%d日"),
                    "lunar_date": f"{g_date.getLunarYear()}年{'闰' if g_date.isLeap() else ''}{l_month_abs}月{l_day}日",
                    "festival": fest_name
                })

    return upcoming_festivals

# 获取未来30天内的传统节日
upcoming = get_upcoming_festivals(30)
if upcoming:
    print("未来30天内的传统节日有：")
    for item in upcoming:
        print(f"{item['date']}（{item['lunar_date']}）：{item['festival']}")
else:
    print("未来30天内没有传统节日")

import sxtwl

def query_birthday_lunar(year, month, day, is_lunar=True):
    """
    查询出生日期的农历或公历信息
    :param year: 年
    :param month: 月
    :param day: 日
    :param is_lunar: 是否为农历生日，True为农历，False为公历
    :return: 对应的公历或农历信息
    """
    if is_lunar:
        # 农历转公历
        try:
            l_date = sxtwl.fromLunar(year, month, day, 0)
            # 检查是否为闰月
            if month < 0:
                l_date = sxtwl.fromLunar(year, abs(month), day, 1)
            g_year = l_date.getSolarYear()
            g_month = l_date.getSolarMonth()
            g_day = l_date.getSolarDay()
            return f"农历{year}年{'闰' if month < 0 else ''}{abs(month)}月{day}日对应的公历日期是：{g_year}年{g_month}月{g_day}日"
        except:
            return "输入的农历日期无效"
    else:
        # 公历转农历
        try:
            g_date = sxtwl.fromSolar(year, month, day)
            l_year = g_date.getLunarYear()
            l_month = g_date.getLunarMonth()
            l_day = g_date.getLunarDay()
            return f"公历{year}年{month}月{day}日对应的农历日期是：{l_year}年{'闰' if g_date.isLeap() else ''}{abs(l_month)}月{l_day}日"
        except:
            return "输入的公历日期无效"

# 测试示例
print(query_birthday_lunar(1990, 1, 1, True))  # 农历1990年1月1日对应的公历
print(query_birthday_lunar(1990, 1, 27, False))  # 公历1990年1月27日对应的农历
print(query_birthday_lunar(2000, 2, 30, False))  # 无效的公历日期
print(query_birthday_lunar(2023, 13, 1, True))  # 无效的农历日期

import sxtwl
from datetime import datetime

# 定义每个节气对应的农业生产建议
solar_term_advice = {
    "立春": "开始备耕，做好春耕准备，及时灌溉，防治病虫害。",
    "雨水": "小麦进入返青期，要及时施肥、中耕除草；南方要注意防涝。",
    "惊蛰": "气温回升，万物复苏，是春耕大忙的开始，要及时播种春作物。",
    "春分": "小麦拔节，油菜抽苔，要加强田间管理，追施肥料。",
    "清明": "北方春播进入高峰期，南方开始插秧；注意森林防火。",
    "谷雨": "水稻、玉米等春播作物进入播种旺季，要抓住时机播种。",
    "立夏": "作物进入生长旺季，要加强田间管理，防治病虫害。",
    "小满": "北方麦类作物进入灌浆期，南方夏收作物即将成熟，要做好收割准备。",
    "芒种": "夏收、夏种、夏管“三夏”大忙季节，要抢收抢种。",
    "夏至": "光照时间最长，作物生长旺盛，要注意浇水、施肥，防止干旱。",
    "小暑": "进入高温季节，要加强作物田间管理，防治高温热害。",
    "大暑": "一年中最热的时期，要注意防暑降温，同时加强作物抗旱。",
    "立秋": "作物开始成熟，要做好秋收准备；北方开始播种秋作物。",
    "处暑": "气温开始下降，秋作物进入生长后期，要加强管理，促进成熟。",
    "白露": "早晚温差大，要注意防霜冻；秋播作物开始播种。",
    "秋分": "秋收、秋耕、秋种“三秋”大忙，要抓紧时间收获成熟作物。",
    "寒露": "气温继续下降，要注意农作物防寒保暖；北方开始结冰。",
    "霜降": "开始出现霜冻，要做好农作物防冻工作，及时收获蔬菜等作物。",
    "立冬": "进入冬季，要做好农作物越冬准备，加强畜禽保暖。",
    "小雪": "北方开始降雪，要做好防寒保暖和积雪清理工作。",
    "大雪": "气温显著下降，降雪增多，要注意保护农作物和畜禽安全越冬。",
    "冬至": "白昼最短，黑夜最长，此后白昼渐长；要做好防寒防冻工作。",
    "小寒": "气候寒冷，要注意保暖，防止农作物和畜禽受冻。",
    "大寒": "一年中最冷的时期，要加强防寒保暖措施，确保农作物和畜禽安全越冬。"
}

def get_solar_term_agricultural_advice():
    """
    获取当前日期所在节气的农业生产建议
    :return: 节气名称和对应的建议
    """
    today = datetime.now()
    g_date = sxtwl.fromSolar(today.year, today.month, today.day)

    # 获取当前日期所在的节气
    prev_term = g_date.getPrevTerm()
    next_term = g_date.getNextTerm()

    # 判断当前日期更接近哪个节气，或者是否在节气当天
    today_date = datetime(today.year, today.month, today.day)
    prev_term_date = datetime(prev_term.getSolarYear(), prev_term.getSolarMonth(), prev_term.getSolarDay())
    next_term_date = datetime(next_term.getSolarYear(), next_term.getSolarMonth(), next_term.getSolarDay())

    if today_date == prev_term_date:
        current_term = prev_term.getName()
    elif today_date == next_term_date:
        current_term = next_term.getName()
    else:
        # 比较距离前后节气的天数
        days_to_prev = (today_date - prev_term_date).days
        days_to_next = (next_term_date - today_date).days
        current_term = prev_term.getName() if days_to_prev < days_to_next else next_term.getName()

    advice = solar_term_advice.get(current_term, "当前节气没有特别的农业生产建议。")
    return f"当前临近{current_term}，农业生产建议：{advice}"

# 获取当前的农业生产建议
advice = get_solar_term_agricultural_advice()
print(advice)