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?

A leap year program in Python helps you check if a year has 366 days. But there’s a catch: the logic isn’t just “divisible by 4.”

A year must be divisible by 4 to qualify, but if it is also divisible by 100, it must then be divisible by 400 to truly be a leap year. While this logic seems clear, implementing it in Python can be a challenge for beginners.

If you’re searching for a simple program to find leap year in Python, or wondering how to create a leap year program in Python using functions, this tutorial walks you through it—step by step.

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.

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

How upGrad can help you?

With upGrad, you can access global standard education facilities right here in India. upGrad also offers free Python 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 Machine Learning and Deep Learning
• 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

• How to Check Prime Number in Python
• Pattern Program in Python
• Difference Between List and Tuple in Python
• Difference between List, Tuple, Set, and Dictionary in Python
• Order Precedence in Python

FAQ’s

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

There are 7 different methods to check if a year is a leap year in Python:

1. If-else statement: A simple condition-based approach.
2. Nested if-else: Adds hierarchical logic for conditions.
3. Ternary Operator: A concise single-line implementation.
4. For Loops: Checks the condition in an iterative structure (less commonly used for leap year logic).
5. While Loop: Also iterative, can be used for continuous user input.
6. Python Libraries - calendar.isleap(): A built-in function for checking leap years.
7. Lambda Function: A compact, functional programming approach for leap year verification.

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

The calendar module in Python provides a built-in method calendar.isleap(year), which checks if a given year is a leap year. It returns True if the year is a leap year and False otherwise.

Example:

import calendar
year = 2024
if calendar.isleap(year):
    print(f"{year} is a leap year")
else:
    print(f"{year} is not a leap year")

Advantages:

• Simplifies the implementation.
• Highly reliable and optimized for performance.
• Can be used in scenarios requiring leap year checks in multiple places.

3. What’s the logic behind the leap year conditions in Python?

The logic is based on the Gregorian calendar rules:

1. A year is a leap year if:

1. • It is divisible by 4.
   • But not divisible by 100, unless it is also divisible by 400.

2. Mathematically, the conditions can be expressed as:(year % 4 == 0) and (year % 100 != 0 or year % 400 == 0)

Explanation:

• Years divisible by 4 are typically leap years.
• However, years divisible by 100 are not leap years (e.g., 1900 is not a leap year).
• Exception: Years divisible by 400 are leap years (e.g., 2000 is a leap year).

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

Advanced techniques for implementing leap year programs include:

1. Lambda Functions:

• Use a functional programming approach for compact code.

is_leap = lambda year: (year % 4 == 0) and (year % 100 != 0 or year % 400 == 0)
print(is_leap(2024))

2. Using the calendar module:
3. • Leverage the built-in isleap() method for reliability and reusability.
3. List Comprehension:
4. • Generate a list of leap years from a given range of years.

leap_years = [year for year in range(2000, 2100) if calendar.isleap(year)]
print(leap_years)

4. Integration with Datetime:
5. • Combine leap year checks with other date-related functionalities for robust date validation systems.
5. Handling User Input with While Loops:
6. • Use loops to validate user input and re-prompt until valid input is provided.

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

A while loop can be used to ensure that the user provides valid input (e.g., a positive integer) for checking leap years. If the input is invalid, the program can re-prompt the user until valid input is provided.

Example:

while True:
    try:
        year = int(input("Enter a year to check if it is a leap year: "))
        if year <= 0:
            print("Year must be a positive integer. Try again.")
            continue
        break
    except ValueError:
        print("Invalid input. Please enter a valid integer.")
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")

Advantages:

• Ensures robust input handling.
• Prevents crashes due to invalid input (e.g., strings or negative numbers).
• Enhances user experience by prompting for corrections.

Take our Free Quiz on Python

Answer quick questions and assess your Python knowledge

Start Quiz