Python Date and Time Exercises: 30 Coding Problems with Solutions

from datetime import datetime

now = datetime.now()
print("Current date and time:", now)Code language: Python (python)

Explanation:

• from datetime import datetime: Imports the datetime class from the built-in datetime module. Note that the module and the class share the same name.
• datetime.now(): Returns the current local date and time as a datetime object, including year, month, day, hour, minute, second, and microsecond.
• print("Current date and time:", now): Displays the datetime object. Python automatically converts it to a readable string in the format YYYY-MM-DD HH:MM:SS.microseconds.

from datetime import datetime

now = datetime.now()
formatted = now.strftime("%d-%b-%Y %I:%M:%S %p")
print("Formatted:", formatted)Code language: Python (python)

Explanation:

• datetime.now(): Retrieves the current local date and time as a datetime object.
• strftime("%d-%b-%Y %I:%M:%S %p"): Converts the datetime object to a formatted string. The format codes are: %d for zero-padded day, %b for abbreviated month name, %Y for full year, %I for 12-hour hour, %M for minutes, %S for seconds, and %p for AM/PM.
• print("Formatted:", formatted): Prints the resulting string. Unlike the raw datetime object, this output is fully controlled by your chosen format.

from datetime import datetime

date = datetime(2025, 1, 15)
day_name = date.strftime("%A")
print("Day of the week:", day_name)Code language: Python (python)

Explanation:

• datetime(2025, 1, 15): Creates a datetime object for January 15, 2025. You can substitute any valid year, month, and day values.
• strftime("%A"): The %A format code returns the full name of the weekday for the given date, such as Monday or Wednesday.
• Alternative: date.weekday() returns an integer from 0 (Monday) to 6 (Sunday). You can use a list like days = ["Monday", ..., "Sunday"] and index into it with days[date.weekday()].

from datetime import datetime

dt = datetime(2025, 6, 15, 10, 30, 45)
dt_string = str(dt)
print("DateTime as string:", dt_string)Code language: Python (python)

Explanation:

• datetime(2025, 6, 15, 10, 30, 45): Creates a datetime object for June 15, 2025 at 10:30:45. The arguments are year, month, day, hour, minute, and second.
• str(dt): Converts the datetime object to its default string representation in the format YYYY-MM-DD HH:MM:SS. This is equivalent to calling dt.strftime("%Y-%m-%d %H:%M:%S").
• Note: The resulting value is a plain Python string – you can concatenate it, write it to a file, or include it in a JSON object directly.

from datetime import datetime

dt = datetime(2025, 8, 20, 14, 35, 50)

print("Year:", dt.year)
print("Month:", dt.month)
print("Day:", dt.day)
print("Hour:", dt.hour)
print("Minute:", dt.minute)
print("Second:", dt.second)Code language: Python (python)

Explanation:

• datetime(2025, 8, 20, 14, 35, 50): Creates a datetime object representing August 20, 2025 at 14:35:50 (2:35 PM).
• dt.year, dt.month, dt.day: These attributes return the date portion as separate integers. For example, dt.month returns 8 for August.
• dt.hour, dt.minute, dt.second: These attributes return the time portion as integers. dt.hour uses a 24-hour clock, so 14 represents 2 PM.

from datetime import datetime

now = datetime.now()
time_ampm = now.strftime("%I:%M %p")
print("Current time:", time_ampm)Code language: Python (python)

Explanation:

• datetime.now(): Returns the current local date and time. Only the time portion is used in this exercise.
• strftime("%I:%M %p"): Formats the time using 12-hour notation. %I produces a zero-padded hour from 01 to 12, %M produces zero-padded minutes, and %p appends AM or PM based on the hour.
• Note: On some platforms, %p may produce lowercase am/pm. If you always want uppercase, use .upper() on the result: now.strftime("%I:%M %p").upper().

from datetime import datetime

now = datetime.now()
time_ms = now.strftime("%H:%M:%S.%f")[:-3]
print("Current time with milliseconds:", time_ms)Code language: Python (python)

Explanation:

• datetime.now(): Captures the current time with microsecond precision. The .microsecond attribute stores a value from 0 to 999999.
• strftime("%H:%M:%S.%f"): Formats the time with hours, minutes, seconds, and microseconds. The %f code always produces 6 digits (e.g., 123456).
• [:-3]: Slices off the last 3 characters from the formatted string, trimming microseconds down to milliseconds. For example, 14:23:45.123456 becomes 14:23:45.123.

from datetime import datetime

