Understanding Python Date and Time, with Examples — SitePoint

On this article, we’ll discover the way to use date and time in Python. We’ll see real-life examples of working with date and time utilizing the Python datetime and time modules.

Working with occasions and dates is inevitable when constructing real-life initiatives, and there are various use circumstances for them. Fortunately, Python has a few modules that make it simple to work with dates and occasions throughout totally different timezones.

The code for this tutorial may be discovered on GitHub.

Contents:

1. The time Module
2. The datetime Module
3. Getting the Present Date and Time in Python
4. Getting the Present Date in Python
5. The datetime Module Lessons
6. The date Class
7. The time Class
8. The datetime Class
9. The timedelta Class
10. Python datetime Formatting
11. Working with timedelta

The time Module

The Python time module is for performing time-related operations. We’ll now spotlight among the mostly used features within the time module, with examples.

The time() operate

The time() operate returns the present time in seconds for the reason that starting of a set epoch as a floating level quantity. The epoch that’s used begins in January 1, 1970, 00:00:00 (UTC):

import time as time_module

time_in_seconds = time_module.time()
print("Time in sceconds from epoch", time_in_seconds)

Right here’s the output of the code above:

Time in sceconds from epoch 1680712853.0801558

The gmtime() operate

The gmtime() operate returns a struct_time in UTC from time expressed in seconds for the reason that starting of the epoch. A struct_time is a kind of time worth sequence with a named tuple interface returned by gmtime(), localtime(), and strptime():

import time as time_module

utc_time_in_seconds = time_module.gmtime()
print("Time struct in UTC", utc_time_in_seconds)

Right here’s the output of the code above:

Time struct in UTC: time.struct_time(tm_year=2023, tm_mon=3, tm_mday=16, tm_hour=14, tm_min=47, tm_sec=28, tm_wday=3, tm_yday=75, tm_isdst=0)

The localtime() operate

The localtime() operate returns a struct_time in native time from time expressed in seconds for the reason that starting of the epoch:

import time as time_module

local_time = time_module.localtime()
print("Time struct in native time:", local_time)

Right here’s the output of the code above:

Time struct in native time: time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=3, tm_yday=75, tm_isdst=0)

The ctime() operate

The ctime() methodology converts time in seconds from the start of the epoch to a string format. If no arguments are handed to the operate, it returns a time string for the present time in seconds:

import time as time_module

time_in_secs = 1678671984.939945  

time_string = time_module.ctime(time_in_secs)
print("Time string: ",time_string)

Right here’s the output of the code above:

Time string: Thu Apr 20 01:46:24 2023

The strftime() operate

The strftime() methodology converts a struct_time to a time string as specified by a given format argument:

import time as time_module

time_tuple = time_module.gmtime()
time_format = "%y/%m/%d %I:%M:%S %p"

time_in_string = time_module.strftime(time_format, time_tuple)

print("Time expressed as formatted string:", time_in_string)

Right here’s the output of the code above:

Time expressed as formatted string: 23/04/20 04:40:04 PM

The sleep() operate

The sleep() operate delays the execution of a thread for a specified variety of seconds:

import time as time_module 

for i in vary(5):
    local_time = time_module.localtime()
    seconds = local_time.tm_sec
    print(seconds)
    time_module.sleep(2)

Right here’s the output of the code above:

Within the code above, the quantity 2 is handed in as an argument of the sleep() operate, which causes the loop to delay two seconds earlier than execution. The numbers which might be output validate our code.

The datetime Module

The datetime module provides courses for manipulating dates and occasions.

These courses are important for straightforward manipulation, extraction, and output formatting of time intervals, occasions and dates. Ordinarily, date and time will not be thought-about information sorts in Python, however they’re date and time objects of the datetime module courses. Datetime courses even have totally different strategies obtainable for dealing with date and time objects.

Getting the Present Date and Time in Python

To get the present date and time, import the datetime class from the datetime module. The datetime class has a way, now(), which returns the present date and time:

from  datetime  import  datetime

current_date_time = datetime.now()
print(current_date_time)

Right here’s the output of the code above:

2023-04-20 13:47:02.362424

Getting the Present Date in Python

To get the present date, import the date class from the datetime module. The date class has a way, right now(), which returns the present date:

from datetime import date

current_date = date.right now()
print(current_date)

Right here’s the output of the code above:

The datetime Module Lessons

The datetime module at present has six courses, every with totally different strategies for manipulating date and time objects. The courses are listed as follows:

• date
• time
• datetime
• timedelta
• tzinfo
• timezone

The date Class

A date object represents a date (12 months, month and day) in an idealized calendar — the present Gregorian calendar indefinitely prolonged in each instructions.

A date object may be instantiated as follows:

datetime.date(12 months, month, day)

The date object constructor takes three integer arguments and needs to be inside the specified vary:

• MINYEAR <= 12 months <= MAXYEAR
• 1 <= month <= 12
• 1 <= day <= variety of days within the given month and 12 months

Within the code above, MINYEAR is 1 and MAXYEAR is 9999. The values signify the smallest and largest 12 months quantity allowed in a date or datetime object.

When the arguments are out of vary, it throws a ValueError, and non-integer arguments throw a TypeError.

Instance: Create a date object

To create a date object, import the date class from the datetime module, and go arguments for 12 months, month and day into the date constructor. The arguments have to be integers and inside the specified vary:

from datetime import date

mydate = date(2023, 4, 20)
print('The date is: ', mydate)

Right here’s the output of the code above:

Instance: Get the present date

To get the present native date, use the date class right now() and ctime() strategies:

from datetime import date

current_date = date.right now()
print(current_date.ctime())

The right now() methodology will return an area date, whereas the ctime() methodology renders the date as a string.
Right here’s the output of the code above:

Instance: Create the date from ISO format

A date object may be created from a date string in ISO 8601 format. Use the fromisoformat() methodology of the date class to do that:

from datetime import date

iso_date = date.fromisoformat('2023-04-20')
print("Date from ISO format: ", iso_date)

Word: ISO 8601 is a standardized format for presenting dates and time with out creating confusion throughout totally different areas or timezones. ISO 8601 takes the format YYYY-MM-DD.

Right here’s the output of the code above:

Date from ISO format:  2023-04-20

Instance: Create date object from string

To create a date object, go a date string and corresponding format to the strptime() methodology. Extract the date through the use of the date() methodology of the returned datetime object:

from datetime import datetime

datetime_object = datetime.strptime("20/04/23", "%d/%m/%y")
date_object = datetime_object.date()

print("Date from string:", date_object)

Right here’s the output of the code above:

Date from string: 2023-04-20

Instance: Get the 12 months, month, day from the date object

To extract the 12 months, month and day from a date object, use the .12 months, .month, and .day attributes of the date class:

from datetime import date

current_date = date.right now()

12 months = current_date.12 months
print("The 12 months is: ", 12 months)

month = current_date.month
print("The month is: ", month)

day = current_date.day
print("The day is: ", day)

Right here’s the output of the code above:

The 12 months is: 2023
The month is: 4
The day is: 20

The time Class

A time object represents a (native) time of day, impartial of any explicit day, and topic to adjustment through a tzinfo object.

A date object may be instantiated as follows:

datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

The time object may be instantiated with none arguments. All arguments are non-compulsory with a default worth of 0, besides tzinfo, which is None. All arguments have to be integers inside a specified vary, whereas the tzinfo argument needs to be an occasion of the tzinfo subclass:

• 0 <= hour < 24,
• 0 <= minute < 60,
• 0 <= second < 60,
• 0 <= microsecond < 1000000.

When arguments which might be out of vary are handed to the constructor, it raises a ValueError.

Instance: Create a time object

To create a time object, import the time class from the datetime module. Move arguments for hours, minutes, seconds, microseconds and tzinfo. Keep in mind that all arguments are non-compulsory, so when no argument is handed to the constructor, the time object returns 00:00:00:

from datetime import time

my_time = time(20, 30, 12)
print("My time is: ", my_time)

Right here’s the output of the code above:

Instance: Create time from ISO format

