Python：每日一题 32（答题领鱼币）

新手·ing

感谢 冬雪雪冬 提供的题目



中国古代采用干支纪年法，即将天干和地支配合起来得到60个干支，将其对应每一年。60年一个轮回，成一个花甲。
要求输入年份给出相应的干支，输入干支，给出上一个和下一个同干支的年份，如果本年也是这个干支，则也显示出来。
例如：

============================ RESTART: D:/py/6.py ============================
输入年份，如2017，或干支，如丁酉：qw
输入错误！
>>> 
============================ RESTART: D:/py/6.py ============================
输入年份，如2017，或干支，如丁酉：2022
壬寅
>>> 
============================ RESTART: D:/py/6.py ============================
输入年份，如2017，或干支，如丁酉：己巳
上一个己巳年是1989
下一个己巳年是2049
>>> 
============================ RESTART: D:/py/6.py ============================
输入年份，如2017，或干支，如丁酉：丁酉
今年2017正好是丁酉年
上一个丁酉年是1957
下一个丁酉年是2077

已知条件：

tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']

欢迎小伙伴们，一起答题！
如果你有能力，欢迎加入我们！
已经上车老司机：@冬雪雪冬 @lumber2388779 @ooxx7788 @gopythoner
点我上车
帅的人都上车了，而丑的人还在犹豫

ooxx7788

"""2017=丁酉年"""
import time


def w_to_e(year):
    tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
    dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
    year_std = 2017
    tiangan_std = int(tiangan.index('丁'))
    dizhi_std = int(dizhi.index('酉'))
    temp = int(year) - year_std
    tiangan_search = (temp + tiangan_std) % 10
    dizhi_search = (temp + dizhi_std) % 12
    ganzhi = f'{tiangan[tiangan_search]}{dizhi[dizhi_search]}'
    return ganzhi


def year_convert(year):
    ganzhi = {}
    for i in range(int(time.strftime('%Y')) - 30, int(time.strftime('%Y')) + 30):
        ganzhi[w_to_e(i)] = i
    try:
        print(f'{year}是{w_to_e(year)}年！')
        return w_to_e(year)
    except:
        if year in ganzhi.keys():
            if ganzhi[year] > int(time.strftime('%Y')):
                print(f'上一个{year}年是{ganzhi[year]-60}年!')
                print(f'下一个{year}年是{ganzhi[year]}年!')
            elif ganzhi[year] < int(time.strftime('%Y')):
                print(f'上一个{year}年是{ganzhi[year]}年!')
                print(f'下一个{year}年是{ganzhi[year]+60}年!')
            else:
                print(f'今年{ganzhi[year]}正好是{year}年！')
                print(f'上一个{year}年是{ganzhi[year]-60}年!')
                print(f'下一个{year}年是{ganzhi[year]+60}年!')
            return ganzhi[year]-60, ganzhi[year], ganzhi[year]+60
        else:
            print('输入错误！')


if __name__ == '__main__':
    year_convert(input('输入年份，如2017，或干支，如丁酉：'))

先发个答案吧，后面再慢慢改。
更新了一下，现在输入公元年会返回一个对应的干支年，而输入一个干支年会返回一个公元年元组，而元组中间是最接近当前年份的公元年，两侧分别是上下60年。

输出：

输入年份，如2017，或干支，如丁酉：丁酉
今年2017正好是丁酉年！
上一个丁酉年是1957年!
下一个丁酉年是2077年!

输入年份，如2017，或干支，如丁酉：1894
1894是甲午年！

输入年份，如2017，或干支，如丁酉：甲子
上一个甲子年是1984年!
下一个甲子年是2044年!

输入年份，如2017，或干支，如丁酉：今天的题目还不错！
输入错误！

ooxx7788

才发现，这一题没有收录在你的淘贴里面。

ButcherRabbit

tiangan = [ '庚', '辛', '壬', '癸','甲', '乙', '丙', '丁', '戊', '己']
dizhi = ['申', '酉', '戌', '亥', '子', '丑', '寅', '卯', '辰', '巳', '午', '未',]
def number(n):
    di = n%12
    tian = n%10
    print(''.join([tiangan[tian],dizhi[di]]))

          
