Spaces:
Running
Running
| # -*- coding: utf-8 -*- | |
| from . import Solar, NineStar, EightChar, JieQi, ShuJiu, Fu, LunarTime | |
| from .util import LunarUtil, SolarUtil | |
| class Lunar: | |
| """ | |
| 阴历日期 | |
| """ | |
| JIE_QI = ("冬至", "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", "小满", "芒种", "夏至", "小暑", "大暑", "立秋", "处暑", "白露", "秋分", "寒露", "霜降", "立冬", "小雪", "大雪") | |
| JIE_QI_IN_USE = ("DA_XUE", "冬至", "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", "小满", "芒种", "夏至", "小暑", "大暑", "立秋", "处暑", "白露", "秋分", "寒露", "霜降", "立冬", "小雪", "大雪", "DONG_ZHI", "XIAO_HAN", "DA_HAN", "LI_CHUN", "YU_SHUI", "JING_ZHE") | |
| def __init__(self, lunar_year: int, lunar_month: int, lunar_day: int, hour: int, minute: int, second: int): | |
| from . import LunarYear | |
| y = LunarYear.fromYear(lunar_year) | |
| m = y.getMonth(lunar_month) | |
| if m is None: | |
| raise Exception("wrong lunar year %d month %d" % (lunar_year, lunar_month)) | |
| if lunar_day < 1: | |
| raise Exception("lunar day must bigger than 0") | |
| days = m.getDayCount() | |
| if lunar_day > days: | |
| raise Exception("only %d days in lunar year %d month %d" % (days, lunar_year, lunar_month)) | |
| self.__year = lunar_year | |
| self.__month = lunar_month | |
| self.__day = lunar_day | |
| self.__hour = hour | |
| self.__minute = minute | |
| self.__second = second | |
| self.__jieQi = {} | |
| self.__jieQiList = [] | |
| self.__eightChar = None | |
| noon = Solar.fromJulianDay(m.getFirstJulianDay() + lunar_day - 1) | |
| self.__solar = Solar.fromYmdHms(noon.getYear(), noon.getMonth(), noon.getDay(), hour, minute, second) | |
| if noon.getYear() != lunar_year: | |
| y = LunarYear.fromYear(noon.getYear()) | |
| self.__compute(y) | |
| def __compute(self, y): | |
| self.__computeJieQi(y) | |
| self.__computeYear() | |
| self.__computeMonth() | |
| self.__computeDay() | |
| self.__computeTime() | |
| self.__computeWeek() | |
| def __computeJieQi(self, y): | |
| julian_days = y.getJieQiJulianDays() | |
| for i in range(0, len(Lunar.JIE_QI_IN_USE)): | |
| name = Lunar.JIE_QI_IN_USE[i] | |
| self.__jieQi[name] = Solar.fromJulianDay(julian_days[i]) | |
| self.__jieQiList.append(name) | |
| def __computeYear(self): | |
| # 以正月初一开始 | |
| offset = self.__year - 4 | |
| year_gan_index = offset % 10 | |
| year_zhi_index = offset % 12 | |
| if year_gan_index < 0: | |
| year_gan_index += 10 | |
| if year_zhi_index < 0: | |
| year_zhi_index += 12 | |
| # 以立春作为新一年的开始的干支纪年 | |
| g = year_gan_index | |
| z = year_zhi_index | |
| # 精确的干支纪年，以立春交接时刻为准 | |
| g_exact = year_gan_index | |
| z_exact = year_zhi_index | |
| solar_year = self.__solar.getYear() | |
| solar_ymd = self.__solar.toYmd() | |
| solar_ymd_hms = self.__solar.toYmdHms() | |
| # 获取立春的阳历时刻 | |
| li_chun = self.__jieQi["立春"] | |
| if li_chun.getYear() != solar_year: | |
| li_chun = self.__jieQi["LI_CHUN"] | |
| li_chun_ymd = li_chun.toYmd() | |
| li_chun_ymd_hms = li_chun.toYmdHms() | |
| # 阳历和阴历年份相同代表正月初一及以后 | |
| if self.__year == solar_year: | |
| # 立春日期判断 | |
| if solar_ymd < li_chun_ymd: | |
| g -= 1 | |
| z -= 1 | |
| # 立春交接时刻判断 | |
| if solar_ymd_hms < li_chun_ymd_hms: | |
| g_exact -= 1 | |
| z_exact -= 1 | |
| elif self.__year < solar_year: | |
| if solar_ymd >= li_chun_ymd: | |
| g += 1 | |
| z += 1 | |
| if solar_ymd_hms >= li_chun_ymd_hms: | |
| g_exact += 1 | |
| z_exact += 1 | |
| self.__yearGanIndex = year_gan_index | |
| self.__yearZhiIndex = year_zhi_index | |
| self.__yearGanIndexByLiChun = (g + 10 if g < 0 else g) % 10 | |
| self.__yearZhiIndexByLiChun = (z + 12 if z < 0 else z) % 12 | |
| self.__yearGanIndexExact = (g_exact + 10 if g_exact < 0 else g_exact) % 10 | |
| self.__yearZhiIndexExact = (z_exact + 12 if z_exact < 0 else z_exact) % 12 | |
| def __computeMonth(self): | |
| ymd = self.__solar.toYmd() | |
| time = self.__solar.toYmdHms() | |
| size = len(Lunar.JIE_QI_IN_USE) | |
| # 序号：大雪以前-3，大雪到小寒之间-2，小寒到立春之间-1，立春之后0 | |
| index = -3 | |
| start = None | |
| for i in range(0, size, 2): | |
| end = self.__jieQi[Lunar.JIE_QI_IN_USE[i]] | |
| symd = ymd if start is None else start.toYmd() | |
| if symd <= ymd < end.toYmd(): | |
| break | |
| start = end | |
| index += 1 | |
| # 干偏移值（以立春当天起算） | |
| g_offset = (((self.__yearGanIndexByLiChun + (1 if index < 0 else 0)) % 5 + 1) * 2) % 10 | |
| self.__monthGanIndex = ((index + 10 if index < 0 else index) + g_offset) % 10 | |
| self.__monthZhiIndex = ((index + 12 if index < 0 else index) + LunarUtil.BASE_MONTH_ZHI_INDEX) % 12 | |
| index = -3 | |
| start = None | |
| for i in range(0, size, 2): | |
| end = self.__jieQi[Lunar.JIE_QI_IN_USE[i]] | |
| stime = time if start is None else start.toYmdHms() | |
| if stime <= time < end.toYmdHms(): | |
| break | |
| start = end | |
| index += 1 | |
| # 干偏移值（以立春交接时刻起算） | |
| g_offset = (((self.__yearGanIndexExact + (1 if index < 0 else 0)) % 5 + 1) * 2) % 10 | |
| self.__monthGanIndexExact = ((index + 10 if index < 0 else index) + g_offset) % 10 | |
| self.__monthZhiIndexExact = ((index + 12 if index < 0 else index) + LunarUtil.BASE_MONTH_ZHI_INDEX) % 12 | |
| def __computeDay(self): | |
| noon = Solar.fromYmdHms(self.__solar.getYear(), self.__solar.getMonth(), self.__solar.getDay(), 12, 0, 0) | |
| offset = int(noon.getJulianDay()) - 11 | |
| day_gan_index = offset % 10 | |
| day_zhi_index = offset % 12 | |
| self.__dayGanIndex = day_gan_index | |
| self.__dayZhiIndex = day_zhi_index | |
| day_gan_exact = day_gan_index | |
| day_zhi_exact = day_zhi_index | |
| # 八字流派2，晚子时（夜子/子夜）日柱算当天 | |
| self.__dayGanIndexExact2 = day_gan_exact | |
| self.__dayZhiIndexExact2 = day_zhi_exact | |
| # 八字流派1，晚子时（夜子/子夜）日柱算明天 | |
| hm = ("0" if self.__hour < 10 else "") + str(self.__hour) + ":" + ("0" if self.__minute < 10 else "") + str(self.__minute) | |
| if "23:00" <= hm <= "23:59": | |
| day_gan_exact += 1 | |
| if day_gan_exact >= 10: | |
| day_gan_exact -= 10 | |
| day_zhi_exact += 1 | |
| if day_zhi_exact >= 12: | |
| day_zhi_exact -= 12 | |
| self.__dayGanIndexExact = day_gan_exact | |
| self.__dayZhiIndexExact = day_zhi_exact | |
| def __computeTime(self): | |
| time_zhi_index = LunarUtil.getTimeZhiIndex(("0" if self.__hour < 10 else "") + str(self.__hour) + ":" + ("0" if self.__minute < 10 else "") + str(self.__minute)) | |
| self.__timeZhiIndex = time_zhi_index | |
| self.__timeGanIndex = (self.__dayGanIndexExact % 5 * 2 + time_zhi_index) % 10 | |
| def __computeWeek(self): | |
| self.__weekIndex = self.__solar.getWeek() | |
| def fromYmdHms(lunar_year, lunar_month, lunar_day, hour, minute, second): | |
| return Lunar(lunar_year, lunar_month, lunar_day, hour, minute, second) | |
| def fromYmd(lunar_year, lunar_month, lunar_day): | |
| return Lunar(lunar_year, lunar_month, lunar_day, 0, 0, 0) | |
| def fromDate(date): | |
| return Lunar.fromSolar(Solar.fromDate(date)) | |
| def fromSolar(solar): | |
| from . import LunarYear | |
| year = 0 | |
| month = 0 | |
| day = 0 | |
| ly = LunarYear.fromYear(solar.getYear()) | |
| for m in ly.getMonths(): | |
| days = solar.subtract(Solar.fromJulianDay(m.getFirstJulianDay())) | |
| if days < m.getDayCount(): | |
| year = m.getYear() | |
| month = m.getMonth() | |
| day = days + 1 | |
| break | |
| return Lunar(year, month, day, solar.getHour(), solar.getMinute(), solar.getSecond()) | |
| def getYear(self): | |
| return self.__year | |
| def getMonth(self): | |
| return self.__month | |
| def getDay(self): | |
| return self.__day | |
| def getHour(self): | |
| return self.__hour | |
| def getMinute(self): | |
| return self.__minute | |
| def getSecond(self): | |
| return self.__second | |
| def getSolar(self): | |
| return self.__solar | |
| def getYearGan(self): | |
| return LunarUtil.GAN[self.__yearGanIndex + 1] | |
| def getYearGanByLiChun(self): | |
| return LunarUtil.GAN[self.__yearGanIndexByLiChun + 1] | |
| def getYearGanExact(self): | |
| return LunarUtil.GAN[self.__yearGanIndexExact + 1] | |
| def getYearZhi(self): | |
| return LunarUtil.ZHI[self.__yearZhiIndex + 1] | |
| def getYearZhiByLiChun(self): | |
| return LunarUtil.ZHI[self.__yearZhiIndexByLiChun + 1] | |
| def getYearZhiExact(self): | |
| return LunarUtil.ZHI[self.__yearZhiIndexExact + 1] | |
| def getYearInGanZhi(self): | |
| return "%s%s" % (self.getYearGan(), self.getYearZhi()) | |
| def getYearInGanZhiByLiChun(self): | |
| return "%s%s" % (self.getYearGanByLiChun(), self.getYearZhiByLiChun()) | |
| def getYearInGanZhiExact(self): | |
| return "%s%s" % (self.getYearGanExact(), self.getYearZhiExact()) | |
| def getMonthGan(self): | |
| return LunarUtil.GAN[self.__monthGanIndex + 1] | |
| def getMonthGanExact(self): | |
| return LunarUtil.GAN[self.__monthGanIndexExact + 1] | |
| def getMonthZhi(self): | |
| return LunarUtil.ZHI[self.__monthZhiIndex + 1] | |
| def getMonthZhiExact(self): | |
| return LunarUtil.ZHI[self.__monthZhiIndexExact + 1] | |
| def getMonthInGanZhi(self): | |
| return "%s%s" % (self.getMonthGan(), self.getMonthZhi()) | |
| def getMonthInGanZhiExact(self): | |
| return "%s%s" % (self.getMonthGanExact(), self.getMonthZhiExact()) | |
| def getDayGan(self): | |
| return LunarUtil.GAN[self.__dayGanIndex + 1] | |
| def getDayGanExact(self): | |
| return LunarUtil.GAN[self.__dayGanIndexExact + 1] | |
| def getDayGanExact2(self): | |
| return LunarUtil.GAN[self.__dayGanIndexExact2 + 1] | |
| def getDayZhi(self): | |
| return LunarUtil.ZHI[self.__dayZhiIndex + 1] | |
| def getDayZhiExact(self): | |
| return LunarUtil.ZHI[self.__dayZhiIndexExact + 1] | |
| def getDayZhiExact2(self): | |
| return LunarUtil.ZHI[self.__dayZhiIndexExact2 + 1] | |
| def getDayInGanZhi(self): | |
| return "%s%s" % (self.getDayGan(), self.getDayZhi()) | |
| def getDayInGanZhiExact(self): | |
| return "%s%s" % (self.getDayGanExact(), self.getDayZhiExact()) | |
| def getDayInGanZhiExact2(self): | |
| return "%s%s" % (self.getDayGanExact2(), self.getDayZhiExact2()) | |
| def getTimeGan(self): | |
| return LunarUtil.GAN[self.__timeGanIndex + 1] | |
| def getTimeZhi(self): | |
| return LunarUtil.ZHI[self.__timeZhiIndex + 1] | |
| def getTimeInGanZhi(self): | |
| return "%s%s" % (self.getTimeGan(), self.getTimeZhi()) | |
| def getYearShengXiao(self): | |
| return LunarUtil.SHENGXIAO[self.__yearZhiIndex + 1] | |
| def getYearShengXiaoByLiChun(self): | |
| return LunarUtil.SHENGXIAO[self.__yearZhiIndexByLiChun + 1] | |
| def getYearShengXiaoExact(self): | |
| return LunarUtil.SHENGXIAO[self.__yearZhiIndexExact + 1] | |
| def getMonthShengXiao(self): | |
| return LunarUtil.SHENGXIAO[self.__monthZhiIndex + 1] | |
| def getMonthShengXiaoExact(self): | |
| return LunarUtil.SHENGXIAO[self.__monthZhiIndexExact + 1] | |
| def getDayShengXiao(self): | |
| return LunarUtil.SHENGXIAO[self.__dayZhiIndex + 1] | |
| def getTimeShengXiao(self): | |
| return LunarUtil.SHENGXIAO[self.__timeZhiIndex + 1] | |
| def getYearInChinese(self): | |
| y = str(self.__year) | |
| s = "" | |
| for i in range(0, len(y)): | |
| s += LunarUtil.NUMBER[ord(y[i]) - 48] | |
| return s | |
| def getMonthInChinese(self): | |
| month = self.__month | |
| return ("闰" if month < 0 else "") + LunarUtil.MONTH[abs(month)] | |
| def getDayInChinese(self): | |
| return LunarUtil.DAY[self.__day] | |
| def getPengZuGan(self): | |
| return LunarUtil.PENG_ZU_GAN[self.__dayGanIndex + 1] | |
| def getPengZuZhi(self): | |
| return LunarUtil.PENG_ZU_ZHI[self.__dayZhiIndex + 1] | |
| def getPositionXi(self): | |
| return self.getDayPositionXi() | |
| def getPositionXiDesc(self): | |
| return self.getDayPositionXiDesc() | |
| def getPositionYangGui(self): | |
| return self.getDayPositionYangGui() | |
| def getPositionYangGuiDesc(self): | |
| return self.getDayPositionYangGuiDesc() | |
| def getPositionYinGui(self): | |
| return self.getDayPositionYinGui() | |
| def getPositionYinGuiDesc(self): | |
| return self.getDayPositionYinGuiDesc() | |
| def getPositionFu(self): | |
| return self.getDayPositionFu() | |
| def getPositionFuDesc(self): | |
| return self.getDayPositionFuDesc() | |
| def getPositionCai(self): | |
| return self.getDayPositionCai() | |
| def getPositionCaiDesc(self): | |
| return self.getDayPositionCaiDesc() | |
| def getDayPositionXi(self): | |
| return LunarUtil.POSITION_XI[self.__dayGanIndex + 1] | |
| def getDayPositionXiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getDayPositionXi()] | |
| def getDayPositionYangGui(self): | |
| return LunarUtil.POSITION_YANG_GUI[self.__dayGanIndex + 1] | |
| def getDayPositionYangGuiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getDayPositionYangGui()] | |
| def getDayPositionYinGui(self): | |
| return LunarUtil.POSITION_YIN_GUI[self.__dayGanIndex + 1] | |
| def getDayPositionYinGuiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getDayPositionYinGui()] | |
| def getDayPositionFu(self, sect=2): | |
| return (LunarUtil.POSITION_FU if 1 == sect else LunarUtil.POSITION_FU_2)[self.__dayGanIndex + 1] | |
| def getDayPositionFuDesc(self, sect=2): | |
| return LunarUtil.POSITION_DESC[self.getDayPositionFu(sect)] | |
| def getDayPositionCai(self): | |
| return LunarUtil.POSITION_CAI[self.__dayGanIndex + 1] | |
| def getDayPositionCaiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getDayPositionCai()] | |
| def getYearPositionTaiSui(self, sect=2): | |
| if 1 == sect: | |
| year_zhi_index = self.__yearZhiIndex | |
| elif 3 == sect: | |
| year_zhi_index = self.__yearZhiIndexExact | |
| else: | |
| year_zhi_index = self.__yearZhiIndexByLiChun | |
| return LunarUtil.POSITION_TAI_SUI_YEAR[year_zhi_index] | |
| def getYearPositionTaiSuiDesc(self, sect=2): | |
| return LunarUtil.POSITION_DESC[self.getYearPositionTaiSui(sect)] | |
| def __getMonthPositionTaiSui(self, month_zhi_index, month_gan_index): | |
| m = month_zhi_index - LunarUtil.BASE_MONTH_ZHI_INDEX | |
| if m < 0: | |
| m += 12 | |
| m = m % 4 | |
| if 0 == m: | |
| p = "艮" | |
| elif 2 == m: | |
| p = "坤" | |
| elif 3 == m: | |
| p = "巽" | |
| else: | |
| p = LunarUtil.POSITION_GAN[month_gan_index] | |
| return p | |
| def getMonthPositionTaiSui(self, sect=2): | |
| if 3 == sect: | |
| month_zhi_index = self.__monthZhiIndexExact | |
| month_gan_index = self.__monthGanIndexExact | |
| else: | |
| month_zhi_index = self.__monthZhiIndex | |
| month_gan_index = self.__monthGanIndex | |
| return self.__getMonthPositionTaiSui(month_zhi_index, month_gan_index) | |
| def getMonthPositionTaiSuiDesc(self, sect=2): | |
| return LunarUtil.POSITION_DESC[self.getMonthPositionTaiSui(sect)] | |
| def __getDayPositionTaiSui(self, day_in_gan_zhi, year_zhi_index): | |
| if day_in_gan_zhi in "甲子,乙丑,丙寅,丁卯,戊辰,己巳": | |
| p = "震" | |
| elif day_in_gan_zhi in "丙子,丁丑,戊寅,己卯,庚辰,辛巳": | |
| p = "离" | |
| elif day_in_gan_zhi in "戊子,己丑,庚寅,辛卯,壬辰,癸巳": | |
| p = "中" | |
| elif day_in_gan_zhi in "庚子,辛丑,壬寅,癸卯,甲辰,乙巳": | |
| p = "兑" | |
| elif day_in_gan_zhi in "壬子,癸丑,甲寅,乙卯,丙辰,丁巳": | |
| p = "坎" | |
| else: | |
| p = LunarUtil.POSITION_TAI_SUI_YEAR[year_zhi_index] | |
| return p | |
| def getDayPositionTaiSui(self, sect=2): | |
| if 1 == sect: | |
| day_in_gan_zhi = self.getDayInGanZhi() | |
| year_zhi_index = self.__yearZhiIndex | |
| elif 3 == sect: | |
| day_in_gan_zhi = self.getDayInGanZhi() | |
| year_zhi_index = self.__yearZhiIndexExact | |
| else: | |
| day_in_gan_zhi = self.getDayInGanZhiExact2() | |
| year_zhi_index = self.__yearZhiIndexByLiChun | |
| return self.__getDayPositionTaiSui(day_in_gan_zhi, year_zhi_index) | |
| def getDayPositionTaiSuiDesc(self, sect=2): | |
| return LunarUtil.POSITION_DESC[self.getDayPositionTaiSui(sect)] | |
| def getTimePositionXi(self): | |
| return LunarUtil.POSITION_XI[self.__timeGanIndex + 1] | |
| def getTimePositionXiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getTimePositionXi()] | |
| def getTimePositionYangGui(self): | |
| return LunarUtil.POSITION_YANG_GUI[self.__timeGanIndex + 1] | |
| def getTimePositionYangGuiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getTimePositionYangGui()] | |
| def getTimePositionYinGui(self): | |
| return LunarUtil.POSITION_YIN_GUI[self.__timeGanIndex + 1] | |
| def getTimePositionYinGuiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getTimePositionYinGui()] | |
| def getTimePositionFu(self, sect=2): | |
| return (LunarUtil.POSITION_FU if 1 == sect else LunarUtil.POSITION_FU_2)[self.__timeGanIndex + 1] | |
| def getTimePositionFuDesc(self, sect=2): | |
| return LunarUtil.POSITION_DESC[self.getTimePositionFu(sect)] | |
| def getTimePositionCai(self): | |
| return LunarUtil.POSITION_CAI[self.__timeGanIndex + 1] | |
| def getTimePositionCaiDesc(self): | |
| return LunarUtil.POSITION_DESC[self.getTimePositionCai()] | |
| def getChong(self): | |
| return self.getDayChong() | |
| def getDayChong(self): | |
| return LunarUtil.CHONG[self.__dayZhiIndex] | |
| def getTimeChong(self): | |
| return LunarUtil.CHONG[self.__timeZhiIndex] | |
| def getChongGan(self): | |
| return self.getDayChongGan() | |
| def getDayChongGan(self): | |
| return LunarUtil.CHONG_GAN[self.__dayGanIndex] | |
| def getTimeChongGan(self): | |
| return LunarUtil.CHONG_GAN[self.__timeGanIndex] | |
| def getChongGanTie(self): | |
| return self.getDayChongGanTie() | |
| def getDayChongGanTie(self): | |
| return LunarUtil.CHONG_GAN_TIE[self.__dayGanIndex] | |
| def getTimeChongGanTie(self): | |
| return LunarUtil.CHONG_GAN_TIE[self.__timeGanIndex] | |
| def getChongShengXiao(self): | |
| return self.getDayChongShengXiao() | |
| def getDayChongShengXiao(self): | |
| chong = self.getDayChong() | |
| for i in range(0, len(LunarUtil.ZHI)): | |
| if LunarUtil.ZHI[i] == chong: | |
| return LunarUtil.SHENGXIAO[i] | |
| return "" | |
| def getTimeChongShengXiao(self): | |
| chong = self.getTimeChong() | |
| for i in range(0, len(LunarUtil.ZHI)): | |
| if LunarUtil.ZHI[i] == chong: | |
| return LunarUtil.SHENGXIAO[i] | |
| return "" | |
| def getChongDesc(self): | |
| return self.getDayChongDesc() | |
| def getDayChongDesc(self): | |
| return "(" + self.getDayChongGan() + self.getDayChong() + ")" + self.getDayChongShengXiao() | |
| def getTimeChongDesc(self): | |
| return "(" + self.getTimeChongGan() + self.getTimeChong() + ")" + self.getTimeChongShengXiao() | |
| def getSha(self): | |
| return self.getDaySha() | |
| def getDaySha(self): | |
| return LunarUtil.SHA[self.getDayZhi()] | |
| def getTimeSha(self): | |
| return LunarUtil.SHA[self.getTimeZhi()] | |
| def getYearNaYin(self): | |
| return LunarUtil.NAYIN[self.getYearInGanZhi()] | |
| def getMonthNaYin(self): | |
| return LunarUtil.NAYIN[self.getMonthInGanZhi()] | |
| def getDayNaYin(self): | |
| return LunarUtil.NAYIN[self.getDayInGanZhi()] | |
| def getTimeNaYin(self): | |
| return LunarUtil.NAYIN[self.getTimeInGanZhi()] | |
| def getSeason(self): | |
| return LunarUtil.SEASON[abs(self.__month)] | |
| def __convertJieQi(name): | |
| jq = name | |
| if "DONG_ZHI" == jq: | |
| jq = "冬至" | |
| elif "DA_HAN" == jq: | |
| jq = "大寒" | |
| elif "XIAO_HAN" == jq: | |
| jq = "小寒" | |
| elif "LI_CHUN" == jq: | |
| jq = "立春" | |
| elif "DA_XUE" == jq: | |
| jq = "大雪" | |
| elif "YU_SHUI" == jq: | |
| jq = "雨水" | |
| elif "JING_ZHE" == jq: | |
| jq = "惊蛰" | |
| return jq | |
| def getJie(self): | |
| for i in range(0, len(Lunar.JIE_QI_IN_USE), 2): | |
| key = Lunar.JIE_QI_IN_USE[i] | |
| d = self.__jieQi[key] | |
| if d.getYear() == self.__solar.getYear() and d.getMonth() == self.__solar.getMonth() and d.getDay() == self.__solar.getDay(): | |
| return self.__convertJieQi(key) | |
| return "" | |
| def getQi(self): | |
| for i in range(1, len(Lunar.JIE_QI_IN_USE), 2): | |
| key = Lunar.JIE_QI_IN_USE[i] | |
| d = self.__jieQi[key] | |
| if d.getYear() == self.__solar.getYear() and d.getMonth() == self.__solar.getMonth() and d.getDay() == self.__solar.getDay(): | |
| return self.__convertJieQi(key) | |
| return "" | |
| def getWeek(self): | |
| return self.__weekIndex | |
| def getWeekInChinese(self): | |
| return SolarUtil.WEEK[self.getWeek()] | |
| def getXiu(self): | |
| return LunarUtil.XIU[self.getDayZhi() + str(self.getWeek())] | |
| def getXiuLuck(self): | |
| return LunarUtil.XIU_LUCK[self.getXiu()] | |
| def getXiuSong(self): | |
| return LunarUtil.XIU_SONG[self.getXiu()] | |
| def getZheng(self): | |
| return LunarUtil.ZHENG[self.getXiu()] | |
| def getAnimal(self): | |
| return LunarUtil.ANIMAL[self.getXiu()] | |
| def getGong(self): | |
| return LunarUtil.GONG[self.getXiu()] | |
| def getShou(self): | |
| return LunarUtil.SHOU[self.getGong()] | |
| def getFestivals(self): | |
| fs = [] | |
| md = "%d-%d" % (self.__month, self.__day) | |
| if md in LunarUtil.FESTIVAL: | |
| fs.append(LunarUtil.FESTIVAL[md]) | |
| if abs(self.__month) == 12 and self.__day >= 29 and self.__year != self.next(1).getYear(): | |
| fs.append("除夕") | |
| return fs | |
| def getOtherFestivals(self): | |
| arr = [] | |
| md = "%d-%d" % (self.__month, self.__day) | |
| if md in LunarUtil.OTHER_FESTIVAL: | |
| fs = LunarUtil.OTHER_FESTIVAL[md] | |
| for f in fs: | |
| arr.append(f) | |
| solar_ymd = self.__solar.toYmd() | |
| if solar_ymd == self.__jieQi["清明"].next(-1).toYmd(): | |
| arr.append("寒食节") | |
| jq = self.__jieQi["立春"] | |
| offset = 4 - jq.getLunar().getDayGanIndex() | |
| if offset < 0: | |
| offset += 10 | |
| if solar_ymd == jq.next(offset + 40).toYmd(): | |
| arr.append("春社") | |
| jq = self.__jieQi["立秋"] | |
| offset = 4 - jq.getLunar().getDayGanIndex() | |
| if offset < 0: | |
| offset += 10 | |
| if solar_ymd == jq.next(offset + 40).toYmd(): | |
| arr.append("秋社") | |
| return arr | |
| def getEightChar(self): | |
| if self.__eightChar is None: | |
| self.__eightChar = EightChar.fromLunar(self) | |
| return self.__eightChar | |
| def getBaZi(self): | |
| ba_zi = self.getEightChar() | |
| return [ba_zi.getYear(), ba_zi.getMonth(), ba_zi.getDay(), ba_zi.getTime()] | |
| def getBaZiWuXing(self): | |
| ba_zi = self.getEightChar() | |
| return [ba_zi.getYearWuXing(), ba_zi.getMonthWuXing(), ba_zi.getDayWuXing(), ba_zi.getTimeWuXing()] | |
| def getBaZiNaYin(self): | |
| ba_zi = self.getEightChar() | |
| return [ba_zi.getYearNaYin(), ba_zi.getMonthNaYin(), ba_zi.getDayNaYin(), ba_zi.getTimeNaYin()] | |
| def getBaZiShiShenGan(self): | |
| ba_zi = self.getEightChar() | |
| return [ba_zi.getYearShiShenGan(), ba_zi.getMonthShiShenGan(), ba_zi.getDayShiShenGan(), ba_zi.getTimeShiShenGan()] | |
| def getBaZiShiShenZhi(self): | |
| ba_zi = self.getEightChar() | |
| return [ba_zi.getYearShiShenZhi()[0], ba_zi.getMonthShiShenZhi()[0], ba_zi.getDayShiShenZhi()[0], ba_zi.getTimeShiShenZhi()[0]] | |
| def getBaZiShiShenYearZhi(self): | |
| return self.getEightChar().getYearShiShenZhi() | |
| def getBaZiShiShenMonthZhi(self): | |
| return self.getEightChar().getMonthShiShenZhi() | |
| def getBaZiShiShenDayZhi(self): | |
| return self.getEightChar().getDayShiShenZhi() | |
| def getBaZiShiShenTimeZhi(self): | |
| return self.getEightChar().getTimeShiShenZhi() | |
| def getZhiXing(self): | |
| offset = self.__dayZhiIndex - self.__monthZhiIndex | |
| if offset < 0: | |
| offset += 12 | |
| return LunarUtil.ZHI_XING[offset + 1] | |
| def getDayTianShen(self): | |
| return LunarUtil.TIAN_SHEN[(self.__dayZhiIndex + LunarUtil.ZHI_TIAN_SHEN_OFFSET[self.getMonthZhi()]) % 12 + 1] | |
| def getTimeTianShen(self): | |
| return LunarUtil.TIAN_SHEN[(self.__timeZhiIndex + LunarUtil.ZHI_TIAN_SHEN_OFFSET[self.getDayZhiExact()]) % 12 + 1] | |
| def getDayTianShenType(self): | |
| return LunarUtil.TIAN_SHEN_TYPE[self.getDayTianShen()] | |
| def getTimeTianShenType(self): | |
| return LunarUtil.TIAN_SHEN_TYPE[self.getTimeTianShen()] | |
| def getDayTianShenLuck(self): | |
| return LunarUtil.TIAN_SHEN_TYPE_LUCK[self.getDayTianShenType()] | |
| def getTimeTianShenLuck(self): | |
| return LunarUtil.TIAN_SHEN_TYPE_LUCK[self.getTimeTianShenType()] | |
| def getDayPositionTai(self): | |
| return LunarUtil.POSITION_TAI_DAY[LunarUtil.getJiaZiIndex(self.getDayInGanZhi())] | |
| def getMonthPositionTai(self): | |
| m = self.__month | |
| if m < 0: | |
| return "" | |
| return LunarUtil.POSITION_TAI_MONTH[m - 1] | |
| def getDayYi(self, sect=1): | |
| """ | |
| 获取每日宜 | |
| :return: 宜 | |
| """ | |
| if 2 == sect: | |
| month_gan_zhi = self.getMonthInGanZhiExact() | |
| else: | |
| month_gan_zhi = self.getMonthInGanZhi() | |
| return LunarUtil.getDayYi(month_gan_zhi, self.getDayInGanZhi()) | |
| def getDayJi(self, sect=1): | |
| """ | |
| 获取每日忌 | |
| :return: 忌 | |
| """ | |
| if 2 == sect: | |
| month_gan_zhi = self.getMonthInGanZhiExact() | |
| else: | |
| month_gan_zhi = self.getMonthInGanZhi() | |
| return LunarUtil.getDayJi(month_gan_zhi, self.getDayInGanZhi()) | |
| def getTimeYi(self): | |
| """ | |
| 获取时宜 | |
| :return: 宜 | |
| """ | |
| return LunarUtil.getTimeYi(self.getDayInGanZhiExact(), self.getTimeInGanZhi()) | |
| def getTimeJi(self): | |
| """ | |
| 获取时忌 | |
| :return: 忌 | |
| """ | |
| return LunarUtil.getTimeJi(self.getDayInGanZhiExact(), self.getTimeInGanZhi()) | |
| def getDayJiShen(self): | |
| """ | |
| 获取日吉神（宜趋） | |
| :return: 日吉神 | |
| """ | |
| return LunarUtil.getDayJiShen(self.getMonthZhiIndex(), self.getDayInGanZhi()) | |
| def getDayXiongSha(self): | |
| """ | |
| 获取日凶煞（宜忌） | |
| :return: 日凶煞 | |
| """ | |
| return LunarUtil.getDayXiongSha(self.getMonthZhiIndex(), self.getDayInGanZhi()) | |
| def getYueXiang(self): | |
| """ | |
| 获取月相 | |
| :return: 月相 | |
| """ | |
| return LunarUtil.YUE_XIANG[self.__day] | |
| def __getYearNineStar(self, year_in_gan_zhi): | |
| index_exact = LunarUtil.getJiaZiIndex(year_in_gan_zhi) + 1 | |
| index = LunarUtil.getJiaZiIndex(self.getYearInGanZhi()) + 1 | |
| year_offset = index_exact - index | |
| if year_offset > 1: | |
| year_offset -= 60 | |
| elif year_offset < -1: | |
| year_offset += 60 | |
| yuan = int((self.__year + year_offset + 2696) / 60) % 3 | |
| offset = (62 + yuan * 3 - index_exact) % 9 | |
| if 0 == offset: | |
| offset = 9 | |
| return NineStar.fromIndex(offset - 1) | |
| def getYearNineStar(self, sect=2): | |
| if 1 == sect: | |
| year_in_gan_zhi = self.getYearInGanZhi() | |
| elif 3 == sect: | |
| year_in_gan_zhi = self.getYearInGanZhiExact() | |
| else: | |
| year_in_gan_zhi = self.getYearInGanZhiByLiChun() | |
| return self.__getYearNineStar(year_in_gan_zhi) | |
| def __getMonthNineStar(year_zhi_index, month_zhi_index): | |
| index = year_zhi_index % 3 | |
| n = 27 - index * 3 | |
| if month_zhi_index < LunarUtil.BASE_MONTH_ZHI_INDEX: | |
| n -= 3 | |
| offset = (n - month_zhi_index) % 9 | |
| return NineStar.fromIndex(offset) | |
| def getMonthNineStar(self, sect=2): | |
| if 1 == sect: | |
| year_zhi_index = self.__yearZhiIndex | |
| month_zhi_index = self.__monthZhiIndex | |
| elif 3 == sect: | |
| year_zhi_index = self.__yearZhiIndexExact | |
| month_zhi_index = self.__monthZhiIndexExact | |
| else: | |
| year_zhi_index = self.__yearZhiIndexByLiChun | |
| month_zhi_index = self.__monthZhiIndex | |
| return self.__getMonthNineStar(year_zhi_index, month_zhi_index) | |
| def getDayNineStar(self): | |
| solar_ymd = self.__solar.toYmd() | |
| dong_zhi = self.__jieQi["冬至"] | |
| dong_zhi2 = self.__jieQi["DONG_ZHI"] | |
| xia_zhi = self.__jieQi["夏至"] | |
| dong_zhi_index = LunarUtil.getJiaZiIndex(dong_zhi.getLunar().getDayInGanZhi()) | |
| dong_zhi_index2 = LunarUtil.getJiaZiIndex(dong_zhi2.getLunar().getDayInGanZhi()) | |
| xia_zhi_index = LunarUtil.getJiaZiIndex(xia_zhi.getLunar().getDayInGanZhi()) | |
| if dong_zhi_index > 29: | |
| solar_shun_bai = dong_zhi.next(60 - dong_zhi_index) | |
| else: | |
| solar_shun_bai = dong_zhi.next(-dong_zhi_index) | |
| solar_shun_bai_ymd = solar_shun_bai.toYmd() | |
| if dong_zhi_index2 > 29: | |
| solar_shun_bai2 = dong_zhi2.next(60 - dong_zhi_index2) | |
| else: | |
| solar_shun_bai2 = dong_zhi2.next(-dong_zhi_index2) | |
| solar_shun_bai_ymd2 = solar_shun_bai2.toYmd() | |
| if xia_zhi_index > 29: | |
| solar_ni_zi = xia_zhi.next(60 - xia_zhi_index) | |
| else: | |
| solar_ni_zi = xia_zhi.next(-xia_zhi_index) | |
| solar_ni_zi_ymd = solar_ni_zi.toYmd() | |
| offset = 0 | |
| if solar_shun_bai_ymd <= solar_ymd < solar_ni_zi_ymd: | |
| offset = self.__solar.subtract(solar_shun_bai) % 9 | |
| elif solar_ni_zi_ymd <= solar_ymd < solar_shun_bai_ymd2: | |
| offset = 8 - (self.__solar.subtract(solar_ni_zi) % 9) | |
| elif solar_ymd >= solar_shun_bai_ymd2: | |
| offset = self.__solar.subtract(solar_shun_bai2) % 9 | |
| elif solar_ymd < solar_shun_bai_ymd: | |
| offset = (8 + solar_shun_bai.subtract(self.__solar)) % 9 | |
| return NineStar.fromIndex(offset) | |
| def getTimeNineStar(self): | |
| solar_ymd = self.__solar.toYmd() | |
| asc = False | |
| if self.__jieQi["冬至"].toYmd() <= solar_ymd < self.__jieQi["夏至"].toYmd(): | |
| asc = True | |
| elif solar_ymd >= self.__jieQi["DONG_ZHI"].toYmd(): | |
| asc = True | |
| start = 6 if asc else 2 | |
| day_zhi = self.getDayZhi() | |
| if day_zhi in "子午卯酉": | |
| start = 0 if asc else 8 | |
| elif day_zhi in "辰戌丑未": | |
| start = 3 if asc else 5 | |
| index = start + self.__timeZhiIndex if asc else start + 9 - self.__timeZhiIndex | |
| return NineStar.fromIndex(index % 9) | |
| def getJieQiTable(self): | |
| return self.__jieQi | |
| def getJieQiList(self): | |
| return self.__jieQiList | |
| def getTimeGanIndex(self): | |
| return self.__timeGanIndex | |
| def getTimeZhiIndex(self): | |
| return self.__timeZhiIndex | |
| def getDayGanIndex(self): | |
| return self.__dayGanIndex | |
| def getDayZhiIndex(self): | |
| return self.__dayZhiIndex | |
| def getDayGanIndexExact(self): | |
| return self.__dayGanIndexExact | |
| def getDayGanIndexExact2(self): | |
| return self.__dayGanIndexExact2 | |
| def getDayZhiIndexExact(self): | |
| return self.__dayZhiIndexExact | |
| def getDayZhiIndexExact2(self): | |
| return self.__dayZhiIndexExact2 | |
| def getMonthGanIndex(self): | |
| return self.__monthGanIndex | |
| def getMonthZhiIndex(self): | |
| return self.__monthZhiIndex | |
| def getMonthGanIndexExact(self): | |
| return self.__monthGanIndexExact | |
| def getMonthZhiIndexExact(self): | |
| return self.__monthZhiIndexExact | |
| def getYearGanIndex(self): | |
| return self.__yearGanIndex | |
| def getYearZhiIndex(self): | |
| return self.__yearZhiIndex | |
| def getYearGanIndexByLiChun(self): | |
| return self.__yearGanIndexByLiChun | |
| def getYearZhiIndexByLiChun(self): | |
| return self.__yearZhiIndexByLiChun | |
| def getYearGanIndexExact(self): | |
| return self.__yearGanIndexExact | |
| def getYearZhiIndexExact(self): | |
| return self.__yearZhiIndexExact | |
| def getNextJie(self, whole_day=False): | |
| """ | |
| 获取下一节（顺推的第一个节） | |
| :param whole_day: 是否按天计 | |
| :return: 节气 | |
| """ | |
| conditions = [] | |
| for i in range(0, int(len(Lunar.JIE_QI_IN_USE) / 2)): | |
| conditions.append(Lunar.JIE_QI_IN_USE[i * 2]) | |
| return self.__getNearJieQi(True, conditions, whole_day) | |
| def getPrevJie(self, whole_day=False): | |
| """ | |
| 获取上一节（逆推的第一个节） | |
| :param whole_day: 是否按天计 | |
| :return: 节气 | |
| """ | |
| conditions = [] | |
| for i in range(0, int(len(Lunar.JIE_QI_IN_USE) / 2)): | |
| conditions.append(Lunar.JIE_QI_IN_USE[i * 2]) | |
| return self.__getNearJieQi(False, conditions, whole_day) | |
| def getNextQi(self, whole_day=False): | |
| """ | |
| 获取下一气令（顺推的第一个气令） | |
| :param whole_day: 是否按天计 | |
| :return: 节气 | |
| """ | |
| conditions = [] | |
| for i in range(0, int(len(Lunar.JIE_QI_IN_USE) / 2)): | |
| conditions.append(Lunar.JIE_QI_IN_USE[i * 2 + 1]) | |
| return self.__getNearJieQi(True, conditions, whole_day) | |
| def getPrevQi(self, whole_day=False): | |
| """ | |
| 获取上一气令（逆推的第一个气令） | |
| :param whole_day: 是否按天计 | |
| :return: 节气 | |
| """ | |
| conditions = [] | |
| for i in range(0, int(len(Lunar.JIE_QI_IN_USE) / 2)): | |
| conditions.append(Lunar.JIE_QI_IN_USE[i * 2 + 1]) | |
| return self.__getNearJieQi(False, conditions, whole_day) | |
| def getNextJieQi(self, whole_day=False): | |
| """ | |
| 获取下一节气（顺推的第一个节气） | |
| :param whole_day: 是否按天计 | |
| :return: 节气 | |
| """ | |
| return self.__getNearJieQi(True, None, whole_day) | |
| def getPrevJieQi(self, whole_day=False): | |
| """ | |
| 获取上一节气（逆推的第一个节气） | |
| :param whole_day: 是否按天计 | |
| :return: 节气 | |
| """ | |
| return self.__getNearJieQi(False, None, whole_day) | |
| def __getNearJieQi(self, forward, conditions, whole_day): | |
| """ | |
| 获取最近的节气，如果未找到匹配的，返回null | |
| :param forward: 是否顺推，true为顺推，false为逆推 | |
| :param conditions: 过滤条件，如果设置过滤条件，仅返回匹配该名称的 | |
| :param whole_day: 是否按天计 | |
| :return: 节气 | |
| """ | |
| name = None | |
| near = None | |
| filters = set() | |
| if conditions is not None: | |
| for cond in conditions: | |
| filters.add(cond) | |
| is_filter = len(filters) > 0 | |
| today = self.__solar.toYmd() if whole_day else self.__solar.toYmdHms() | |
| for key in self.JIE_QI_IN_USE: | |
| jq = self.__convertJieQi(key) | |
| if is_filter and not filters.__contains__(jq): | |
| continue | |
| solar = self.__jieQi[key] | |
| day = solar.toYmd() if whole_day else solar.toYmdHms() | |
| if forward: | |
| if day <= today: | |
| continue | |
| if near is None: | |
| name = jq | |
| near = solar | |
| else: | |
| near_day = near.toYmd() if whole_day else near.toYmdHms() | |
| if day < near_day: | |
| name = jq | |
| near = solar | |
| else: | |
| if day > today: | |
| continue | |
| if near is None: | |
| name = jq | |
| near = solar | |
| else: | |
| near_day = near.toYmd() if whole_day else near.toYmdHms() | |
| if day > near_day: | |
| name = jq | |
| near = solar | |
| if near is None: | |
| return None | |
| return JieQi(name, near) | |
| def getJieQi(self): | |
| """ | |
| 获取节气名称，如果无节气，返回空字符串 | |
| :return: 节气名称 | |
| """ | |
| for key in self.__jieQi: | |
| d = self.__jieQi[key] | |
| if d.getYear() == self.__solar.getYear() and d.getMonth() == self.__solar.getMonth() and d.getDay() == self.__solar.getDay(): | |
| return self.__convertJieQi(key) | |
| return "" | |
| def getCurrentJieQi(self): | |
| """ | |
| 获取当天节气对象，如果无节气，返回None | |
| :return: 节气对象 | |
| """ | |
| for key in self.__jieQi: | |
| d = self.__jieQi[key] | |
| if d.getYear() == self.__solar.getYear() and d.getMonth() == self.__solar.getMonth() and d.getDay() == self.__solar.getDay(): | |
| return JieQi(self.__convertJieQi(key), self.__solar) | |
| return None | |
| def getCurrentJie(self): | |
| """ | |
| 获取当天节令对象，如果无节令，返回None | |
| :return: 节气对象 | |
| """ | |
| for i in range(0, len(Lunar.JIE_QI_IN_USE), 2): | |
| key = Lunar.JIE_QI_IN_USE[i] | |
| d = self.__jieQi[key] | |
| if d.getYear() == self.__solar.getYear() and d.getMonth() == self.__solar.getMonth() and d.getDay() == self.__solar.getDay(): | |
| return JieQi(self.__convertJieQi(key), d) | |
| return None | |
| def getCurrentQi(self): | |
| """ | |
| 获取当天气令对象，如果无气令，返回None | |
| :return: 节气对象 | |
| """ | |
| for i in range(1, len(Lunar.JIE_QI_IN_USE), 2): | |
| key = Lunar.JIE_QI_IN_USE[i] | |
| d = self.__jieQi[key] | |
| if d.getYear() == self.__solar.getYear() and d.getMonth() == self.__solar.getMonth() and d.getDay() == self.__solar.getDay(): | |
| return JieQi(self.__convertJieQi(key), d) | |
| return None | |
| def next(self, days): | |
| """ | |
| 获取往后推几天的农历日期，如果要往前推，则天数用负数 | |
| :param days: 天数 | |
| :return: 农历日期 | |
| """ | |
| return self.__solar.next(days).getLunar() | |
| def __str__(self): | |
| return self.toString() | |
| def toString(self): | |
| return "%s年%s月%s" % (self.getYearInChinese(), self.getMonthInChinese(), self.getDayInChinese()) | |
| def toFullString(self): | |
| s = self.toString() | |
| s += " " + self.getYearInGanZhi() + "(" + self.getYearShengXiao() + ")年" | |
| s += " " + self.getMonthInGanZhi() + "(" + self.getMonthShengXiao() + ")月" | |
| s += " " + self.getDayInGanZhi() + "(" + self.getDayShengXiao() + ")日" | |
| s += " " + self.getTimeZhi() + "(" + self.getTimeShengXiao() + ")时" | |
| s += " 纳音[" + self.getYearNaYin() + " " + self.getMonthNaYin() + " " + self.getDayNaYin() + " " + self.getTimeNaYin() + "]" | |
| s += " 星期" + self.getWeekInChinese() | |
| for f in self.getFestivals(): | |
| s += " (" + f + ")" | |
| for f in self.getOtherFestivals(): | |
| s += " (" + f + ")" | |
| jq = self.getJieQi() | |
| if len(jq) > 0: | |
| s += " [" + jq + "]" | |
| s += " " + self.getGong() + "方" + self.getShou() | |
| s += " 星宿[" + self.getXiu() + self.getZheng() + self.getAnimal() + "](" + self.getXiuLuck() + ")" | |
| s += " 彭祖百忌[" + self.getPengZuGan() + " " + self.getPengZuZhi() + "]" | |
| s += " 喜神方位[" + self.getDayPositionXi() + "](" + self.getDayPositionXiDesc() + ")" | |
| s += " 阳贵神方位[" + self.getDayPositionYangGui() + "](" + self.getDayPositionYangGuiDesc() + ")" | |
| s += " 阴贵神方位[" + self.getDayPositionYinGui() + "](" + self.getDayPositionYinGuiDesc() + ")" | |
| s += " 福神方位[" + self.getDayPositionFu() + "](" + self.getDayPositionFuDesc() + ")" | |
| s += " 财神方位[" + self.getDayPositionCai() + "](" + self.getDayPositionCaiDesc() + ")" | |
| s += " 冲[" + self.getChongDesc() + "]" | |
| s += " 煞[" + self.getSha() + "]" | |
| return s | |
| def getYearXun(self): | |
| """ | |
| 获取年所在旬（以正月初一作为新年的开始） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getYearInGanZhi()) | |
| def getYearXunByLiChun(self): | |
| """ | |
| 获取年所在旬（以立春当天作为新年的开始） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getYearInGanZhiByLiChun()) | |
| def getYearXunExact(self): | |
| """ | |
| 获取年所在旬（以立春交接时刻作为新年的开始） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getYearInGanZhiExact()) | |
| def getYearXunKong(self): | |
| """ | |
| 获取值年空亡（以正月初一作为新年的开始） | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getYearInGanZhi()) | |
| def getYearXunKongByLiChun(self): | |
| """ | |
| 获取值年空亡（以立春当天作为新年的开始） | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getYearInGanZhiByLiChun()) | |
| def getYearXunKongExact(self): | |
| """ | |
| 获取值年空亡（以立春交接时刻作为新年的开始） | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getYearInGanZhiExact()) | |
| def getMonthXun(self): | |
| """ | |
| 获取月所在旬（以节交接当天起算） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getMonthInGanZhi()) | |
| def getMonthXunExact(self): | |
| """ | |
| 获取月所在旬（以节交接时刻起算） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getMonthInGanZhiExact()) | |
| def getMonthXunKong(self): | |
| """ | |
| 获取值月空亡（以节交接当天起算） | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getMonthInGanZhi()) | |
| def getMonthXunKongExact(self): | |
| """ | |
| 获取值月空亡（以节交接时刻起算） | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getMonthInGanZhiExact()) | |
| def getDayXun(self): | |
| """ | |
| 获取日所在旬（以节交接当天起算） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getDayInGanZhi()) | |
| def getDayXunExact(self): | |
| """ | |
| 获取日所在旬（晚子时日柱算明天） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getDayInGanZhiExact()) | |
| def getDayXunExact2(self): | |
| """ | |
| 获取日所在旬（晚子时日柱算当天） | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getDayInGanZhiExact2()) | |
| def getDayXunKong(self): | |
| """ | |
| 获取值日空亡 | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getDayInGanZhi()) | |
| def getDayXunKongExact(self): | |
| """ | |
| 获取值日空亡（晚子时日柱算明天） | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getDayInGanZhiExact()) | |
| def getDayXunKongExact2(self): | |
| """ | |
| 获取值日空亡（晚子时日柱算当天） | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getDayInGanZhiExact2()) | |
| def getTimeXun(self): | |
| """ | |
| 获取时辰所在旬 | |
| :return: 旬 | |
| """ | |
| return LunarUtil.getXun(self.getTimeInGanZhi()) | |
| def getTimeXunKong(self): | |
| """ | |
| 获取值时空亡 | |
| :return: 空亡(旬空) | |
| """ | |
| return LunarUtil.getXunKong(self.getTimeInGanZhi()) | |
| def getShuJiu(self): | |
| """ | |
| 获取数九 | |
| :return: 数九，如果不是数九天，返回None | |
| """ | |
| current = Solar.fromYmd(self.__solar.getYear(), self.__solar.getMonth(), self.__solar.getDay()) | |
| start = self.__jieQi["DONG_ZHI"] | |
| start = Solar.fromYmd(start.getYear(), start.getMonth(), start.getDay()) | |
| if current.isBefore(start): | |
| start = self.__jieQi["冬至"] | |
| start = Solar.fromYmd(start.getYear(), start.getMonth(), start.getDay()) | |
| end = Solar.fromYmd(start.getYear(), start.getMonth(), start.getDay()).next(81) | |
| if current.isBefore(start) or not current.isBefore(end): | |
| return None | |
| days = current.subtract(start) | |
| return ShuJiu(LunarUtil.NUMBER[int(days / 9) + 1] + "九", days % 9 + 1) | |
| def getFu(self): | |
| """ | |
| 获取三伏 | |
| :return: 三伏，如果不是伏天，返回None | |
| """ | |
| current = Solar.fromYmd(self.__solar.getYear(), self.__solar.getMonth(), self.__solar.getDay()) | |
| xia_zhi = self.__jieQi["夏至"] | |
| li_qiu = self.__jieQi["立秋"] | |
| start = Solar.fromYmd(xia_zhi.getYear(), xia_zhi.getMonth(), xia_zhi.getDay()) | |
| add = 6 - xia_zhi.getLunar().getDayGanIndex() | |
| if add < 0: | |
| add += 10 | |
| add += 20 | |
| start = start.next(add) | |
| if current.isBefore(start): | |
| return None | |
| days = current.subtract(start) | |
| if days < 10: | |
| return Fu("初伏", days + 1) | |
| start = start.next(10) | |
| days = current.subtract(start) | |
| if days < 10: | |
| return Fu("中伏", days + 1) | |
| start = start.next(10) | |
| days = current.subtract(start) | |
| li_qiu_solar = Solar.fromYmd(li_qiu.getYear(), li_qiu.getMonth(), li_qiu.getDay()) | |
| if li_qiu_solar.isAfter(start): | |
| if days < 10: | |
| return Fu("中伏", days + 11) | |
| start = start.next(10) | |
| days = current.subtract(start) | |
| if days < 10: | |
| return Fu("末伏", days + 1) | |
| return None | |
| def getLiuYao(self): | |
| """ | |
| 获取六曜 | |
| :return: 六曜 | |
| """ | |
| return LunarUtil.LIU_YAO[(abs(self.__month) + self.__day - 2) % 6] | |
| def getWuHou(self): | |
| """ | |
| 获取物候 | |
| :return: 物候 | |
| """ | |
| jie_qi = self.getPrevJieQi(True) | |
| offset = 0 | |
| for i in range(0, len(Lunar.JIE_QI)): | |
| if jie_qi.getName() == Lunar.JIE_QI[i]: | |
| offset = i | |
| break | |
| index = int(self.__solar.subtract(jie_qi.getSolar()) / 5) | |
| if index > 2: | |
| index = 2 | |
| return LunarUtil.WU_HOU[(offset * 3 + index) % len(LunarUtil.WU_HOU)] | |
| def getHou(self): | |
| jie_qi = self.getPrevJieQi(True) | |
| size = len(LunarUtil.HOU) - 1 | |
| offset = int(self.__solar.subtract(jie_qi.getSolar()) / 5) | |
| if offset > size: | |
| offset = size | |
| return "%s %s" % (jie_qi.getName(), LunarUtil.HOU[offset]) | |
| def getDayLu(self): | |
| """ | |
| 获取日禄 | |
| :return: 日禄 | |
| """ | |
| gan = LunarUtil.LU[self.getDayGan()] | |
| zhi = None | |
| if self.getDayZhi() in LunarUtil.LU: | |
| zhi = LunarUtil.LU[self.getDayZhi()] | |
| lu = gan + "命互禄" | |
| if zhi is not None: | |
| lu += " " + zhi + "命进禄" | |
| return lu | |
| def getTime(self): | |
| """ | |
| 获取时辰 | |
| :return: 时辰 | |
| """ | |
| return LunarTime.fromYmdHms(self.__year, self.__month, self.__day, self.__hour, self.__minute, self.__second) | |
| def getTimes(self): | |
| """ | |
| 获取当天的时辰列表 | |
| :return: 时辰列表 | |
| """ | |
| times = [LunarTime.fromYmdHms(self.__year, self.__month, self.__day, 0, 0, 0)] | |
| for i in range(0, 12): | |
| times.append(LunarTime.fromYmdHms(self.__year, self.__month, self.__day, (i+1) * 2-1, 0, 0)) | |
| return times | |
| def getFoto(self): | |
| """ | |
| 获取佛历 | |
| :return: 佛历 | |
| """ | |
| from . import Foto | |
| return Foto.fromLunar(self) | |
| def getTao(self): | |
| """ | |
| 获取道历 | |
| :return: 道历 | |
| """ | |
| from . import Tao | |
| return Tao.fromLunar(self) | |