I am trying to make a simple calculator to determine whether or not a certain year is a leap year.
By definition, a leap year is divisible by four, but not by one hundred, unless it is divisible by four hundred.
Here is my 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))
When I try this inside the Python IDLE, the module returns None. I am pretty sure that I should get 1900 is a leap year.
Use calendar.isleap:
import calendar
print(calendar.isleap(1900))
As a one-liner function:
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)
It's similar to the Mark's answer, but short circuits at the first test (note the parenthesis).
Alternatively, you can use the standard library's calendar.isleap, which has exactly the same implementation:
from calendar import isleap
print(isleap(1900)) # False
You test three different things on n:
n % 4
n % 100
n % 400
For 1900:
1900 % 4 == 0
1900 % 100 == 0
1900 % 400 == 300
So 1900 doesn't enter the if clause because 1900 % 100 != 0 is False
But 1900 also doesn't enter the else clause because 1900 % 4 != 0 is also False
This means that execution reaches the end of your function and doesn't see a return statement, so it returns None.
This rewriting of your function should work, and should return False or True as appropriate for the year number you pass into it. (Note that, as in the other answer, you have to return something rather than print it.)
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)
(Algorithm from Wikipedia)
The whole formula can be contained in a single expression:
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"
Your function doesn't return anything, so that's why when you use it with the print statement you get None. So either just call your function like this:
leapyr(1900)
or modify your function to return a value (by using the return statement), which then would be printed by your print statement.
Note: This does not address any possible problems you have with your leap year computation, but ANSWERS YOUR SPECIFIC QUESTION as to why you are getting None as a result of your function call in conjunction with your print.
Explanation:
Some short examples regarding the above:
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
Now when I call them:
print add2(10, 5)
this gives:
the result is: 15
None
The first line comes form the print statement inside of add2(). The None from the print statement when I call the function add2() which does not have a return statement, causing the None to be printed. Incidentally, if I had just called the add2() function simply with (note, no print statement):
add2()
I would have just gotten the output of the print statement the result is: 15 without the None (which looks like what you are trying to do).
Compare this with:
print add2_New(10, 5)
which gives:
15
In this case the result is computed in the function add2_New() and no print statement, and returned to the caller who then prints it in turn.
A leap year is exactly divisible by 4 except for century years (years ending with 00). The century year is a leap year only if it is perfectly divisible by 400. For example,
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))
If you don't want to import calendar and apply .isleap method you can try this:
def isleapyear(year):
if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
return True
return False
In the Gregorian calendar, three conditions are used to identify leap years:
The year can be evenly divided by 4, is a leap year, unless:
The year can be evenly divided by 100, it is NOT a leap year, unless:
The year is also evenly divisible by 400. Then it is a leap year.
This means that in the Gregorian calendar, the years 2000 and 2400 are leap years, while 1800, 1900, 2100, 2200, 2300 and 2500 are NOT leap years. source
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")
The logic in the "one-liner" works fine. From personal experience, what has helped me is to assign the statements to variables (in their "True" form) and then use logical operators for the result:
A = year % 4 == 0
B = year % 100 == 0
C = year % 400 == 0
I used '==' in the B statement instead of "!=" and applied 'not' logical operator in the calculation:
leap = A and (not B or C)
This comes in handy with a larger set of conditions, and to simplify the boolean operation where applicable before writing a whole bunch of if statements.
An alternative one liner:
((((y % 4) + (int((y - (y % 100)) / y) * ((y % 400) / 100))) - 1) < 0)
This was something that I put together for fun (?) that is also 1:1 compatible with C.
(y % 4) >>>It first checks if the year is a leap year via the typical mod-4 check.
(int((y - (y % 100)) / y) >>>It then accounts for those years divisible by 100. If the year is evenly divisible by 100, this will result in a value of 1, otherwise it will result in a value of 0.
((y % 400) / 100))) >>>Next, the year is divided by 400 (and subsequently 100, to return 1, 2, or 3 if it is not.
These two values
(int(y - (y % 100)) / y)
&
((y % 400) / 100)))
are then multiplied together. If the year is not divisible by 100, this will always equal 0, otherwise if it is divisible by 100, but not by 400, it will result in 1, 2, or 3. If it is divisible by both 100 and 400, it will result in 0.
This value is added to (y % 4), which will only be equal to 0 if the year is a leap year after accounting for the edge-cases.
Finally, 1 is subtracted from this remaining value, resulting in -1 if the year is a leap year, and either 0, 1, or 2 if it is not. This value is compared against 0 with the less-than operator. If the year is a leap year this will result in True (or 1, if used in C), otherwise it will return False (or 0, if used in C).
Please note: this code is horribly inefficient, incredibly unreadable, and a detriment to any code attempting to follow proper practices. This was an exercise of mine to see if I could do so, and nothing more.
Further, be aware that ZeroDivisionErrors are a consequence of the input year equaling 0, and must be accounted for.
For example, a VERY basic timeit comparison of 1000 executions shows that, when compared against an equivalent codeblock utilizing simple if-statements and the modulus operator, this one-liner is roughly 5 times slower than its if-block equivalent.
That being said, I do find it highly entertaining!
The missing part is the use of return statement:
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)
I tried solving in this way and it as work for me like a charm !!!
Logic I applied to find leap year or not
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) ] )
Output :
[True, False, True]
[False, False, False]
[True, True, True]
[True, False, False]
[True, False, False]
My code :
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')
Output :
Not Leap Year
Incase you find any issue in my code feel free to guide me
From 1700 to 1917, official calendar was the Julian calendar. Since then they we use the Gregorian calendar system. The transition from the Julian to Gregorian calendar system occurred in 1918, when the next day after January 31st was February 14th. This means that 32nd day in 1918, was the February 14th.
In both calendar systems, February is the only month with a variable amount of days, it has 29 days during a leap year, and 28 days during all other years. In the Julian calendar, leap years are divisible by 4 while in the Gregorian calendar, leap years are either of the following:
Divisible by 400.
Divisible by 4 and not divisible by 100.
So the program for leap year will be:
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
def leap():
year = int(input("enter a number: "))
if year == range(300,2000):
print(year/400)
elif year == range(2001,2024):
print(year/4)
leap()
so I am trying to create a function that calculates if the year is a leap year, but it seems it does not want to show the answer of the leap year. there is no error message when I run the code,
also, I am doing this in visual studio code.
The object returned by range(300, 2000) has a type that is different than year, in your case an int. We can see this in the REPL:
>>> r = r(300, 2000)
>>> r
range(300, 2000)
>>> type(r)
<class 'range'>
Typically, comparing values of two types will not lead to equality. For this reason == is not what you're looking for.
Ranges are a builtin type in Python, which implements all the common sequence operators. This is why what you're looking for is:
if year in range(300, 2000):
...
This clause will operate as you expect. Note that it does not scan the list, and is in fact take O(1) time, not O(n).
However, it is probably easier to simply see if your values are within the expected parameters using a direct integer comparison:
if year >= 300 and <= 2000:
...
You can do it this way simply:
def leap():
year = int(input("enter a number: "))
if 300 <= year < 2000:
print(year/400)
elif 2001 <= year < 2024:
print(year/4)
leap()
Or use in instead of ==
i believe this will determine a leap year
def leap():
year = int(input("enter a number: "))
if year % 400 == 0:
print('leap year')
elif year % 4 ==0 and year % 100 != 0:
print('leap year')
else:
print('not a leap year')
leap()
leap()
I am trying to solve this question with this code:
is_leap_year = False
not_leap_year = True
input_year = int(input())
if (input_year % 4 == 0 or input_year % 400 == 0):
print(input_year, '- leap year')
elif (input_year % 4 != 0 and input_year % 400 != 0):
print(input_year, '- not a leap year')
Why is my code still reading 1900 as a leap year?
Divisibility by 400 is an exception to the rule that years divisible by 100 are not leap years, which itself is an exception to the rule that years divisible by 4 are leap years. If you wrote it out in sequence, you might write
if year % 400 == 0: # Some centuries are leap years...
print("leap year")
elif year % 100 == 0: # ... but most are not ...
print("not leap year")
elif year % 4 == 0: # ... even though other divisibly-by-four years are
print("leap year")
else:
print("not leap year")
or work your way up
if year % 4 != 0:
print("not a leap year")
elif year % 100 != 0:
print("leap year")
elif year % 400 != 0:
print("not a leap year")
else:
print("leap year")
Combining these into a single test would be something like
if year % 4 != 0 or (year % 100 == 0 and year % 400 != 0):
print("not a leap year")
else:
print("leap year")
which I find a little harder to follow than a series of simple tests.
(Given the nature of a solar year, making every year divisible by 400 a leap year is also a problem, though not as big a one as making every century year a leap year. People wanting to avoid drifts over the millenia will propose additional exceptions like "years divisible by 4000, or 40,000, or something, should not be leap years"; no official rule exists yet, though.)
Because 1900 % 4 is actually 0, so the first if conditional is True ( True or False is True) and then it doesn't execute the second if block because is an elif (else if, and since the first was True, there is no need to execute the else part).
Try like this!
year = int(input("Input year: "))
if year % 4 == 0:
print("Year is leap.")
if year % 100 == 0 and year % 400 != 0:
print("Year is common.")
else:
print("Year is common.")
Because the first condition input_year % 4 == 0 evaluates to True.
1900/4= 475 => input_year%4 == 0 is True => for your code 1900 is a leap year
1901/4 = 475,25 => input_year%4 == 0 is false => for your code 1901 is not a leap year
1900 is not a leap year, your calculation is not correct.
here is the code for leap year calculation:
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))
You can write a simplified function taking advantage of Truthy/Falsely
if not(year % 400) or (not(year % 4) and year % 100) : return True
return False```
print(isLeapYear(1900)) # False
print(isLeapYear(1896)) # True
Instead of "or" use "and" in the first if statement.
Both conditions need to be met.
I have started learning Python and came across this code:This is leap year program.
Why are we defining leap = False .The output will be true or false.
def is_leap(year):
leap = False
return year % 4 == 0 and (year % 400 == 0 or year % 100 != 0)
year = int(input())
print(is_leap(year))
We don't need to define leap=False since it is not being used in the code, so you can just remove it and do.
def is_leap(year):
return year % 4 == 0 and (year % 400 == 0 or year % 100 != 0)
year = int(input())
print(is_leap(year))
A bad way to write this and use leap will be
def is_leap(year):
leap = year % 4 == 0 and (year % 400 == 0 or year % 100 != 0)
return leap
year = int(input())
print(is_leap(year))
The leap variable in this function isn't even used, and as you assumed, that line is just redundant, and can (should!) be removed.