date = datetime(2025, 3, 15)
day_of_year = int(date.strftime("%j"))
print("Day of the year:", day_of_year)Code language: Python (python)

Explanation:

• datetime(2025, 3, 15): Creates a datetime object for March 15, 2025. January 1 is day 1, and the count continues through December 31 (day 365 or 366 in a leap year).
• strftime("%j"): Returns the day of the year as a zero-padded 3-character string. For March 15, 2025 it returns "074".
• int(...): Converts the string "074" to the integer 74, removing the leading zero and making the value suitable for arithmetic.

from datetime import date, time, datetime

d = date(2025, 5, 20)
t = time(9, 45, 0)
combined = datetime.combine(d, t)
print("Combined datetime:", combined)Code language: Python (python)

Explanation:

• date(2025, 5, 20): Creates a date-only object representing May 20, 2025. Unlike datetime, this object holds no time information.
• time(9, 45, 0): Creates a time-only object representing 9:45:00 AM. The arguments are hour, minute, and second.
• datetime.combine(d, t): Merges the two objects into a single datetime instance. This is the standard way to assemble a full timestamp when your date and time data come from separate sources.

from datetime import datetime

date_string = "20 January, 2025"
dt = datetime.strptime(date_string, "%d %B, %Y")
print("DateTime object:", dt)Code language: Python (python)

Explanation:

• "20 January, 2025": The input date string. Its structure – day, full month name with a trailing comma, then 4-digit year – must be described precisely in the format argument.
• datetime.strptime(date_string, "%d %B, %Y"): Parses the string into a datetime object. %d matches the day, %B matches the full month name (case-insensitive on most platforms), and %Y matches the 4-digit year. Since no time is present in the string, the time defaults to 00:00:00.
• Note: strptime() is the inverse of strftime(). Where strftime() converts a datetime to a string, strptime() converts a string back into a datetime.

from datetime import datetime, timedelta

date = datetime(2025, 3, 15)
one_week = timedelta(weeks=1)
result = date - one_week

print("Date after subtracting one week:", result)Code language: Python (python)

Explanation:

• timedelta(weeks=1): Creates a duration object representing exactly 7 days. You can also write this as timedelta(days=7) – both are equivalent.
• date - one_week: Subtracts the 7-day duration from the datetime object. Python’s datetime arithmetic handles month and year boundaries automatically, so subtracting a week from March 3rd correctly produces February 24th.
• result: Holds a brand-new datetime object. The original date variable is unchanged, as datetime objects are immutable in Python.

from datetime import datetime, timedelta

date = datetime(2025, 3, 15)
one_week = timedelta(weeks=1)
result = date + one_week

print("Date after adding one week:", result)Code language: Python (python)

Explanation:

• timedelta(weeks=1): Represents a fixed duration of 7 days. The timedelta class also accepts days, hours, minutes, seconds, and microseconds as arguments, which can be combined freely (e.g., timedelta(weeks=1, hours=3)).
• date + one_week: Adds the 7-day duration to the datetime object. Python handles rollovers across month and year boundaries automatically, so adding a week to March 28th correctly produces April 4th.
• result: A new datetime object set to March 22, 2025. The original date variable is unchanged.

from datetime import datetime

date1 = datetime(2025, 1, 1)
date2 = datetime(2025, 3, 15)
delta = date2 - date1

print("Days between dates:", delta.days)Code language: Python (python)

Explanation:

• date2 - date1: Subtracting two datetime objects returns a timedelta object representing the duration between them. No import of timedelta is needed here since you are reading the result, not constructing one.
• delta.days: The .days attribute of a timedelta gives the total whole-day count as an integer. For this example, the 73 days from January 1 to March 15 span across two months and are calculated automatically.
• Note: A timedelta also has .seconds and .microseconds attributes for sub-day precision. To get the total duration in seconds, use delta.total_seconds() instead.

from datetime import datetime

timestamp = 1672531200
dt = datetime.utcfromtimestamp(timestamp)

print("Datetime from timestamp:", dt)Code language: Python (python)

Explanation:

• 1672531200: A Unix timestamp representing the number of seconds that have passed since the Unix epoch: January 1, 1970 at 00:00:00 UTC. This particular value corresponds to January 1, 2023 at midnight UTC.
• datetime.utcfromtimestamp(timestamp): Converts the integer into a datetime object expressed in UTC. This is the safest choice when the source of the timestamp is a server or API that stores times in UTC, as it avoids any local timezone offset being applied.
• Alternative: datetime.fromtimestamp(timestamp) converts to your local system time instead of UTC. The output will differ depending on the timezone of the machine running the code, so prefer utcfromtimestamp() for portable, consistent results.