A time object may be created from a time string in ISO 8601 format. Use the fromisoformat() methodology of the time class to do that:

from datetime import time

iso_time = time.fromisoformat('12:45:12')
print('The time says: ', iso_time)

Right here’s the output of the code above:

Instance: Create time object from string

To create a time object, go a date string and corresponding format to the strptime() methodology. Extract the time through the use of the time() methodology of the returned datetime object:

from datetime import datetime

datetime_object = datetime.strptime("20 Apr, 2023 13:50:30", "%d %b, %Y %H:%M:%S")
time_object = datetime_object.time()

print("Time from string:", time_object)

Right here’s the output of the code above:

Time from string: 13:50:30

Instance: Get hours, minutes, seconds and microseconds from the time object

To extract values for hours, minutes, seconds and microseconds, use the hour, minute, second, and microsecond attributes of the time object:

from datetime import time

new_time = time(7, 20, 50, 569230)

hour = new_time.hour
print('Hours: ',hour)

minute = new_time.minute
print('Minutes: ', minute)

second = new_time.second
print('Seconds: ', second)

microsecond = new_time.microsecond
print('Microseconds: ', microsecond)

Right here’s the output of the code above:

Hours: 7
Minutes: 20
Seconds: 50
Microseconds: 569230

The datetime Class

A datetime object is a single object containing all the data from a date object and a time object.

A datetime object may be instantiated as follows:

datetime.datetime(12 months, month, day, hour, minute=0, second=0, microsecond=0, tzinfo=None)

The datetime constructor requires the 12 months, month and day arguments. The tzinfo default is None or an occasion of the tzinfo subclass. The time arguments are non-compulsory, however the arguments have to be integers and inside vary:

• MINYEAR <= 12 months <= MAXYEAR,
• 1 <= month <= 12,
• 1 <= day <= variety of days within the given month and 12 months,
• 0 <= hour < 24,
• 0 <= minute < 60,
• 0 <= second < 60,
• 0 <= microsecond < 1000000.

A ValueError is raised if arguments are out of vary.

Instance: Create a datetime object

To create a datetime object, import the datetime class from the datetime module and go the next arguments:

from datetime import datetime

dt = datetime(2023, 4, 20, 10, 38, 10, 345389)

Right here’s the output of the code above:

The date time is: 2023-04-20 10:38:10.345389

Instance: Get the present native date and time

To get the present native date and time, use the now() methodology of the datetime class:

from datetime import datetime

print('Present find date time is: ', datetime.now())

Right here’s the output of the code above:

Present find date time is: 2023-04-20 10:50:08.944232

Instance: Create date time from ISO format

To create a datetime object from a date time string in ISO 8601 format, use the fromisoformat() methodology of the datetime class:

from datetime import datetime

iso_dt = datetime.fromisoformat('2023-04-20 11:25:30.983023')
print('Date time from ISO is: ', iso_dt)

Word: if the date string argument handed into the fromisoformat() methodology isn’t a legitimate ISO format string, a ValueError exception is raised. The date output right here is sort of just like the end result receive from datetime.now().

Right here’s the output of the code above:

Date time from ISO is: 2023-04-20 11:25:30.983023

Instance: Get date and time attributes from the datetime object

A datetime object affords the next attributes: 12 months, month, day, hour, minute, second, microsecond, tzinfo and fold. The attributes may be accessed as follows:

from datetime import datetime

new_dt = datetime.now()

12 months = new_dt.12 months
print('Yr: ', 12 months)

month = new_dt.month
print('Month: ', month)

day = new_dt.day
print('Day: ', day)

hour = new_dt.hour
print('Hours: ', hour)

minute = new_dt.minute
print('Minutes: ', minute)

second = new_dt.second
print('Seconds: ', second)

microsecond = new_dt.microsecond
print('Microseconds: ', microsecond)

tz_info = new_dt.tzinfo
print('Timezone information: ', tz_info)

fold = new_dt.fold
print('Fold: ', fold)

Right here’s the output of the code above:

Yr: 2023
Month: 4
Day: 20
Hours: 12
Minutes: 42
Seconds: 15
Microseconds: 794955
Timezone information: None
Fold: O