def hanzi(n):
    years = 2017
    beishu  = years//12
    global num1 ,num2
    for each in range(-2,3):#这种判断不是很好，我再想想其他判断方法
        num1 = (beishu  + each )*12 + dizhi.index(n[1])
        count = num1%10
        if count == tiangan.index(n[0]):
            break
    if num1 < years:
        num2 = num1 + 60
    elif num1 == years:
        num2 =num1 + 60
        num1 = years - 60
        print('今年2017正好是丁酉年')
    else:
        num2 = num1 
        num1 = num2 - 60
    return num1,num2

temp = input('输入年份，如2017，或干支，如丁酉：')
temp1 = temp

try:
    if temp.isdigit() == True:
        temp = int(temp)
        number(temp)
    else:
        list(temp1)
        if temp1[0] in tiangan and temp1[1] in dizhi:
            hanzi(temp1)
            print('上一个{0}年是{1}'.format(temp, num1))
            print('下一个{0}年是{1}'.format(temp, num2))
        else:
            print('输入错误！')
except:
    print('输入错误！')

我是来凑答案的。。干支判断有待完善，还有我的tiangen 和dizhi的列表有稍微改动一下

余欲渔

tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']*6
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']*5
gz=[tiangan[i]+dizhi[i] for i in range(60)]
while True:
    x=input('输入年份或干支：')
    if x in gz:
        print(gz.index(x)+1924,gz.index(x)+1984,gz.index(x)+2044)
    else:
        print(gz[int(x)%60-4])

solomonxian

为了判断打印时间，要把今年输入，默认关键字参数 n=2017

# 试试直接把所有干支弄出来，这样程序应该简单多了
tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
ganzi = list(zip(tiangan*6,dizhi*5))

def gz_print(year, now=2017):
    """输入年份或干支（字符串），打印相应日期信息，可传入现在年份（默认现在时间2017年）"""
    jiazi = 4 # 用公元后第一个甲子年做计算基础
    
    if tuple(year) in ganzi: 
        # 根据是不是正好今年，控制 target 打印范围
        extra = 0
        # 计算出来的是现在这一轮干支年，分‘过去、正在、未来’三种情况打印
        target = ganzi.index(tuple(year)) +jiazi +(now-jiazi)//60*60
        if target > now:
            target -= 60
        elif target == now:
            extra = -60
            print("今年 %d 正好是 %s 年" %(now, year))
        else:
            pass
        print("上一个 %s 是 %d " %(year, target+ extra))
        print("上一个 %s 是 %d " %(year, target+60))
    elif year.isdigit():
        # 减去甲子年再 %60 得出索引号，解包打印
        print(*ganzi[(int(year) - jiazi) %60])
    else:
        print("输入错误，亲！")

n = input("请输入年份，如‘2017’ ,或干支，如‘丁酉’：")
gz_print(n)

张大象

tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
year1 = 2017
tiandi1 = 34
tmp = input('输入年份，如2017，或干支，如丁酉：')
if tmp.isdigit():
    num = int(tmp) - year1
    tiandi = (tiandi1 + num)%60
    num1 = tiandi //10
    num2 = tiandi %10
    a2,b2 = tiangan[num2-1],dizhi[(num2+num1*10)%12-1]
    print(a2,b2,sep='')
else:
    a1,b1  = [i for i in tmp]
    num1 = tiangan.index(a1)-dizhi.index(b1)
    if num1 >= 0:
        num2 = num1 //2*10+tiangan.index(a1)+1
    else:
        num2 = (num1+12)//2*10+tiangan.index(a1)+1
    num3 = num2 - 34
    if num3 < 0:
        print('上一个{0}年是{1}'.format(tmp, 2017+num3))
        print('下一个{0}年是{1}'.format(tmp, 2017+num3+60))
    else:
        print('上一个{0}年是{1}'.format(tmp, 2017+num3-60))
        print('下一个{0}年是{1}'.format(tmp, 2017+num3))  

gausser

# -*- coding utf-8 -*-

import time
tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
now = int(time.strftime("%Y"))

def Get_Tian_Zhi(year):
    s = tiangan[year % 10 - 3] + dizhi[year % 12 - 3]
    print s.decode('utf-8')

