Leap Year Program in Python: 7 Ways to Check Using Functions and Logic

How does Python know if a year is a leap year or not?

Is it just every four years—or is there more to it?

Checking for a leap year seems simple, but it's a fantastic problem for practicing conditional logic in Python. The challenge lies in correctly implementing the rules: a year must be divisible by 4, unless it's a century year, in which case it must also be divisible by 400. 

In this step-by-step tutorial, we'll create a leap year program in Python from scratch. You'll learn how to handle user input and write the conditional logic, including how to structure your code as a leap year program in Python using functions. This is a fundamental exercise for any new programmer. 

We’ll cover both basic and function-based approaches, making it easy to understand and implement. Want to level up your Python skills? Explore our Data Science Courses and Machine Learning Courses designed for hands-on practice with real-world problems.

Want to level up your Python skills? Explore our Data Science Courses and Machine Learning Courses designed for hands-on practice with real-world problems. 

Let’s get started!

How to Check Leap Year in Python

A leap year is a year that has an extra day, making it 366 days long instead of the usual 365 days. This additional day is added to February, resulting in February having 29 days instead of 28.

The purpose of leap years is to keep our calendar aligned with the Earth's revolutions around the Sun, which takes approximately 365.2425 days.

Divisibility Conditions to Check Leap Year in Python

To determine whether a year is a leap year, specific divisibility rules must be followed:

• Divisible by 4: The primary rule states that any year that is evenly divisible by 4 is a leap year. For example, years like 2020 and 2016 are leap years because they can be divided by 4 without a remainder.
• Divisible by 100: However, if the year is divisible by 100, it is not automatically considered a leap year. For instance, the year 1900 is divisible by 100 but is not a leap year because it does not meet the next condition.
• Divisible by 400: If a year is divisible by both 100 and 400, then it is classified as a leap year. For example, the year 2000 is a leap year because it meets this criterion (divisible by both 100 and 400), while the year 1900 does not qualify as it is only divisible by 100

Examples of Leap Years

Leap Years:

• 2000: Divisible by both 100 and 400.
• 2016: Divisible by 4 but not by 100.
• 2020: Divisible by 4 but not by 100.

Non-Leap Years:

• 1900: Divisible by 100 but not by 400.
• 2100: Divisible by 100 but not by 400.
• 2019: Not divisible by 4.

Looking to bridge the gap between Python practice and actual ML applications? A formal Data Science and Machine Learning course can help you apply these skills to real datasets and industry workflows.

• Master’s Degree in Artificial Intelligence and Data Science
• Executive Programme in Generative AI for Leaders
• Generative AI Foundations Certificate Program

Summary of Leap Year Condition in Python

7 Different Methods to Check Leap Year in Python

1. If-else statement

# Function to check if a year is a leap year using if-else statements

def is_leap_year(year):
    # Check if the year is divisible by 4
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        return True  # Year is a leap year
    else:
        return False  # Year is not a leap year
# Example usage
year = int(input("Enter a year: "))
if is_leap_year(year):
    print(f"{year} is a leap year.")
else:
    print(f"{year} is not a leap year.")

Output:

Enter a year: 2025

2025 is not a leap year.

2. Nested if-else

# Function to check if a year is a leap year using nested if-else statements

def is_leap_year(year):
    if year % 4 == 0:  # First condition
        if year % 100 == 0:  # Second condition
            if year % 400 == 0:  # Third condition
                return True  # Year is a leap year
            else:
                return False  # Year is not a leap year
        else:
            return True  # Year is a leap year
    else:
        return False  # Year is not a leap year

# Example usage
year = int(input("Enter a year: "))
if is_leap_year(year):
    print(f"{year} is a leap year.")
else:
    print(f"{year} is not a leap year.")

Output:

Enter a year: 2024

2024 is a leap year.

“Start your coding journey with our complimentary Python courses designed just for you — dive into Python programming fundamentals, explore key Python libraries, and engage with practical case studies!”

3. Ternary Operator

# Function to check if a year is a leap year using the ternary operator

def is_leap_year(year):
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
# Example usage
year = int(input("Enter a year: "))
print(f"{year} is {'a leap year' if is_leap_year(year) else 'not a leap year'}.")

Output:

Enter a year: 2023

2023 is not a leap year.

4. For Loops

# Function to check multiple years for leap years using a for loop

def check_multiple_years(start_year, end_year):
    print(f"Leap years between {start_year} and {end_year}:")
    for year in range(start_year, end_year + 1):
        if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
            print(year)  # Print the leap year
