Get the Current Time Function in Python

In Python programming, the “datetime” module offers a direct mechanism to get the present date and time. Utilizing the “datetime” module’s “datetime” class and its now() method, the developers can access an uncomplicated means of capturing the current timestamp. This function yields a “datetime” object that includes the existing year, month, day, hour, minute, second, and microsecond. Due to its simplicity and effectiveness, this approach has become a fundamental choice for handling the time-related tasks in Python.

Example 1: Basic Usage of

At the basics of Python’s time-handling capabilities is the “datetime” module. This module introduces the “datetime” class which includes information about dates and times. The “datetime” class provides an extensive suite of methods, among which the now() method stands out for its simplicity and utility. Let’s start by examining a basic example that demonstrates how to use the now() method to obtain the current date and time.

from datetime import datetime

current_time =
print("Current Time:", current_time)

At first, the “datetime” module is imported, granting access to its classes and functions. Then, the method is called for without any argument, returning a “datetime” object that represents the current moment. The obtained “datetime” object is stored in the “current_time” variable. Lastly, the {print} statement is employed to print the current time over the console. This straightforward example gives the foundation for more advanced applications. Let’s explore the additional scenarios where the “datetime” module proves essential.

Example 2: Formatting the Current Time

Now, we will do the formatting of the current time. Like in the previous example, the “datetime” module is imported, and the current time is obtained using

from datetime import datetime

current_time =
formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S")
print("Formatted Time:", formatted_time)

The strftime() method formats the “datetime” object. The “%Y-%m-%d %H:%M:%S” format string specifies the desired format including the year, month, day, hour, minute, and second. The formatted time is stored in the “formatted_time” variable. Using print(), the outcome is printed with the current time that is shown in a readable manner for humans to see.

Example 3: Calculating the Time Differences

This example illustrates the calculation of time differences using the “timedelta” class from the “datetime” module.

from datetime import datetime, timedelta
# Current time
start_time =
# Simulate some time-consuming task
for _ in range(1000000):

# Updated time
end_time =
# Calculate the time difference
time_difference = end_time - start_time
print("Time Elapsed:", time_difference)
from datetime import datetime

current_time =
formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S")
print("Formatted Time:", formatted_time)

To find out the time at the beginning and end of a laborious task, utilize the function. A “timedelta” object can be derived by subtracting the start time from the end time in order to calculate the time difference. The elapsed time is displayed on the console, providing information about how long the simulated task takes.

Example 4: Working with Time Zones

Time zones play a crucial role in handling the global time-related tasks. In this example, a custom time zone (UTC+5:30) is defined using the “timezone” class.

from datetime import datetime, timedelta, timezone
# Define a time zone (UTC+5:30)
custom_timezone = timezone(timedelta(hours=5, minutes=30))
# Current time in the custom time zone
current_time =
print("Current Time (Custom Timezone):", current_time)

The function is used with the custom time zone, producing a “datetime” object that is adjusted accordingly. Python’s ability to handle time zones with flexibility is demonstrated by printing the current time in the designated time zone.

Example 5: Converting Strings to Datetime Objects

String representations of dates and times often need conversion to “datetime” objects for further processing. The strptime() method allows this conversion.

from datetime import datetime
# Date string in a specific format
date_string = "2023-11-17 15:30:00"
# Convert the string to a datetime object
converted_time = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
print("Converted Time:", converted_time)

The “date_string” variable holds a date and time in the “2023-11-17 15:30:00” format. The datetime.strptime() is used to parse the string into a “datetime” object, utilizing the specified format in the second argument. The converted time is printed, demonstrating the ability to transform the string representations into usable “datetime” objects.

Example 6: Working with Time Intervals

Similar to the third example, this scenario introduces the concept of time intervals and demonstrates how to compare them with the elapsed time.

from datetime import datetime, timedelta
# Current time
start_time =
# Simulate a time-consuming task
for _ in range(1000000):

# Updated time
end_time =

# Calculate the elapsed time
elapsed_time = end_time - start_time

