Operaciones básicas de fecha y hora en Python

Python tiene un módulo incorporado llamado DateTime para manejar fechas y horas de muchas maneras. En este artículo, vamos a ver operaciones básicas de DateTime en Python.

Hay seis clases de objetos principales con sus respectivos componentes en el módulo de fecha y hora que se menciona a continuación:

1. fechahora.fecha
2. fechahora.hora
3. fechahora.fechahora
4. fechahora.tzinfo
5. fechahora.timedelta
6. fechahora.zonahoraria

Ahora veremos el programa para cada una de las funciones en el módulo de fecha y hora mencionado anteriormente. 

fechahora.fecha():

Podemos generar objetos de fecha a partir de la clase de fecha. Un objeto de fecha representa una fecha que tiene un año, mes y día.

Sintaxis: datetime.date(año, mes, día)

strftime para imprimir día, mes y año en varios formatos. Estos son algunos de ellos: 

• current.strftime(“%m/%d/%y”) que se imprime en formato de mes (numérico)/fecha/año
• current.strftime(“%b-%d-%Y”) que se imprime en formato de mes (abreviatura)-fecha-año
• current.strftime(“%d/%m/%Y”) que se imprime en formato de fecha/mes/año
• current.strftime(“%B %d, %Y”) que se imprime en formato de mes (palabras) fecha, año

from datetime import date
 
# You can create a date object containing
# the current date
# by using a classmethod named today()
current = date.today()
 
# print current year, month, and year individually
print("Current Day is :", current.day)
print("Current Month is :", current.month)
print("Current Year is :", current.year)
 
# strftime() creates string representing date in
# various formats
print("\n")
print("Let's print date, month and year in different-different ways")
format1 = current.strftime("%m/%d/%y")
 
# prints in month/date/year format
print("format1 =", format1)
     
format2 =  current.strftime("%b-%d-%Y")
# prints in month(abbreviation)-date-year format
print("format2 =", format2)
 
format3 = current.strftime("%d/%m/%Y")
 
# prints in date/month/year format
print("format3 =", format3)
     
format4 =  current.strftime("%B %d, %Y")
 
# prints in month(words) date, year format
print("format4 =", format4)

Producción:

Current Day is : 23
Current Month is : 3
Current Year is : 2021


Let's print date, month and year in different-different ways
format1 = 03/23/21
format2 = Mar-23-2021
format3 = 23/03/2021
format4 = March 23, 2021

fechahora.hora():

 Un objeto de tiempo generado a partir de la clase de tiempo representa la hora local.

Componentes: 

• hora
• minuto
• segundo
• microsegundo
• tzinfo

Sintaxis: datetime.time(hora, minuto, segundo, microsegundo)

Código:

from datetime import time
 
# time() takes hour, minutes, second,
# microsecond respectively in order
# if no parameter is passed in time() by default
# it takes 0
defaultTime = time()
 
print("default_hour =", defaultTime.hour)
print("default_minute =", defaultTime.minute)
print("default_second =", defaultTime.second)
print("default_microsecond =", defaultTime.microsecond)
 
# passing parameter in different-different ways
# hour, minute and second respectively is a default
# order
time1= time(10, 5, 25)
print("time_1 =", time1)
 
# assigning hour, minute and second to respective
# variables
time2= time(hour = 10, minute = 5, second = 25)
print("time_2 =", time2)
 
# assigning hour, minute, second and microsecond to
# respective variables
time3= time(hour=10, minute= 5, second=25, microsecond=55)
print("time_3 =", time3)

Producción:

default_hour = 0
default_minute = 0
default_second = 0
default_microsecond = 0
time_1 = 10:05:25
time_2 = 10:05:25
time_3 = 10:05:25.000055

fechahora.fechahora():

El módulo datetime.datetime() muestra la combinación de una fecha y una hora. 

Componentes: 

• año
• mes
• día
• hora
• minuto
• segundo,
• microsegundo
• tzinfo

Sintaxis: datetime.datetime(año, mes, día)

                           o

datetime.datetime(año, mes, día, hora, minuto, segundo, microsegundo)

Fecha y hora actuales usando el método strftime() de diferentes maneras:

• strftime(“%d”) da el día actual
• strftime(“%m”) da el mes actual
• strftime(“%Y”) da el año actual
• strftime(“%H:%M:%S”) proporciona la hora actual en formato de hora, minuto y segundo
• strftime(“%m/%d/%Y, %H:%M:%S”) da la fecha y la hora juntas

Código:

from datetime import datetime
 
# now() gives current date and time
current = datetime.now()
 
# print combinedly
print(current)
print("\n")
print("print each term individually")
 
day = current.strftime("%d")
 
# print day
print("day:", day)
 
month = current.strftime("%m")
 
# print month
print("month:", month)
 