def Get_Year_By_TianZhi(tianzhi):
    tmp1 = tianzhi[0] + 3
    tmp2 = tianzhi[1] + 3
    list_year = []
    years = []

    for i in range(100, 300):
        for j in range(100, 300):
            if i * 10 + tmp1 == j * 12 + tmp2:
                list_year.append(j * 12 + tmp2)

    for each in list_year:
        if abs(each - now) <= 60:
            years.append(each)

    return years
        
year = int(raw_input("Enter the year: "))    
Get_Tian_Zhi(year)

tiangan = int(raw_input("Enter the tiangan: "))
dizhi = int(raw_input("Enter the dizhi: "))
tianzhi = [tiangan, dizhi]
print Get_Year_By_TianZhi(tianzhi)

石小龙

看到楼上这么长的代码，不敢回答了

shigure_takimi

from datetime import datetime

tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']


# 已知2017年是丁酉年
allGanzhi = []
for number in range(0, 60):
    gan = tiangan[number%10]
    zhi = dizhi[number%12]
    allGanzhi.append(gan+zhi)
# 丁酉年的index
indexOfDingyou = allGanzhi.index('丁酉')
currentYear = datetime.now().year

def judgeYear(ganzhi):
    if judgeGanzhi(currentYear) == ganzhi:
        print('今年%d年正好是%s年!' % (currentYear, ganzhi))
        print('上一个%s年是%d年!' % (ganzhi, currentYear-60))
        print('下一个%s年是%d年!' % (ganzhi, currentYear+60))
    else:
        ganzhiOfCurrentYear = judgeGanzhi(currentYear)
        indexOfCurrentYearGanzhi = allGanzhi.index(ganzhiOfCurrentYear)
        indexOfRequestedGanzhi = allGanzhi.index(ganzhi)
        sub = indexOfCurrentYearGanzhi - indexOfRequestedGanzhi
        lastOrNextYear = currentYear - sub
        if lastOrNextYear > currentYear:
            nextYear = lastOrNextYear
            lastYear = nextYear - 60
        else:
            lastYear = lastOrNextYear
            nextYear = lastYear + 60

        print('上一个%s年是%d年!' % (ganzhi, lastYear))
        print('下一个%s年是%d年!' % (ganzhi, nextYear))
    
def judgeGanzhi(year):
    return allGanzhi[(year+indexOfDingyou-2017)%60]

inputYearOrGanzhi = input('输入年份，如2017，或干支，如丁酉：')
if inputYearOrGanzhi in allGanzhi:
    judgeYear(inputYearOrGanzhi)
elif inputYearOrGanzhi.isdigit() and int(inputYearOrGanzhi) > 0:
    print('%s年是%s年！' % (inputYearOrGanzhi, judgeGanzhi(int(inputYearOrGanzhi))))
else:
    print('输入错误！')


# 结果完美。只是不能判断公元前的。
# 硬要写也可以，只是懒得改了，就是这么个意思。
>>> 
输入年份，如2017，或干支，如丁酉：戊戌
上一个戊戌年是1958年!
下一个戊戌年是2018年!
>>> ================================ RESTART ================================
>>> 
输入年份，如2017，或干支，如丁酉：甲子
上一个甲子年是1984年!
下一个甲子年是2044年!
>>> ================================ RESTART ================================
>>> 
输入年份，如2017，或干支，如丁酉：丁酉
今年2017年正好是丁酉年!
上一个丁酉年是1957年!
下一个丁酉年是2077年!
>>> ================================ RESTART ================================
>>> 
输入年份，如2017，或干支，如丁酉：1985
1985年是乙丑年！
>>> ================================ RESTART ================================
>>> 
输入年份，如2017，或干支，如丁酉：1
1年是辛酉年！
>>> ================================ RESTART ================================
>>> 
输入年份，如2017，或干支，如丁酉：0
输入错误！
>>> ================================ RESTART ================================
>>> 
输入年份，如2017，或干支，如丁酉：辛亥
上一个辛亥年是1971年!
下一个辛亥年是2031年!
>>> ================================ RESTART ================================
>>> 
输入年份，如2017，或干支，如丁酉：1911
1911年是辛亥年！

瞬秒爆加速

tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']

def fun(n):
    td=[tiangan[i%10]+dizhi[i%12] for i in range(60)]
    return td[(n-3)%60-1]