# Example usage
start_year = int(input("Enter the start year: "))
end_year = int(input("Enter the end year: "))
check_multiple_years(start_year, end_year)

Output:

Enter the start year: 1995

Enter the end year: 2025

Leap years between 1995 and 2025:

1996

2000

2004

2008

2012

2016

2020

2024

5. While Loop

# Loop until valid input for the year is provided

while True:
    try:
        year = int(input("Enter a year: "))  # Request user input
        if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
            print(f"{year} is a leap year.")
        else:
            print(f"{year} is not a leap year.")
        break  # Exit loop after successful input and processing
    except ValueError:
        print("Invalid input. Please enter an integer value for the year.")

Output:

Enter a year: 2022

2022 is not a leap year.

6. Python Libraries - calendar.isleap()

import calendar

# Check if the given year is a leap year using the calendar module's isleap function
def check_leap_with_calendar(year):
    if calendar.isleap(year):
        return True   # Year is a leap year
    else:
        return False   # Year is not a leap year

# Example usage
year = int(input("Enter a year: "))
if check_leap_with_calendar(year):
    print(f"{year} is a leap year.")
else:
    print(f"{year} is not a leap year.")

# Benefits of Using Built-in Functions:
# - Simplifies code by leveraging Python's built-in functionality.
# - Reduces potential errors by using well-tested library functions.

Output:

Enter a year: 2021

2021 is not a leap year.

7. Lambda Function

# Using lambda function to check for leap years

is_leap_year = lambda year: (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
# Example usage
year = int(input("Enter a year: "))
print(f"{year} is {'a leap year' if is_leap_year(year) else 'not a leap year'}.")

Output:

Enter a year: 2020

2020 is a leap year.

Performance Analysis of Different Methods Using Time Complexity and Space Complexity

Note: The calendar.isleap() method is the most practical for readability and reusability, especially for production code. The if-else statement or ternary operator is ideal for minimalistic code.

MCQs on Leap Year Program in Python

1. Which year is a leap year?

a) 1900

b) 2000

c) 2023

d) 2021

2. How many days are there in a leap year?

a) 364

b) 365

c) 366

d) 367

3. Which condition correctly checks if a year is divisible by 4 in Python?

a) if year / 4 == 0:

b) if year % 4 == 0:

c) if year = 4:

d) if year == 4:

4. Which function can be used to take user input in Python?

a) input()

b) scanf()

c) raw_input()

d) gets()

5. What is the output of 2024 % 100 == 0?

a) True

b) False

c) Error

d) None

6. Which logic checks for leap year correctly?

a) Year divisible by 2

b) Year divisible by 4 but not by 100

c) Year divisible by 10 only

d) Year divisible by 3 and 5

7. What is the correct order of leap year conditions?

a) Divisible by 100 then by 400

b) Divisible by 4 then by 100 but not by 400

c) Divisible by 4 and not by 100, unless divisible by 400

d) Only divisible by 400

8. Which of the following returns True for the year 2000 using a leap year function?

a) is_leap(2000)

b) leap_year(2000)

c) check_leap(2000)

d) All of the above (if defined)

9. You are asked to write a function is_leap(year) to return True or False. What should be its first condition?

a) if year % 4 == 0:

b) if year % 100 == 0:

c) if year % 400 == 0:

d) if year == 0:

10. A user enters the year 2100. Your leap year program returns True. What is likely wrong in the code?

a) It didn’t check divisibility by 100

b) It used input() wrong

c) It missed return statement

d) It used while instead of if

11. You want to write a leap year program using a Python function and take year as input. Which structure is best?

a) def leap():

b) def leap(year):

c) def year(leap):

d) def check():

Conclusion 

You've now successfully built a leap year program in Python, mastering the tricky conditional logic that trips up many beginners. This exercise is more than just a simple problem, it's a perfect example of how to translate complex rules into clean, effective code. 

By creating a leap year program in Python using functions, you've also learned how to write reusable and organized code, a fundamental skill for any developer. Keep practicing with these kinds of challenges, and you'll be well on your way to tackling even more complex programming problems. 

How upGrad can help you?

With upGrad, you can access global standard education facilities right here in India. upGrad also offers free Data Science Courses that come with certificates, making them an excellent opportunity if you're interested in data science and machine learning.

By enrolling in upGrad's Python courses, you can benefit from the knowledge and expertise of some of the best educators from around the world. These instructors understand the diverse challenges that Python programmers face and can provide guidance to help you navigate them effectively.