Word: the default attribute worth for tzinfo is None, as a result of there’s no object argument handed, and fold will return 0 by default. For extra on the fold attribute (which was launched in Python model 3.6), see the docs.

The timedelta Class

A timedelta object represents a length, the distinction between two dates or occasions.

A timedelta object may be instantiated as follows:

datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

All arguments are non-compulsory, with a default worth of 0. Integers or floats, optimistic or unfavourable numbers are legitimate arguments for the constructor.

Arguments are transformed as follows:

• A millisecond is transformed to 1000 microseconds.
• A minute is transformed to 60 seconds.
• An hour is transformed to 3600 seconds.
• Every week is transformed to 7 days.

All arguments ought to fall inside the following vary as specified within the docs:

• 0 <= microseconds < 1000000
• 0 <= seconds < 3600*24 (the variety of seconds in in the future)
• -999999999 <= days <= 999999999

An OverFlowError is raised if arguments are outdoors the normalized days vary.

Instance: Create a timedelta object

To create a timedelta object, import the timedelta class from the datetime module. Move the suitable arguments to the constructor operate:

from datetime import timedelta

td = timedelta(10, 30, 4300, 3000, 12, 5, 3)
print('Time Delta: ', td)

Right here’s the output of the code above:

Time Delta: 31 days, 5:12:33.004300

Python datetime Formatting

Date and time codecs differ from area to area and nation to nation. It’s due to these variations in date and time codecs that the ISO 8601 format was launched, as a strategy to standardize date and time.
Nonetheless, there could also be a have to format date and time in a specific means based mostly on a rustic or area.

Formatting datetime with the strftime() methodology

Datetime formatting may be performed with the strftime() methodology. The strftime() methodology is an occasion methodology of time, date and datetime courses, which implies we’ve to create a date, time or datetime object to use the tactic. The tactic takes a given format code as an argument, and returns a string representing time, date or datetime from within the desired format.

The tactic signature seems to be like this:

Often a string format code is handed as an argument to strftime() methodology to format date. Among the format codes are as follows:

• %a: weekday abbreviated title — akin to Solar, Mon, and so forth.
• %b: month as abbreviated title — akin to Jan, Feb, and so forth.
• %y: 12 months with out century as a zero-padded decimal quantity — akin to 00, 01, 02, and so forth.

A extra detailed desk with format code may be discovered within the Python docs.

Instance: Format date and time in a datetime object

Identical to within the earlier examples, we will go an argument of the format string of the specified date and time output to the strftime() methodology:

from datetime import datetime

date_time = datetime.now()

formatted_date_time = date_time.strftime("%d %B %Y, %H:%M:%S")
print("Formatted date and time:", formatted_date_time)

formatted_date_time_2 = date_time.strftime("%A, %d %B %Y, %I:%M %p")
print("Formatted date and time in 12-hour clock:", formatted_date_time_2)

Right here’s the output of the code above:

Formatted date and time: 20 April 2023, 11:11:40
Formatted date and time in 12-hour clock: Thursday, 20 April 2023, 11:11 AM

Formatting datetime with the strptime() methodology

Not like strftime(), the strptime() is a datetime class methodology, which implies it may be used with out creating an object of the category. The tactic returns a datetime object from a given date string and format.

The tactic signature seems to be like this:

strptime(date_string, format)

A string format code is handed as an argument to strptime() methodology to format date.

Instance: String to datetime object

To create a datetime object, we’ll go two arguments to the strptime() methodology, a date string and a corresponding format. A ValueError is raised when the date string doesn’t match the offered format:

from datetime import datetime

date_string = "April 20, 23 12:12:20"
dt_format = "%B %d, %y %H:%M:%S"

datetime_from_string = datetime.strptime(date_string, dt_format)
print("Datetime from string:", datetime_from_string)

Right here’s the output of the code above:

Datetime from string: 2023-04-20 12:12:20

Working with timedelta

The timedelta class in Python is used for calculating the distinction between dates, calculating time variations between particular dates, and likewise performing different calculations utilizing particular items of time (akin to weeks or hours).