# Define a time interval for comparison
time_limit = timedelta(seconds=5)

# Check if the elapsed time exceeds the defined limit
if elapsed_time > time_limit:
    print("Task took longer than expected.")
    print("Task completed within the expected time.")

The “timedelta” class defines a time interval of 5 seconds (“time_limit”). The script simulates a time-consuming task and calculates the elapsed time using the same principles as in the third example. A conditional statement checks whether the elapsed time exceeds the predefined time limit, providing a mechanism for managing the tasks based on time constraints.

Example 7: Countdown Timer

This example demonstrates the creation of a simple countdown timer using the “datetime” module.

from datetime import datetime, timedelta
def countdown_timer(seconds):
    end_time = + timedelta(seconds=seconds)

    while < end_time:
        remaining_time = end_time -
        print(f"Time remaining: {remaining_time}", end="\r")

    print("Time's up!")

# Set the countdown duration (e.g., 10 seconds)

The end time is determined by the “countdown_timer” function using the given duration in seconds as an input and the current time. A “while” loop continuously updates and displays the remaining time until the end time is reached. The countdown ends with a “Time’s up!” message.

Example 8: Future Date Calculation

This example focuses on date calculations using the “timedelta” class in affiliation with the “date” attribute of the “datetime” object.

from datetime import datetime, timedelta
current_date =
# Calculate a future date (e.g., 30 days from now)
future_date = current_date + timedelta(days=30)

print("Current Date:", current_date)
print("Future Date:", future_date)

The current date is obtained using The script then calculates a future date by adding a timedelta of 30 days to the current date. The current and future dates are printed, displaying the simple nature of date manipulations in Python.

Example 9: Handling the Daylight Saving Time (DST)

Python’s Daylight Saving Time (DST) can impact the time-related calculations. This example showcases the creation of time zones with and without DST.

from datetime import datetime, timedelta, timezone

# Define time zones with and without DST
timezone_with_dst = timezone(timedelta(hours=3), "Zone With DST")
timezone_without_dst = timezone(timedelta(hours=2), "Zone Without DST")

# Obtain the current time in both time zones
current_time_with_dst =
current_time_without_dst =

print("Current Time with DST:", current_time_with_dst)
print("Current Time without DST:", current_time_without_dst)

We define the two time zones using the “timezone” class, each with a specified UTC offset. The function obtains the current time in both time zones. The resulting times illustrate how Python deals with time zone variations including DST considerations. As technology evolves, Python’s commitment to providing fast and intuitive solutions for temporal challenges improves its position as a leading programming language.

Example 10: Time-Based Data Filtering

This final example demonstrates how the “datetime” module can be used to filter the time-based data.

from datetime import datetime, timedelta

# Sample dataset with timestamps
data = [
    {"timestamp": datetime(2023, 1, 15, 10, 30, 0), "value": 42},
    {"timestamp": datetime(2023, 1, 15, 11, 45, 0), "value": 56},
    {"timestamp": datetime(2023, 1, 15, 14, 20, 0), "value": 38},

# Filter data for entries within the last hour
current_time =
filtered_data = [entry for entry in data if current_time - entry["timestamp"] <= timedelta(hours=1)]

print("Filtered Data within the Last Hour:")
for entry in filtered_data:

A sample dataset with timestamps is created, each representing a data entry. The script filters the data to include only the entries within the last hour, displaying Python’s ability to handle the time-based data manipulations. The filtered data is then printed, practically applying the time-related functionality.


In this detailed explanation of Python’s “datetime” module, we covered the various examples that demonstrate this fundamental tool’s versatility and power to handle the temporal data. From the basic usage to the advanced scenarios like time intervals, countdown timers, future date calculations, DST considerations, and time-based data filtering, the “datetime” module proves to be important in a wide range of applications. Whether we are a beginner or an experienced Python developer, mastering the complexities of the “datetime” module enhances our ability to manage the time-related tasks with precision and clarity.

About the author

Omar Farooq

Hello Readers, I am Omar and I have been writing technical articles from last decade. You can check out my writing pieces.