Understanding Python Date and Time, with Examples — SitePoint | Digital Noch

On this article, we’ll discover 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 could 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 Courses
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 because the 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 because the starting of the epoch. A struct_time is a sort 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 because the 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() technique 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() technique 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 are output validate our code.

The datetime Module

The datetime module provides lessons for manipulating dates and occasions.

These lessons are important for simple 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 lessons. Datetime lessons even have totally different strategies accessible 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, at the moment(), which returns the present date:

from datetime import date

current_date = date.at the moment()
print(current_date)

Right here’s the output of the code above:

The datetime Module Courses

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

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

The date Class

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

A date object could be instantiated as follows:

datetime.date(yr, month, day)

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

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

Within the code above, MINYEAR is 1 and MAXYEAR is 9999. The values characterize the smallest and largest yr 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 move arguments for yr, month and day into the date constructor. The arguments should 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 at the moment() and ctime() strategies:

from datetime import date

current_date = date.at the moment()
print(current_date.ctime())

The at the moment() technique will return a neighborhood date, whereas the ctime() technique 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 could be created from a date string in ISO 8601 format. Use the fromisoformat() technique 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)

Be aware: 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, move a date string and corresponding format to the strptime() technique. Extract the date by utilizing the date() technique 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 yr, month, day from the date object

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

from datetime import date

current_date = date.at the moment()

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

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 yr is: 2023
The month is: 4
The day is: 20

The time Class

A time object represents a (native) time of day, unbiased of any specific day, and topic to adjustment by way of a tzinfo object.

A date object could be instantiated as follows:

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

The time object could be instantiated with none arguments. All arguments are optionally available with a default worth of 0, besides tzinfo, which is None. All arguments should be integers inside a specified vary, whereas the tzinfo argument ought to be an occasion of the tzinfo subclass:

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

When arguments which are 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. Cross arguments for hours, minutes, seconds, microseconds and tzinfo. Do not forget that all arguments are optionally available, 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 could be created from a time string in ISO 8601 format. Use the fromisoformat() technique 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, move a date string and corresponding format to the strptime() technique. Extract the time by utilizing the time() technique 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 knowledge from a date object and a time object.

A datetime object could be instantiated as follows:

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

The datetime constructor requires the yr, month and day arguments. The tzinfo default is None or an occasion of the tzinfo subclass. The time arguments are optionally available, however the arguments should be integers and inside vary:

• MINYEAR <= yr <= MAXYEAR,
• 1 <= month <= 12,
• 1 <= day <= variety of days within the given month and yr,
• 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 move 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() technique 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() technique 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)

Be aware: if the date string argument handed into the fromisoformat() technique isn’t a sound ISO format string, a ValueError exception is raised. The date output right here is sort of just like the consequence 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 provides the next attributes: yr, month, day, hour, minute, second, microsecond, tzinfo and fold. The attributes could be accessed as follows:

from datetime import datetime

new_dt = datetime.now()

yr = new_dt.yr
print('Yr: ', yr)

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 data: ', 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 data: None
Fold: O

Be aware: 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 could be instantiated as follows:

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

All arguments are optionally available, with a default worth of 0. Integers or floats, constructive or damaging 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.
• Per 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 sooner or later)
• -999999999 <= days <= 999999999

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

Instance: Create a timedelta object

To create a timedelta object, import the timedelta class from the datetime module. Cross 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 technique to standardize date and time.
Nonetheless, there could also be a have to format date and time in a specific approach primarily based on a rustic or area.

Formatting datetime with the strftime() technique

Datetime formatting could be achieved with the strftime() technique. The strftime() technique is an occasion technique of time, date and datetime lessons, 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 appears like this:

Often a string format code is handed as an argument to strftime() technique to format date. A number of the format codes are as follows:

• %a: weekday abbreviated title — corresponding to Solar, Mon, and many others.
• %b: month as abbreviated title — corresponding to Jan, Feb, and many others.
• %y: yr with out century as a zero-padded decimal quantity — corresponding to 00, 01, 02, and many others.

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

Instance: Format date and time in a datetime object

Similar to within the earlier examples, we are able to move an argument of the format string of the specified date and time output to the strftime() technique:

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

Not like strftime(), the strptime() is a datetime class technique, 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 appears like this:

strptime(date_string, format)

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

Instance: String to datetime object

To create a datetime object, we’ll move two arguments to the strptime() technique, 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 models of time (corresponding to weeks or hours).

Instance: Calculate a future date

from datetime import datetime, timedelta

date_now = datetime.now()
print("At the moment'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:

At the moment'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)

consequence = time_delta1 - time_delta2

print("Distinction between two timedelta objects:", consequence)

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)

consequence = time_delta1 + time_delta2

print("Sum of two delta objects:", consequence)

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

Using timezones is important if we need to create conscious date and time objects. An conscious time or date object consists of 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 move the timezone object tz to the now() technique.

Once we test 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() technique 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 observe of time is a vital facet of our day by day lives, and this additionally interprets into programming. Once we construct real-world initiatives, there’s at all times the necessity to preserve time logs for consumer 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 keeping with a consumer’s area or timezone.

To raised handle occasions and dates in our packages or functions, Python offers the time and datetime modules. These modules have features, lessons 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 could be discovered on GitHub.