So, reach out to an upGrad counselor today to learn more about how you can benefit from a Python course.

Here are some of the best data science and machine learning courses offered by upGrad, designed to meet your learning needs:

• Professional Certificate Program in Business Analytics & Consulting in association with PwC India
• Advanced Certificate Program in Generative AI
• Post Graduate Certificate in Data Science & AI (Executive)
• Executive Program in Generative AI for Business Leaders
• Post Graduate Programme in Data Science & AI (Executive)
• Master of Science in Machine Learning & AI
• Master’s Degree in Artificial Intelligence and Data Science
• Doctor of Business Administration in Emerging Technologies with Specialization in Generative AI

Similar Reads: Top Trending Blogs of Python

• Prime Number in Python: 7 Easy Methods with Code and Explanation 
• Master Pattern Program in Python: 20+ Star & Number Patterns with Code 
• Difference Between List and Tuple in Python
• List, Tuple, Set, Dictionary in Python: Key Differences with Examples 
• Precedence of Operators in Python: Complete Guide with Examples 

FAQ’s

1. What is the logic behind the leap year conditions in Python? 

The logic for a leap year program in Python is based on the rules of the Gregorian calendar, which was designed to keep the calendar year synchronized with the astronomical year. A year is a leap year if it is divisible by 4, except for end-of-century years, which must be divisible by 400. This can be expressed in code as: (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0). This logic correctly identifies years like 2024 as leap years (divisible by 4 but not 100) and 2000 as a leap year (divisible by 400), while correctly identifying 1900 as a common year (divisible by 100 but not 400). 

2. Why was the Gregorian calendar and its leap year rule created?  

The Gregorian calendar was introduced in 1582 to correct for a small inaccuracy in the Julian calendar that preceded it. The Earth's orbit around the sun is approximately 365.2425 days, not exactly 365.25 as the Julian calendar assumed. By skipping leap years on most century years, the Gregorian rule brings the average length of a calendar year much closer to the actual solar year. This historical context is interesting to know when creating a leap year program in Python. 

3. What are the different methods to check if a year is a leap year in Python?  

There are several methods to create a leap year program in Python, each with its own advantages. The most common is using a simple if-else statement or a nested if-else to check the conditions. For more concise code, a ternary operator can be used to write the logic in a single line. For the simplest and most reliable solution, you can use the built-in calendar.isleap() function. More advanced techniques include wrapping the logic in a lambda function for a functional approach. 

4. How can you use the calendar module to determine leap years in Python?  

The calendar module in Python provides a built-in, highly optimized function called calendar.isleap(year). This is the most straightforward and recommended method for a leap year program in Python. You simply import the calendar module and then pass the year you want to check to this function. It will return True if the year is a leap year according to the Gregorian rules, and False otherwise. This approach is not only simpler to write but also less prone to logical errors than implementing the conditions manually. 

5. What are some advanced techniques for writing a leap-year program in Python? 

Beyond a simple if-else check, you can use more advanced Python features. A lambda function can define the entire logic in a single, anonymous function: is_leap = lambda year: (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0). You can also use a list comprehension to generate a list of all leap years within a specific range, for example: leap_years = [year for year in range(2000, 2100) if calendar.isleap(year)]. This showcases more advanced, "Pythonic" ways to structure your leap year program in Python. 

6. How do you write a leap year program in Python using functions?  

Creating a leap year program in Python using functions is the best practice for writing clean and reusable code. You would define a function, for example check_leap_year(year), that takes the year as a parameter. Inside this function, you would place your conditional logic and return a boolean value (True or False). Your main program can then call this function whenever it needs to check a year. This separates the core logic from the user input and output, making your code much more organized and easier to debug. 

7. How can you use a while loop to validate user input for a leap-year program?  

A while loop is an excellent tool for ensuring that your leap year program in Python receives valid input from the user. You can wrap your input prompt inside a while True: loop and use a try-except block to catch ValueError if the user enters a non-integer. You can also add a condition to check if the year is a positive number. If the input is valid, you can use the break statement to exit the loop; otherwise, you can print an error message and the loop will continue, re-prompting the user. 

8. What is the difference between using a ternary operator and an if-else statement?  

Both are used for conditional logic, but they differ in syntax and use case. An if-else statement is a multi-line block that is used to execute different sets of statements based on a condition. A ternary operator, on the other hand, is a single-line expression that evaluates to a value. For a simple leap year program in Python, a ternary operator can be very concise, for example: result = "Leap Year" if is_leap else "Not a Leap Year". However, for more complex logic, a full if-else statement is more readable. 