year = current.strftime("%Y")
 
# print year
print("year:", year)
 
time = current.strftime("%H:%M:%S")
 
# time in hour, minute and second
print("time:", time)
 
print("\n")
print("printing date and time together")
date_time = current.strftime("%m/%d/%Y, %H:%M:%S")
print("date and time:", date_time)
print("\n")
 
# fetching details from timestamp
timestamp = 1615797322
date_time = datetime.fromtimestamp(timestamp)
 
# %c, %x and %X are used for locale's proper date and time representation
time_1 = date_time.strftime("%c")
print("first_output:", time_1)
 
time_2 = date_time.strftime("%x")
print("second_output:", time_2)
 
time_3 = date_time.strftime("%X")
print("third_output:", time_3)
 
print("\n")
 
# assigning each term manually
manual = datetime(2021, 3, 28, 23, 55, 59, 342380)
print("year =", manual.year)
print("month =", manual.month)
print("hour =", manual.hour)
print("minute =", manual.minute)
print("timestamp =", manual.timestamp())

Producción:

2021-03-23 19:00:20.726833


print each term individually
day: 23
month: 03
year: 2021
time: 19:00:20


printing date and time together
date and time: 03/23/2021, 19:00:20


first_output: Mon Mar 15 14:05:22 2021
second_output: 03/15/21
third_output: 14:05:22


year = 2021
month = 3
hour = 23
minute = 55
timestamp = 1616955959.34238

fechahora.timedelta():

Muestra una duración que expresa la diferencia entre dos instancias de fecha, hora o fecha y hora con una resolución de microsegundos.

Aquí implementamos algunas funciones básicas e imprimimos días pasados ​​y futuros. Además, imprimiremos algunos otros atributos de timedelta max, min y resolution que muestran el máximo de días y horas, el mínimo de fechas y horas, y la diferencia más pequeña posible entre objetos timedelta no iguales, respectivamente. Aquí también aplicaremos algunas operaciones aritméticas en dos fechas y horas diferentes.

from datetime import timedelta, datetime
 
present_date_with_time = datetime.now()
 
print("Present Date :", present_date_with_time)
 
# coming date after 10 days
ten_days_after= present_date_with_time + timedelta(days = 10)
print('Date after 10 days :',ten_days_after)
 
# date before 10 days
ten_days_before= present_date_with_time - timedelta(days = 10)
print('Date before 10 days :',ten_days_before)
 
# date before one year ago
one_year_before_today= present_date_with_time + timedelta(days = 365)
print('One year before present Date :', one_year_before_today)
 
#date before one year ago
one_year_after_today= present_date_with_time - timedelta(days = 365)
print('One year before present Date :', one_year_after_today)
 
print("\n")
print("print some other attributes of timedelta\n")
 
# maximum days and time
print("Max : ",timedelta.max)
 
# minimum days and time
print("Min : ",timedelta.min)
 
# The smallest possible difference between non-equal
# timedelta objects, timedelta(microseconds=1)
print("Resolution: ",timedelta.resolution)
 
print('Total number of seconds in an year :',
      timedelta(days = 365).total_seconds())
 
print("\nApply some operations on timedelta function\n")
time_after_one_min = present_date_with_time + timedelta(seconds=10) * 6
print('Time after one minute :', time_after_one_min)
 
print('Timedelta absolute value :', abs(timedelta(days = +20)))
 
print('Timedelta string representation :', str(timedelta(days = 5,
                       seconds = 40, hours = 20, milliseconds = 355)))
 
print('Timedelta object representation :', repr(timedelta(days = 5,
                       seconds = 40, hours = 20, milliseconds = 355)))

Producción:

Fecha actual: 2021-03-25 22:34:27.651128

Fecha después de 10 días: 2021-04-04 22:34:27.651128

Fecha antes de 10 días: 2021-03-15 22:34:27.651128

Un año antes del presente Fecha: 2022-03-25 22:34:27.651128

Un año antes del presente Fecha: 2020-03-25 22:34:27.651128

imprimir algunos otros atributos de timedelta

Máx: 999999999 días, 23:59:59.999999

Mín.: -999999999 días, 0:00:00

Resolución: 0:00:00.000001

Número total de segundos en un año: 31536000.0

Aplicar algunas operaciones en la función timedelta

Tiempo después de un minuto: 2021-03-25 22:35:27.651128

Valor absoluto Timedelta: 20 días, 0:00:00

Representación de string Timedelta: 5 días, 20:00:40.355000

Representación del objeto Timedelta: datetime.timedelta(días=5, segundos=72040, microsegundos=355000)

fechahora.tzinfo():

Es una clase base abstracta para objetos de información de zona horaria. Las clases de fecha y hora las utilizan para proporcionar una noción personalizable de ajuste de hora. 