if __name__=="__main__":
    fun(2017)

新手潘包邮

def calculate(year = 2018, tiangan_dizhi ="戊戌"):
    tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
    dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
    if year != 2018:
        tiangan_index = (year - 4)%10
        dizhi_index = (year - 4)%12
        #tiangan_dizhi = ""
        tiangan_dizhi = tiangan[tiangan_index] + dizhi[dizhi_index]
        print(tiangan_dizhi)
        return tiangan_dizhi
    else:
        tiangan_index = list(tiangan_dizhi)[0]
        dizhi_index = list(tiangan_dizhi)[1]
        
        tiangan_index = tiangan.index(tiangan_index)
        dizhi_index = dizhi.index(dizhi_index)
        year_list = []

        for year in range(1900, 2060):
            tiangan_num = (year - 4)%10
            dizhi_num = (year - 4)%12
            if tiangan_num == tiangan_index and dizhi_num == dizhi_index:
                year_list.append(year)
        print(year_list)
        print("上一个%s年是%d"%(tiangan_dizhi, year_list[-2]))
        print("下一个%s年是%d"%(tiangan_dizhi, year_list[-1]))        
        #year = tiangan_index*
        #print(tiangan_num, dizhi_num)
while True:
    num = input("输入年份，如2017，或干支，如丁酉：")
    if num.isdigit():
        calculate(year = int(num))
    else:
        calculate(tiangan_dizhi = num)

大头目

'''计算方法还要百度科普。。。深觉自己没文化。。。
计算以及推算
万年历查知1995年为乙亥年。
用1995年的尾数查得知为乙，用年份（1995年）除以12的余数为3查表的知3为亥，所以1995年为乙亥年。具体的算法如下：
先用年份的尾数查出天干，如2013年 3为癸；再用2013年除以12余数为9，9为巳。那么2013年就是癸巳年了。
天干        甲        乙        丙        丁        戊        己        庚        辛        壬        癸               
        4        5        6        7        8        9        0        1        2        3               
地支        子        丑        寅        卯        辰        巳        午        未        申        酉        戌        亥
        4        5        6        7        8        9        10        11        12        1        2        3'''

tiangan = ['庚', '辛', '壬', '癸','甲', '乙', '丙', '丁', '戊', '己']
dizhi = ['申', '酉', '戌', '亥','子', '丑', '寅', '卯', '辰', '巳', '午', '未']

year = input('输入年份，如2017，或干支，如丁酉：')
n = 0
if year.isnumeric():
        x = int(year[-1])
        y = int(year) % 12
        out_year = tiangan[x] + dizhi[y]
        print(out_year)

elif year[0] in tiangan and year[1] in dizhi:
        for i in range(1957,2078):
                if tiangan.index(year[0]) == int(str(i)[-1]) and i % 12 == dizhi.index(year[1]) and i == 2017:
                        print('今年%s年正好是%s' % (i,year))
                elif tiangan.index(year[0]) == int(str(i)[-1]) and i % 12 == dizhi.index(year[1]) and n == 0:
                        print('上一个%s年是%s' % (year,i))
                        n += 1
                elif tiangan.index(year[0]) == int(str(i)[-1]) and i % 12 == dizhi.index(year[1]) and n == 1:
                        print('下一个%s年是%s' % (year,i))
else:
        print('输入格式错误')

凌九霄

tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']

rebirth = list(map(lambda x: x[0] + x[1], list(zip(tiangan * 6, dizhi * 5))))

import time


def calendar(year):
    if year.isdigit():
        if int(year) >= 2017:
            years = int(year) % 2017 % 60 - 60
        else:
            years =  0 - 2017 % int(year) % 60
        return rebirth[rebirth.index('丁酉') + years]
    else:
        nf = 2017 + rebirth.index(year) - rebirth.index('丁酉')
        return str(nf)


while True:
    lstr = input("\n请输入年份，如2017 或干支，如丁酉：【输入Q退出】")
    if lstr.isdigit():
        print("{0}年的干支纪年：{1}".format(lstr, calendar(lstr)))
    elif lstr in rebirth:
        nf = calendar(lstr)
        if nf == time.strftime("%Y", time.localtime()):
            print("今年{0}正好是{1}年".format(calendar(lstr), lstr))

        print("上一个{0}年是:{1}年".format(lstr, str(int(nf) - 60)))
        print("下一个{0}年是:{1}年".format(lstr, str(int(nf) + 60)))
    elif lstr == 'Q':
        break
    else:
        print("\n输入有误，请重新输入...")

