Wie kann man feststellen, ob ein Jahr ein Schaltjahr ist?

Ich versuche einen einfachen Taschenrechner, um zu bestimmen, ob oder nicht in einem bestimmten Jahr um ein Schaltjahr handelt.

Per definition ein Schaltjahr ist durch vier teilbar, aber nicht durch hundert, es sei denn, es ist durch vier teilbar hundert.

Hier ist mein code:

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)

Wenn ich versuche, das innerhalb der Python-IDLE, liefert das Modul None. Ich bin mir ziemlich sicher, dass ich bekommen sollte 1900 is a leap year.

InformationsquelleAutor der Frage Anthony | 2012-07-23

python python-2.7

101
```
import calendar
print calendar.isleap(1900)
```
Python bietet diese Funktionen bereits in der Bibliothek-Modul 'Kalender'.

InformationsquelleAutor der Antwort mawueth
34

Als ein one-liner:
```
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)
```
Es ist ähnlich wie die Mark ' s Antwortaber Kurzschlüsse beim ersten test (man beachte die Klammern).

P. Ortiz bemerkt in den Kommentaren, die standard-Bibliothek Kalender.isleap Funktion hat die gleiche Umsetzung.

InformationsquelleAutor der Antwort Eugene Yarmash
14

Testen Sie drei verschiedene Dinge auf n:
```
n % 4
n % 100
n % 400
```
Seit 1900:
```
1900 % 4 == 0
1900 % 100 == 0
1900 % 400 == 300
```
Also 1900 nicht in den if Klausel, weil 1900 % 100 != 0 ist False

Aber 1900 auch nicht in den else Klausel, weil 1900 % 4 != 0 ist auch False

Dies bedeutet, dass die Ausführung erreicht das Ende Ihrer Funktion und nicht sehen, eine return-Anweisung, so gibt es None.

Diese Umschreibung Ihrer Funktion arbeiten sollte, und sollte zurück False oder True je nach der Jahres Zahl, die Sie gehen in es. (Beachten Sie, dass, wie in der anderen Antwort, die Sie haben, um etwas von dem zurückgeben, anstatt es zu drucken.)
```
def leapyr(n):
    if n % 400 == 0:
        return True
    if n % 100 == 0:
        return False
    if n % 4 == 0:
        return True
    else:
        return False
print leapyr(1900)
```
(Algorithmus von Wikipedia)

InformationsquelleAutor der Antwort Sam Mussmann

Die ganze Formel enthalten sein können, in einem einzigen Ausdruck:

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"

InformationsquelleAutor der Antwort Mark Ransom

4

Ihre Funktion nichts zurückgibt, so dass ist, warum, wenn Sie es mit der print - Anweisung erhalten Sie None. Also entweder nur die Funktion aufrufen wie diesem:
```
leapyr(1900)
```
oder ändern Sie Ihre Funktion einen Wert zurückgeben (mit der return - Anweisung), die dann gedruckt werden, indem Sie Ihre print - Anweisung.

Hinweis: Dies ist nicht gegen alle möglichen Probleme, die Sie haben mit Ihrem Schaltjahr-Berechnung, sondern ANTWORTEN auf IHRE SPEZIELLE FRAGE zu warum Sie sind immer None als Ergebnis Ihrer Funktion aufrufen, die in Verbindung mit Ihrer print.

Erklärung:

Einige kurze Beispiele zu dem oben:
```
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
```
Nun wenn ich Sie rufe:
```
print add2(10, 5)
```
gibt es:
```
the result is: 15
None
```
Die erste Zeile stammt aus der print Anweisung innen von add2(). Die None aus der print-Anweisung, wenn ich die Funktion aufrufen add2() die nicht nicht haben eine return-Anweisung verursacht die None gedruckt werden. Übrigens, wenn ich hatte gerade angerufen, die add2() Funktion einfach mit (bitte beachten Sie, keine print - Anweisung):
```
add2()
```
Ich würde bekommen haben nur die Ausgabe der print-Anweisung the result is: 15 ohne die None (sieht aus wie das, was Sie zu tun versuchen).

Vergleichen Sie dies mit:
```
print add2_New(10, 5)
```
gibt:
```
15
```
In diesem Fall wird das Ergebnis berechnet in der Funktion add2_New() und keine print-Anweisung, und an den Aufrufer zurückgegeben, der Sie dann druckt es wiederum.

InformationsquelleAutor der Antwort Levon

Ein Schaltjahr ist genau teilbar durch 4, außer für die Jahrhundert Jahre (Jahre endet mit 00). Die Jahrhundert Jahre ein Schaltjahr ist nur dann, wenn es perfekt ist, teilbar durch 400. Zum Beispiel,

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))

InformationsquelleAutor der Antwort Mohammed Elzanaty

Wenn Sie nicht wollen, um import calendar und gelten .isleap Methode können Sie versuchen, diese:

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

InformationsquelleAutor der Antwort Salam

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.