Existen los siguientes cuatro métodos disponibles para la clase base tzinfo:

• utcoffset(self, dt): devuelve el desplazamiento de la instancia de fecha y hora pasada como argumento
• dst(self, dt): dst significa horario de verano. dst denota adelantar el reloj 1 hora en verano para que la oscuridad caiga más tarde según el reloj. Está activado o desactivado. Se comprueba sobre la base de los siguientes elementos:

(dt.año, dt.mes, dt.día, dt.hora, dt.minuto, dt.segundo, dt.día de la semana(), 0, 0)

• tzname(self, dt): Devuelve un objeto Python String. Se utiliza para encontrar el nombre de la zona horaria del objeto de fecha y hora pasado.
• fromutc(self, dt) : esta función devuelve la hora local equivalente y toma la fecha y la hora del objeto en UTC. Se utiliza principalmente para ajustar la fecha y la hora. Se llama desde la implementación predeterminada de datetime.astimezone(). El dt.tzinfo se pasará como propio, los datos de fecha y hora del horario de verano se devolverán como una hora local equivalente.

Nota: Genera ValueError si dt.tzinfo no es propio o/y dst() es Ninguno.

# code
from datetime import datetime, timedelta
from pytz import timezone
import pytz
 
time_zone = timezone('Asia/Calcutta')
 
normal = datetime(2021, 3, 16)
ambiguous = datetime(2021, 4, 16, 23, 30)
 
# is_dst parameter is ignored for most of the
# timstamps.It is only used during DST
# transition ambiguous periods to resolve that
# ambiguity
print("Operations on normal datetime")
print(time_zone.utcoffset(normal, is_dst=True))
print(time_zone.dst(normal, is_dst=True))
print(time_zone.tzname(normal, is_dst=True))
 
# put is_dst=False
print(time_zone.utcoffset(normal, is_dst=False))
print(time_zone.dst(normal, is_dst=False))
print(time_zone.tzname(normal, is_dst=False))
 
print("\n")
print("Operations on ambiguous datetime")
print(time_zone.utcoffset(ambiguous, is_dst=True))
print(time_zone.dst(ambiguous, is_dst=True))
print(time_zone.tzname(ambiguous, is_dst=True))
 
# is_dst=False
print(time_zone.utcoffset(ambiguous, is_dst=False))
print(time_zone.dst(ambiguous, is_dst=False))
print(time_zone.tzname(ambiguous, is_dst=False))

Operations on normal datetime
5:30:00
0:00:00
IST
5:30:00
0:00:00
IST


Operations on ambiguous datetime
5:30:00
0:00:00
IST
5:30:00
0:00:00
IST

Producción:

Operations on normal datetime
5:30:00
0:00:00
IST
5:30:00
0:00:00
IST


Operations on ambiguous datetime
5:30:00
0:00:00
IST
5:30:00
0:00:00
IST

fechahora.zonahoraria():

Descripción: es una clase que implementa la clase base abstracta tzinfo como un desplazamiento fijo del UTC.

Sintaxis:  datetime.timezone()

from datetime import datetime, timedelta
from pytz import timezone
import pytz
 
utc = pytz.utc
print(utc.zone)
 
india = timezone('Asia/Calcutta')
print(india.zone)
 
eastern = timezone('US/Eastern')
print(eastern.zone)
 
time_format = '%Y-%m-%d %H:%M:%S %Z%z'
 
# localize() is used to localize
# datetime with no timezone information
loc_dt = india.localize(datetime(2021, 3, 16, 6, 0, 0))
loc_dt = india.localize(datetime(2021, 3, 16, 6, 0, 0))
print(loc_dt.strftime(time_format))
 
# another way of building a localized time is by converting
# an existing localized time
# using the standard astimezone() method
eastern_dt = loc_dt.astimezone(eastern)
print(eastern_dt.strftime(time_format))
 
print(datetime(2021, 3, 16, 12, 0, 0, tzinfo=pytz.utc).strftime(time_format))
 
# 10 minutes before
before_dt = loc_dt - timedelta(minutes=10)
print(before_dt.strftime(time_format))
print(india.normalize(before_dt).strftime(time_format))
 
# 20 mins later
after_dt = india.normalize(before_dt + timedelta(minutes=20))
print(after_dt.strftime(time_format))

Producción:

UTC
Asia/Calcutta
US/Eastern
2021-03-16 06:00:00 IST+0530
2021-03-15 20:30:00 EDT-0400
2021-03-16 12:00:00 UTC+0000
2021-03-16 05:50:00 IST+0530
2021-03-16 05:50:00 IST+0530
2021-03-16 06:10:00 IST+0530

Veamos diferentes funciones con descripción en el módulo de tiempo: –