Instance: Calculate a future date

from datetime import datetime, timedelta

date_now = datetime.now()
print("Immediately's date:", date_now)

future_date = date_now + timedelta(days=7)
print("Future date is:", future_date)

Right here’s the output of the code above:

Immediately's date: 2023-04-20 15:50:43.415319
Future date is: 2023-04-27 15:50:43.415319

From the instance above, we first get a present native date and time and a timedelta object of seven days. As a result of timedelta helps operations like addition, we add the datetime object and timedelta object to get a future day in seven days. If our present date is 2023-04-20, in seven days the date will likely be 2023-04-27.

Instance: Calculate the distinction between two timedelta objects

from datetime import timedelta

time_delta1 = timedelta(days=23, hours=0, minutes=20)
time_delta2 = timedelta(days=15, seconds=2, microseconds=123, milliseconds=234566, minutes=5, hours=2)

end result = time_delta1 - time_delta2

print("Distinction between two timedelta objects:", end result)

Right here’s the output of the code above:

Distinction between two timedelta objects: 7 days, 22:11:03.433877

Within the code snippet above, we’ve created two timedelta objects, time_delta1 and time_delta2, and calculated the distinction between them.

Instance: Calculate the sum of two timedelta objects

from datetime import timedelta

time_delta1 = timedelta(days = 2, hours = 1, seconds = 33, weeks=2)
time_delta2 = timedelta(days = 4, hours = 11, minutes = 4, seconds = 54)

end result = time_delta1 + time_delta2

print("Sum of two delta objects:", end result)

Right here’s the output of the code above:

Sum of two delta objects: 20 days, 12:05:27

As seen above, the timedelta objects help addition operation, and the result’s output to the console. Timedelta objects help operations like subtraction, multiplication, and division.

Working with Timezones

The usage of timezones is important if we need to create conscious date and time objects. An conscious time or date object contains info on the timezone. It’s additionally essential for displaying time or date objects in relation to a specific area.

zoneinfo is a built-in Python module for working with timezones.

Instance: Create a datetime object with timezone info

from datetime import datetime
from zoneinfo import ZoneInfo

tz = ZoneInfo('Africa/Accra')
date_time_object = datetime.now(tz)

print("Timezone info", date_time_object.tzinfo)
print("Timezone code", date_time_object.tzname())

Right here’s the output for the code above:

Timezone info: Africa/Accra
Timezone code: GMT

First, we import the datetime class from the datetime module and ZoneInfo from the zoneinfo module. We create a ZoneInfo object after which a datetime object, however this time we go the timezone object tz to the now() methodology.

After we verify the worth of the tzinfo attribute, it returns the title of the timezone Africa/Accra, not None.

Instance: Convert a datetime object from one timezone to a different

from datetime import datetime
from zoneinfo import ZoneInfo

accra_timezone = ZoneInfo('Africa/Accra')
accra_datetime = datetime.now(accra_timezone)
print("Present date time in Accra:", accra_datetime)


new_york_timezone = ZoneInfo('America/New_York')
new_york_datetime = accra_datetime.astimezone(new_york_timezone)
print("Present date time in New York:", new_york_datetime)

Right here’s the output of the code above:

Present date time in Accra 2023-04-20 10:42:02.476541+00:00
Present date time in New York 2023-04-20 06:42:02.476541-04:00

To transform between timezones, we use the astimezone() methodology of the datetime object, passing in a brand new timezone object. The astimezone() returns a brand new datetime object with up to date timezone info.

Conclusion

Protecting monitor of time is a crucial facet of our every day lives, and this additionally interprets into programming. After we construct real-world initiatives, there’s at all times the necessity to hold time logs for person actions like login and sign-out, amongst different use circumstances. It’s additionally essential to place a time stamp on content material generated on-line and to show time and date in response to a person’s area or timezone.

To higher handle occasions and dates in our packages or purposes, Python offers the time and datetime modules. These modules have features, courses and strategies for managing time-related duties. On this article, we’ve highlighted some generally used features and strategies, offering examples of how they can be utilized.

The code for this tutorial may be discovered on GitHub.