如何判断某一年份是否是闰年？

问题描述：

我正在尝试制作一个简单的计算器来确定某一年是否是闰年。

根据定义，闰年可以被四整除，但不能被一百整除，除非它可以被四百整除。

这是我的代码：

def leapyr(n):
    if n%4==0 and n%100!=0:
        if n%400==0:
            print(n, "is a leap year.")
    elif n%4!=0:
        print(n, "is not a leap year.")
print(leapyr(1900))

当我在 Python IDLE 中尝试此操作时，模块返回None。我非常确定我应该得到1900 is a leap year。

解决方案 1：

使用calendar.isleap：

import calendar
print(calendar.isleap(1900))

解决方案 2：

作为单行函数：

def is_leap_year(year):
    """Determine whether a year is a leap year."""

    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

它与马克的答案类似，但在第一次测试时短路（注意括号）。

或者，您可以使用标准库的calendar.isleap，它具有完全相同的实现：

from calendar import isleap
print(isleap(1900))  # False

解决方案 3：

你在 n 上测试三种不同的东西：

n % 4
n % 100
n % 400

对于 1900 年：

1900 % 4 == 0
1900 % 100 == 0
1900 % 400 == 300

因此 1900 不属于该if条款，1900 % 100 != 0因为False

但 1900 也不属于该else条款，因为1900 % 4 != 0也是False

这意味着执行到达函数的末尾并且没有看到返回语句，因此它返回None。

重写您的函数应该可以工作，并且应该返回False或True适当返回您传递给它的年份数字。（请注意，与其他答案一样，您必须返回某些内容而不是打印它。）

def leapyr(n):
    if n % 400 == 0:
        return True
    if n % 100 == 0:
        return False
    if n % 4 == 0:
        return True
    return False
print leapyr(1900)

（算法来自维基百科）

解决方案 4：

整个公式可以包含在一个表达式中：

def is_leap_year(year):
    return (year % 4 == 0 and year % 100 != 0) or year % 400 == 0

print n, " is a leap year" if is_leap_year(n) else " is not a leap year"

解决方案 5：

您的函数不返回任何内容，因此当您将其与print语句一起使用时，您会得到None。因此，只需像这样调用您的函数：

leapyr(1900)

或者修改您的函数以返回一个值（通过使用return语句），然后该值将由您的print语句打印出来。

注意：这不能解决您在闰年计算中可能遇到的任何问题，但可以回答您的具体问题，即为什么您会None在与您的函数调用结合时得到这样的结果print。

解释：

有关上述内容的一些简短示例：

def add2(n1, n2):
    print 'the result is:', n1 + n2  # prints but uses no *return* statement

def add2_New(n1, n2):
    return n1 + n2    # returns the result to caller

现在当我打电话给他们时：

print add2(10, 5)

得出：

the result is: 15
None

第一行来自中的print语句。当我调用没有return 语句的函数时， print 语句中的 会打印出来。顺便说一句，如果我只是 简单地用（注意，没有语句）调用该函数：add2()`Noneadd2()None`add2() print

add2()

我本来只会得到the result is: 15没有None（看起来就像您正在尝试做的）的打印语句的输出。

比较一下：

print add2_New(10, 5)

其结果为：

15

在这种情况下，结果在函数中计算add2_New()且没有打印语句，并返回给调用者，然后调用者依次打印它。

解决方案 6：

闰年是指除世纪年（以 00 结尾的年份）外，能被 4 整除的年份。世纪年只有能被 400 整除才是闰年。例如，

if( (year % 4) == 0):
    if ( (year % 100 ) == 0):

        if ( (year % 400) == 0):

            print("{0} is a leap year".format(year))
        else:

            print("{0} is not a leap year".format(year))
    else:

        print("{0} is a leap year".format(year))

else:

    print("{0} is not a leap year".format(year))

解决方案 7：

如果你不想import calendar应用.isleap方法，你可以尝试这个：

def isleapyear(year):
    if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
        return True
    return False

解决方案 8：

在公历中，闰年有三种判断条件：

• 年份能被4整除，即为闰年，除非：

  • 年份可以被 100 整除，则不是闰年，除非：

    • 该年份也能被 400 整除。那么该年就是闰年。

这意味着在公历中，2000 年和 2400 年是闰年，而 1800、1900、2100、2200、2300 和 2500 年不是闰年。来源

def is_leap(year):
    leap = False
    if year % 4 == 0:
        leap = True
        if year % 4 == 0 and year % 100 == 0:
            leap = False
            if year % 400 == 0:
                leap = True 
    return leap

year = int(input())
leap = is_leap(year)

if leap:
  print(f"{year} is a leap year")
else:
  print(f"{year} is not a leap year")

解决方案 9：

“一行”中的逻辑运行良好。从个人经验来看，对我有帮助的是将语句分配给变量（以“True”形式），然后使用逻辑运算符得出结果：