9. How do I handle the year 0 in a leap year program?  

The Gregorian calendar, upon which the leap year rules are based, does not have a year 0; it goes from 1 BC to 1 AD. Therefore, a robust leap year program in Python should treat year 0 (and any negative years) as invalid input. You can add a condition at the beginning of your function, such as if year <= 0:, to handle this edge case and inform the user that the input is out of the valid range. 

10. What is the time complexity of a typical leap year check? 

The time complexity for checking a single year is O(1), which means it takes a constant amount of time, regardless of the value of the year. This is because a leap year program in Python performs a fixed number of simple arithmetic operations (a few modulo checks and logical comparisons). The calculation does not become more complex or take longer for a large year like 2024 versus a smaller year like 4. 

11. Can I use a dictionary to create a leap year checker?  

While not a standard approach, you could use a dictionary to mimic the conditional logic. For example, you could use a boolean result of a condition as a key to look up the answer. result = {True: "Leap Year", False: "Not a Leap Year"}[(year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)] This is a clever but less readable alternative for a leap year program in Python. 

12. How would I write a program to find the next N leap years from a given year? 

To do this, you would start with the given year and use a while loop that continues until a list of N leap years has been collected. Inside the loop, you would check if the current year is a leap year using your leap year logic. If it is, you add it to your list. At the end of each iteration, you increment the year. This is a great way to combine the logic of a leap year program in Python using functions with iterative programming. 

13. What are some common mistakes to avoid when writing this program? 

A very common mistake is to only check if the year is divisible by 4, completely forgetting the century year rules. Another is to implement the logic incorrectly, for example, using and where an or is needed. Forgetting to handle non-integer or negative inputs is also a frequent oversight. A good leap year program in Python must be logically correct and robust against bad input. 

14. How does the datetime module handle leap years?  

Python's datetime module is fully aware of the leap year rules. If you try to create a date object for a non-existent date, like February 29th of a common year (e.g., datetime.date(2023, 2, 29)), it will raise a ValueError. This is an implicit way to check for a leap year, though using the calendar.isleap() function is more direct. 

15. What is the history behind leap years?  

Leap years were introduced by Julius Caesar in 45 BC with the Julian calendar, which simply added an extra day every four years. This was an oversimplification, and over the centuries, the calendar drifted out of sync with the seasons. The more precise Gregorian calendar, which we use today, was introduced in 1582 to correct this drift by adding the more complex rules about century years. This history is the reason why a leap year program in Python has its specific set of logical conditions. 

16. How can I test my leap year program?  

Thorough testing is crucial. You should test your leap year program in Python with several categories of years. Include a year that is divisible by 4 but not 100 (e.g., 2024), a year that is divisible by 100 but not 400 (e.g., 1900), a year that is divisible by 400 (e.g., 2000), and a year that is not divisible by 4 (e.g., 2023). This will ensure all branches of your conditional logic are working correctly. 

17. How can I make my program's output more user-friendly? 

Instead of just printing "True" or "False," you can use f-strings to provide a more descriptive and user-friendly output, such as f"{year} is a leap year." or f"{year} is not a leap year.". You can also wrap your main logic in a loop, as shown in a previous question, to allow the user to check multiple years without having to restart the program each time. 

18. Why is this a good project for a beginner? 

The leap year program in Python is a classic beginner project because it is the perfect exercise for practicing fundamental programming concepts. It requires you to use variables, user input, and, most importantly, conditional logic (if-else statements). It's a simple problem with a slightly tricky set of rules, which teaches you the importance of translating detailed requirements into accurate code. 

19. How can I learn to solve more Python challenges like this?  

The best way to improve is by combining structured learning with consistent practice. A comprehensive program, like the Python programming courses offered by upGrad, can provide a strong foundation and expert guidance. You should also regularly practice solving problems on coding challenge websites. This will expose you to a wide variety of challenges and help you master the core logic needed to write any leap year program in Python using functions and much more. 

20. What is the main takeaway from building a leap year program? 

The main takeaway is the importance of attention to detail and accurately translating a set of rules into logical code. The leap year program in Python is a perfect example of a problem that seems simple on the surface but has a few crucial edge cases (the century years). It teaches a beginner that successful programming is not just about writing code, but about fully understanding the problem's requirements first. 

Take our Free Quiz on Python

Answer quick questions and assess your Python knowledge

Start Quiz