from datetime import datetime

date = datetime(2026, 1, 1)
iso_week = int(date.strftime("%V"))

print("ISO week number:", iso_week)Code language: Python (python)

Explanation:

• datetime(2026, 1, 1): Creates a datetime object for January 1, 2026. Under the ISO 8601 standard, this date falls on a Thursday, which means it belongs to week 1 of 2026.
• strftime("%V"): Returns the ISO 8601 week number as a zero-padded 2-character string. %V always counts weeks starting on Monday, and week 1 is defined as the week that contains the first Thursday of the year.
• Alternative: date.isocalendar() returns a named tuple with three fields. You can access the week number directly with date.isocalendar().week, which already returns an integer and makes the intent of the code clearer.

from datetime import datetime, timedelta

now = datetime.now()
delta = timedelta(hours=5, minutes=30)
result = now - delta

print("5 hours and 30 minutes before now:", result)Code language: Python (python)

Explanation:

• timedelta(hours=5, minutes=30): Creates a duration object representing 5 hours and 30 minutes. timedelta accepts keyword arguments like days, hours, minutes, and seconds.
• now - delta: Subtracts the duration from the current datetime. Python’s datetime supports arithmetic with timedelta directly using - and + operators.
• Use case: This pattern is commonly used to compute “N hours ago” timestamps for filtering logs, displaying relative times, or adjusting for time zone differences.

import calendar

def is_leap_year(year):
    return calendar.isleap(year)

year = 2024
print(f"{year} is a leap year: {is_leap_year(year)}")Code language: Python (python)

Explanation:

• calendar.isleap(year): A built-in function from the calendar module that returns True if the given year is a leap year. A year is a leap year if it is divisible by 4, except for century years, which must be divisible by 400.
• def is_leap_year(year): Wrapping the logic in a named function makes it reusable and testable across multiple inputs.
• Alternative: You could implement the leap year logic manually with if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0), but calendar.isleap() is cleaner and less error-prone.

from datetime import date

birthdate = date(1995, 6, 15)
today = date.today()
age_in_days = (today - birthdate).days

print("Age in days:", age_in_days)Code language: Python (python)

Explanation:

• date.today(): Returns the current local date as a date object (without time). It is preferred over datetime.now().date() when only the date portion is needed.
• today - birthdate: Subtracting two date objects produces a timedelta object representing the difference.
• .days: The timedelta attribute that returns the total number of whole days in the duration as an integer.

from datetime import datetime

dt1 = datetime(2025, 1, 1, 9, 0, 0)
dt2 = datetime(2025, 1, 1, 11, 45, 30)

diff = dt2 - dt1
print("Difference in seconds:", diff.total_seconds())Code language: Python (python)

Explanation:

• dt2 - dt1: Subtracting two datetime objects yields a timedelta representing the gap between them. Ensure the later datetime is on the left to avoid a negative result.
• .total_seconds(): Returns the total duration expressed purely in seconds as a float, combining days, seconds, and microseconds into a single value. This is more reliable than accessing .seconds alone, which only covers the seconds component within the final day.
• Verification: 2 hours and 45 minutes and 30 seconds equals (2 * 3600) + (45 * 60) + 30 = 9930 seconds, confirming the output.

import calendar

year = int(input("Enter year: "))
month = int(input("Enter month (1-12): "))

print(calendar.month(year, month))Code language: Python (python)

Explanation:

• int(input(...)): Reads the year and month as strings from the user and converts them to integers, which is required by the calendar functions.
• calendar.month(year, month): Returns a multi-line string containing a nicely formatted text calendar for the specified month and year, with the week starting on Monday by default.
• Alternative: Use calendar.prmonth(year, month) to print the calendar directly without needing an explicit print() call.

from datetime import date
import calendar

today = date.today()
months_to_add = 4

month = today.month - 1 + months_to_add
year = today.year + month // 12
month = month % 12 + 1

max_day = calendar.monthrange(year, month)[1]
day = min(today.day, max_day)

future_date = today.replace(year=year, month=month, day=day)
print("Date 4 months from today:", future_date)Code language: Python (python)

Explanation:

• month = today.month - 1 + months_to_add: Converts the month to a zero-based index before adding, which makes the modulo arithmetic for wrapping around December work correctly.
• year = today.year + month // 12: Increments the year whenever the total months exceed 12 (e.g., adding 4 months to October results in February of the next year).
• calendar.monthrange(year, month)[1]: Returns the number of days in the target month, used to clamp the day and avoid invalid dates like February 31.
• today.replace(...): Creates a new date object with updated year, month, and day fields while leaving unspecified fields unchanged.

from datetime import date

given_date = date(2025, 8, 17)
first_day = given_date.replace(day=1)

print("First day of the month:", first_day)Code language: Python (python)

Explanation:

• given_date.replace(day=1): Returns a new date object with the same year and month as the original, but with the day set to 1. The replace() method never modifies the original object since date objects are immutable.
• Practical use: This one-liner is a standard pattern in data pipelines for grouping records by month, e.g., transaction_date.replace(day=1) normalizes any date to its month bucket.

from datetime import date
import calendar

today = date.today()
last_day_num = calendar.monthrange(today.year, today.month)[1]
last_day = today.replace(day=last_day_num)

print("Last day of current month:", last_day)Code language: Python (python)

Explanation:

• calendar.monthrange(year, month): Returns a two-element tuple. The first element is the integer weekday of the first day of the month (0 = Monday), and the second is the total number of days in that month. This automatically accounts for leap years.
• [1]: Indexes into the tuple to extract only the day count (e.g., 28, 29, 30, or 31).
• today.replace(day=last_day_num): Builds a complete date object for the last day of the current month by replacing only the day component.

from datetime import date, timedelta

today = date.today()
days_ahead = (7 - today.weekday()) % 7
if days_ahead == 0:
    days_ahead = 7

next_monday = today + timedelta(days=days_ahead)
print("Next Monday:", next_monday)Code language: Python (python)

Explanation:

• today.weekday(): Returns the current day as an integer from 0 (Monday) to 6 (Sunday). For example, Wednesday returns 2.
• (7 - today.weekday()) % 7: Calculates how many days remain until the next Monday. The modulo by 7 ensures that if today is already Monday (weekday() == 0), the result is 0 rather than 7.
• if days_ahead == 0: days_ahead = 7: Handles the edge case where today is Monday. Without this check, the script would return today’s date rather than next Monday.
• timedelta(days=days_ahead): Adds the computed offset to today to land precisely on the next Monday.

from datetime import datetime, timedelta

dt = datetime(2025, 7, 15, 14, 35, 0)

if dt.minute >= 30:
    rounded = (dt + timedelta(hours=1)).replace(minute=0, second=0, microsecond=0)
else:
    rounded = dt.replace(minute=0, second=0, microsecond=0)

print("Rounded to nearest hour:", rounded)Code language: Python (python)

Explanation:

• dt.minute >= 30: The rounding condition. If the minutes are at least 30, the time is closer to the next hour, so it rounds up; otherwise it rounds down to the current hour.
• dt + timedelta(hours=1): Advances the datetime by one hour before zeroing out the sub-hour components. This correctly handles edge cases like rounding 23:45 up to midnight (00:00 the next day).
• .replace(minute=0, second=0, microsecond=0): Strips all sub-hour components from the datetime object, leaving a clean on-the-hour timestamp.
• Example breakdown: The input 14:35 has 35 minutes, which is greater than or equal to 30, so it rounds up to 15:00.

from datetime import date, timedelta
year = 2026
sundays = []
current = date(year, 1, 1)
end = date(year, 12, 31)
# Advance to the first Sunday of the year
while current.weekday() != 6:
    current += timedelta(days=1)
# Collect all Sundays by stepping 7 days at a time
while current <= end:
    sundays.append(current)
    current += timedelta(weeks=1)
print(f"Total Sundays in {year}: {len(sundays)}")
for sunday in sundays:
    print(sunday)Code language: Python (python)

Explanation:

• current.weekday() != 6: Advances day by day from January 1st until the first Sunday is found. In Python’s weekday() system, 0 is Monday and 6 is Sunday.
• timedelta(weeks=1): Once the first Sunday is located, stepping by exactly 7 days each iteration guarantees every subsequent date also lands on a Sunday, making the loop far more efficient than checking every single day.
• sundays.append(current): Builds the list incrementally. The result can be used for further processing, such as filtering events or generating weekly report dates.
• Result: Most years contain 52 Sundays. Years where January 1st falls on a Sunday, or leap years starting on Saturday, will have 53.