A = year % 4 == 0
B = year % 100 == 0
C = year % 400 == 0

我在 B 语句中使用 '==' 代替“！=”，并在计算中应用“not”逻辑运算符：

leap = A and (not B or C)

这对于一组更大的条件非常有用，并且可以在编写一大堆 if 语句之前简化适用的布尔运算。

解决方案 10：

另一种方式：

((((y % 4) + (int((y - (y % 100)) / y) * ((y % 400) / 100))) - 1) < 0)

这是我为了好玩而组装起来的东西（？），而且与 C 1:1 兼容。

(y % 4)>>>它首先通过典型的 mod-4 检查该年份是否为闰年。

(int((y - (y % 100)) / y)>>>然后它会计算那些可以被 100 整除的年份。如果年份可以被 100 整除，则结果为 1，否则结果为 0。

((y % 400) / 100)))>>>接下来，将年份除以 400（如果不是，则除以 100，以返回 1、2 或 3）。

这两个值

(int(y - (y % 100)) / y)

&

((y % 400) / 100)))

然后将它们相乘。如果年份不能被 100 整除，则结果始终为 0；否则，如果能被 100 整除但不能被 400 整除，则结果为 1、2 或 3。如果能被 100 和 400 整除，则结果为 0。

该值被添加到(y % 4)，考虑到边缘情况后，如果该年份是闰年，则该值仅等于 0。

最后，从剩余值中减去 1，如果该年份是闰年，则结果为 -1，如果不是闰年，则结果为 0、1 或 2。使用小于运算符将该值与 0 进行比较。如果该年份是闰年，则结果为 True（如果在 C 中使用，则结果为 1），否则将返回 False（如果在 C 中使用，则结果为 0）。

请注意：此代码效率极低，难以阅读，并且对任何试图遵循正确做法的代码都有害。这是我的一次练习，看看我是否可以这样做，仅此而已。

此外，请注意 ZeroDivisionErrors 是输入年份等于 0 的结果，必须予以考虑。

例如，对 1000 次执行进行非常基本的 timeit 比较表明，与使用简单 if 语句和模数运算符的等效代码块相比，这一行代码比其 if 块等效代码块慢大约 5 倍。

话虽如此，我确实发现它非常有趣！

解决方案 11：

缺少的部分是 return 语句的使用：

def is_year_leap(year):
    if year % 100 == 0:
        if year %  400 == 0:
            return True
        else:
            return False

    elif year % 4 == 0:
        return True

    else:
        return False

x = is_year_leap(int(input('Enter any year: ')))
print(x)

解决方案 12：

我尝试用这种方式解决，它对我来说非常有效！

我用来判断是否闰年的逻辑

print([ (1900 % 4 == 0 ) , (1900 % 400 == 0) , (1900 % 100 == 0) ] )
print([ (2022 % 4 == 0 ) , (2022 % 400 == 0) , (2022 % 100 == 0) ] )
print([ (2000 % 4 == 0 ) , (2000 % 400 == 0) , (2000 % 100 == 0) ] )
print([ (1896 % 4 == 0 ) , (1896 % 400 == 0) , (1896 % 100 == 0) ] )
print([ (2020 % 4 == 0 ) , (2020 % 400 == 0) , (2020 % 100 == 0) ] )

输出 ：

[True, False, True]
[False, False, False]
[True, True, True]
[True, False, False]
[True, False, False]

我的代码：

yy = 2100

lst = [ (yy % 4  == 0)   , (yy % 400 == 0) , (yy % 100 == 0)  ]

if lst.count(True) in [0,2]:
  print('Not Leap Year')
else:
  print('Leap Year')

输出 ：

Not Leap Year

如果您发现我的代码有任何问题，请随时指导我

解决方案 13：

从 1700 年到 1917 年，官方日历是儒略历。从那时起，我们就使用公历系统。从儒略历到公历系统的过渡发生在 1918 年，当时 1 月 31 日的第二天是 2 月 14 日。这意味着 1918 年的第 32 天是 2 月 14 日。

在两种日历系统中，二月是唯一一个天数可变的月份，闰年有 29 天，其他年份有 28 天。在儒略历中，闰年可以被 4 整除，而在公历中，闰年有以下两种情况之一：

能被 400 整除。

能被 4 整除，但不能被 100 整除。

因此闰年的程序将是：

def leap_notleap(year):

    yr = ''
    if year <= 1917:
        if year % 4 == 0:
            yr = 'leap'
        else:
            yr = 'not leap'
    elif year >= 1919:
        if (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
            yr = 'leap'
        else:
            yr = 'not leap'
    else:
        yr = 'none actually, since feb had only 14 days'

    return yr

解决方案 14：

你可以说我老土，但我只想问一下，你感兴趣的年份的 2 月 29 日是否是有效日期：

import datetime
datetime.datetime.strptime('29022025', '%d%m%Y').date()

^ 返回 ValueError，因为 2025 年 2 月 29 日不是一个日期。