萧丹夜

6666完美复现

import datetime

x = input('输入年份，如2017：')
tiangan = ['庚', '辛', '壬', '癸', '甲', '乙', '丙', '丁', '戊', '己']
dizhi = ['酉', '戌', '亥', '子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申']
dic = { '甲子':1984,'甲戌':1994,'甲申':2004,'甲午':2014,'甲辰':2024,'甲寅':2034,\
        '乙丑':1985,'乙亥':1995,'乙酉':2005,'乙未':2015,'乙巳':2025,'乙卯':2035,\
        '丙寅':1986,'丙子':1996,'丙戌':2006,'丙申':2016,'丙午':2026,'丙辰':2036,\
        '丁卯':1987,'丁丑':1997,'丁亥':2007,'丁酉':2017,'丁未':2027,'丁巳':2037,\
        '戊辰':1988,'戊寅':1998,'戊子':2008,'戊戌':2018,'戊申':2028,'戊午':2038,\
        '己巳':1989,'己卯':1999,'己丑':2009,'己亥':2019,'己酉':2029,'己未':2039,\
        '庚午':1990,'庚辰':2000,'庚寅':2010,'庚子':2020,'庚戌':2030,'庚申':2040,\
        '辛未':1991,'辛巳':2001,'辛卯':2011,'辛丑':2021,'辛亥':2031,'辛酉':2041,\
        '壬申':1992,'壬午':2002,'壬辰':2012,'壬寅':2022,'壬子':2032,'壬戌':2042,\
        '癸酉':1993,'癸未':2003,'癸巳':2013,'癸卯':2023,'癸丑':2033,'癸亥':2043}

cur_year = datetime.datetime.now().year
if x in dic.keys():
    if int(dic[x]) == cur_year:
        print('今年%d年刚好是%s年！'%(cur_year,x))
        print('上一个%s年是%d年！'%(x,int(dic[x])-60))
        print('下一个%s年是%d年！'%(x,int(dic[x])+60))
    elif int(dic[x]) < cur_year:
        print('上一个%s年是%d年！'%(x,int(dic[x])))
        print('下一个%s年是%d年！'%(x,int(dic[x])+60))
    else:
        print('上一个%s年是%d年！'%(x,int(dic[x])-60))
        print('下一个%s年是%d年！'%(x,int(dic[x])))
elif x.isdigit():
    x = int(x)
    a = x % 10
    b = x % 12
    print('%c%c'%(tiangan[a],dizhi[b-1]))
else:
    print('输入错误！')

噬魂之诗

import datetime

cur_year = datetime.datetime.now().year


tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
nian = []
i = -1
n = -1
while True:
    i += 1
    n += 1
    x = tiangan[i] + dizhi[n]
    if i == 9:
        i = -1
    if n == 11:
        n = -1
   
    nian.append(x)
   
    if len(nian) == 60:
        break
try:
    while True:
        w = input('请输入查询的年份： 如2018 或干支 如甲子：')
        print('输入 "q" 退出')
        if w in nian:
            p = int(nian.index(w)) + 4
            y = cur_year % 60
            print('上一个' + w + '年是：' + str(cur_year - (y -p)))
            print('下一个' + w + '年是：' + str(cur_year + (y -p)))
        elif w == 'q':
            break
        else:
            n = (int(w)) % 60 - 4
            print(nian[n])
except ValueError:
    print('请按套路出牌')

噬魂之诗

import datetime

cur_year = datetime.datetime.now().year


tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
nian = []
i = -1
n = -1
while True:
    i += 1
    n += 1
    x = tiangan[i] + dizhi[n]
    if i == 9:
        i = -1
    if n == 11:
        n = -1
   
    nian.append(x)
   
    if len(nian) == 60:
        break