Ahora veremos el programa y la salida para cada una de las funciones mencionadas anteriormente en la tabla.

1: método time( ): El método time() devuelve la hora como un número de punto flotante expresado en segundos desde la época, en UTC.

Sintaxis: tiempo.tiempo([ ])

NOTA: No tiene ningún parámetro

# import time
import time
 
#prints total number of seconds passed since epoch
print(time.time())

Producción:

1616692391.3081982

2: método ctime() 

El método ctime() convierte un tiempo expresado en segundos desde la época en una string que representa la hora local. Se utiliza la hora actual devuelta por time() si no se proporcionan segundos o ninguno. Este método es equivalente a asctime(localtime(secs)). La información de configuración regional no es utilizada por el método ctime().

Sintaxis: time.ctime([ seg ])

Donde sec pasado como argumento es el número de segundos que se convertirán en representación de string.

import time
 
number_of_seconds=1625925769.9618232
 
# function takes seconds passed since epoch as an argument and returns
# a string representing local time
print(time.ctime(number_of_seconds))

Sat Jul 10 14:02:49 2021

3: método dormir()

El método de tiempo de Python sleep() detiene la ejecución durante la cantidad de segundos dada. El punto flotante del número se puede pasar como argumento para obtener un tiempo de sueño más preciso.

Sintaxis: time.sleep([ seg ])

donde sec pasado como argumento es el número de segundos durante los cuales

el proceso debe ser detenido.

import time
 
# prints GEEKSFORGEEKS immediately
print("GEEKSFORGEEKS")
 
time.sleep(1.23)
 
# prints GEEKSFORGEEKS after 1.23 seconds
# as it stops execution for that time interval
print("GEEKSFORGEEKS")

GEEKSFORGEEKS
GEEKSFORGEEKS

4: método de hora local()

El método localtime() convierte el número de segundos a la hora local. Si no se proporciona secs o None, se utiliza la hora actual devuelta por time(). El indicador dst se establece en 1 cuando se aplica DST a la hora dada.

Sintaxis: time.localtime([ seg ])

Donde sec pasado como argumento es el número de segundos que se convertirán en la representación struct_time.

import time
 
# returns a time.struct_time
# object with a named tuple interface
print(time.localtime())

Producción

time.struct_time(tm_year=2021, tm_mon=3, tm_mday=30, tm_hour=8, tm_min=48, tm_sec=58, tm_wday=1, tm_yday=89, tm_isdst=0)

5: método gmtime().

El método gmtime() convierte un tiempo expresado en segundos desde la época en un struct_time en UTC en el que el indicador dst siempre es cero. Si no se proporciona secs o None, se utiliza la hora actual devuelta por time().

Sintaxis: time.gmtime([ seg ])

Donde sec pasado como argumento es el número de segundos que se convertirán en la representación de la estructura struct_time.

# code
import time
# returns a time.struct_time object with a named tuple interface
# If secs is not provided or None,
# the current time as returned by time() is used
print(time.gmtime())

Producción:

time.struct_time(tm_year=2021, tm_mon=3, tm_mday=30, tm_hour=8, tm_min=49, tm_sec=18, tm_wday=1, tm_yday=89, tm_isdst=0)

6: método mktime()

Es la función inversa del método localtime(). Toma un argumento como struct_time o tupla completa de 9 y devuelve un número de coma flotante. Si el valor de entrada no se representa como una hora válida, se genera OverflowError o ValueError.

Sintaxis: tiempo.mktime([t])

Donde t pasado como argumento es un objeto time.struct_time o una tupla que contiene 9 elementos correspondientes al objeto time.struct_time

# code
import time
 
# method mktime() is the inverse function of localtime()
# Its argument is the struct_time or full 9-tuple and
# it returns a floating point number, for compatibility with time().
 
t = (2016, 2, 15, 10, 13, 38, 1, 48, 0)
d = time.mktime(t)
print ("time.mktime(t) : %f" %  d)
print ("asctime(localtime(secs)): %s" % time.asctime(time.localtime(d)))

time.mktime(t) : 1455531218.000000
asctime(localtime(secs)): Mon Feb 15 10:13:38 2016

7: método asctime()

El método de tiempo de Python, asctime(), convierte un struct_time que representa un tiempo devuelto por gmtime() o localtime() en una string de 24 caracteres con el siguiente formato: ‘Tue Mar 23 23:21:05 2021’.

Sintaxis: tiempo.asctime([t])

Donde t pasado como argumento es una tupla de 9 elementos o struct_time que representa una hora devuelta por la función gmtime() o localtime().

import time
# method returns 24-character string of
# the following form − 'Mon March 15 23:21:05 2021'
 
local_time = time.localtime()
print ("asctime : ",time.asctime(local_time))

asctime :  Tue Mar 16 06:02:42 2021