from datetime import date, timedelta
start = date(2025, 7, 1)
end = date(2025, 7, 31)
business_days = 0
current = start
while current < end:
    if current.weekday() < 5:  # 0=Monday ... 4=Friday
        business_days += 1
    current += timedelta(days=1)
print(f"Business days between {start} and {end}: {business_days}")Code language: Python (python)

Explanation:

• current.weekday() < 5: A concise condition that matches only weekdays. Since weekday() returns 0 (Monday) through 6 (Sunday), any value less than 5 is a working day. Values 5 and 6 (Saturday and Sunday) are automatically skipped.
• while current < end: Uses a strict less-than comparison so the end date itself is not counted, consistent with the common convention of counting days between two dates exclusively.
• Alternative – NumPy: numpy.busday_count(start, end) achieves the same result in a single call and also supports custom holiday arrays for more advanced business day calculations.
• Note: This solution does not account for public holidays. To exclude them, maintain a list of holiday dates and add and current not in holidays to the condition.

from datetime import datetime
from zoneinfo import ZoneInfo

# Naive datetime representing a local time in IST (UTC+5:30)
naive_dt = datetime(2025, 7, 15, 10, 30, 0)

# Make it timezone-aware by attaching the local timezone
local_dt = naive_dt.replace(tzinfo=ZoneInfo("Asia/Kolkata"))

# Convert to UTC
utc_dt = local_dt.astimezone(ZoneInfo("UTC"))

print("Local (IST):", local_dt)
print("UTC:        ", utc_dt)Code language: Python (python)

Explanation:

• ZoneInfo("Asia/Kolkata"): Creates a timezone object for Indian Standard Time (UTC+5:30) using the IANA timezone database. zoneinfo is part of the standard library from Python 3.9 onwards, so no third-party installation is required.
• naive_dt.replace(tzinfo=...): Stamps the timezone onto a naive (timezone-unaware) datetime without changing the time value. Use this only when you know the datetime was originally created in that specific zone.
• .astimezone(ZoneInfo("UTC")): Converts the aware datetime to the target timezone, recalculating the time value accordingly. Here, 10:30 IST becomes 05:00 UTC because IST is 5 hours and 30 minutes ahead of UTC.
• Alternative: For Python versions below 3.9, use the pytz library: pytz.timezone("Asia/Kolkata").localize(naive_dt) followed by .astimezone(pytz.utc).

from datetime import datetime
from zoneinfo import ZoneInfo

timezones = {
    "Tokyo":    "Asia/Tokyo",
    "New York": "America/New_York",
}

for city, tz_name in timezones.items():
    current_time = datetime.now(tz=ZoneInfo(tz_name))
    formatted = current_time.strftime("%Y-%m-%d %H:%M:%S %Z")
    print(f"Current time in {city}: {formatted}")Code language: Python (python)

Explanation:

• datetime.now(tz=ZoneInfo(tz_name)): Returns the current moment expressed in the specified timezone. This is the preferred approach over converting from UTC after the fact, and it correctly handles Daylight Saving Time transitions automatically.
• Dictionary of timezones: Storing city-to-IANA-zone mappings in a dictionary makes the code easy to extend. Adding more cities requires only a new key-value pair, with no changes to the loop logic.
• strftime("%Z"): Appends the timezone abbreviation (e.g., JST or EDT) to the output string, making it immediately clear which zone each timestamp belongs to.
• Alternative – pytz: Replace ZoneInfo(tz_name) with pytz.timezone(tz_name) for compatibility with Python versions below 3.9. The rest of the code remains unchanged.

from datetime import date, timedelta
def add_working_days(start_date, n):
    current = start_date
    working_days_counted = 0
    while working_days_counted < n:
        current += timedelta(days=1)
        if current.weekday() < 5:  # Monday to Friday
            working_days_counted += 1
    return current
start_date = date(2025, 7, 1)
n = 10
result = add_working_days(start_date, n)
print(f"Date after {n} working days from {start_date}: {result}")Code language: Python (python)

Explanation:

• current += timedelta(days=1) before the check: The day is advanced first, then evaluated. This ensures the start date itself is never counted as one of the working days, which matches the real-world convention of “N working days from today.”
• current.weekday() < 5: Counts only weekdays (Monday through Friday). Saturday (5) and Sunday (6) are stepped over without incrementing the counter, so the loop naturally absorbs weekends.
• Encapsulated as a function: Wrapping the logic in add_working_days(start_date, n) makes it reusable for any start date and any number of working days, not just the specific example.
• Extension: To also skip public holidays, pass a holidays set to the function and add and current not in holidays to the counting condition.