while True:
    w = input('请输入查询的年份： 如2018 或干支 如甲子：')
    print('输入 "q" 退出')
    try:
        if w in nian:
            p = int(nian.index(w)) + 4
            y = cur_year % 60
            print('上一个' + w + '年是：' + str(cur_year - (y -p)))
            print('下一个' + w + '年是：' + str(cur_year + (y -p)))
        elif w == 'q':
            break
        elif type(int(w)) == int:
            n = (int(w)) % 60 - 4
            print(nian[n])
        else:
            print('请按套路出牌')
    except ValueError:
        print('请按套路出牌')

噬魂之诗

import datetime

cur_year = datetime.datetime.now().year


tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
nian = []
i = -1
n = -1
while True:
    i += 1
    n += 1
    x = tiangan[i] + dizhi[n]
    if i == 9:
        i = -1
    if n == 11:
        n = -1
   
    nian.append(x)
   
    if len(nian) == 60:
        break

while True:
    w = input('请输入查询的年份： 如2018 或干支 如甲子：')
    print('输入 "q" 退出')
    try:
        if w in nian:
            p = int(nian.index(w)) + 4
            y = cur_year % 60
            print('上一个' + w + '年是：' + str(cur_year - (y -p)))
            print('下一个' + w + '年是：' + str(cur_year + (y -p)))
        elif w == 'q':
            break
        elif type(int(w)) == int:
            n = (int(w)) % 60 - 4
            print(nian[n])
        else:
            print('请按套路出牌')
    except ValueError:
        print('请按套路出牌')

噬魂之诗

import datetime

cur_year = datetime.datetime.now().year


tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
nian = []
i = -1
n = -1
while True:
    i += 1
    n += 1
    x = tiangan[i] + dizhi[n]
    if i == 9:
        i = -1
    if n == 11:
        n = -1
   
    nian.append(x)
   
    if len(nian) == 60:
        break

while True:
    w = input('请输入查询的年份： 如2018 或干支 如甲子：')
    print('输入 "q" 退出')
    try:
        if w in nian:
            p = int(nian.index(w)) + 4
            y = cur_year % 60
            print('上一个' + w + '年是：' + str(cur_year - (y -p)))
            print('下一个' + w + '年是：' + str(cur_year + (y -p)))
        elif w == 'q':
            break
        elif type(int(w)) == int:
            n = (int(w)) % 60 - 4
            print(nian[n])
        else:
            print('请按套路出牌')
    except ValueError:
        print('请按套路出牌')

jrro452

import datetime
tiangan = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']
dizhi = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥']
td=[]
s1= 0
s2= 0
while True:
    if s1>=len(tiangan):
        s1=0
    if s2>=len(dizhi):
        s2=0
    SS=tiangan[s1]+dizhi[s2]
    if SS not in td:
        td.append(SS)
    else:
        break
    s1+=1
    s2+=1
while True:
    data = input('输入年份，如2017，或干支，如丁酉：')
    t=data.isdigit()
    if data in td or (t and isinstance(int(data),int)):
        break
    else:
        print('输入错误')
def yearToganzhi(data):
    n = int(data)%10-3
    m = int(data)%12-3
    if n>0:
        gan = tiangan[n-1]
    else:
        gan=tiangan[n-1+10]
    if m>0:
        zhi = dizhi[m-1]
    else:
        zhi = dizhi[m-1+12]
    result = gan+zhi
    return result
def ganzhiToyear(data):
    datanow = datetime.datetime.now().year
    ganzhinow = yearToganzhi(datanow)
    index1 = td.index(ganzhinow)
    index2 = td.index(data)
    if ganzhinow==data:
        yearl= datanow - 60
        yearn= datanow + 60
    elif index1>index2:
        yearl = datanow -(index1-index2)
        yearn = datanow-(index1-index2)+60
    else:
        yearl=datanow+(index2-index1)-60
        yearn=datanow+(index2-index1)
    return (ganzhinow,yearl,yearn)
if t:
    print(yearToganzhi(data))
else:
    a,b,c=ganzhiToyear(data)
    if a == data:
        print('今年%d的正好是%s年'%(datetime.datetime.now().year,data))
        print('上一个%s年是%d'%(data,b))
        print('下一个%s年是%d'%(data,c))
    else:
        print('上一个%s年是%d'%(data,b))
        print('下一个%s年是%d'%(data,c))