# Python time: todo sobre el uso y funciones del módulo

`time` de Python es un módulo que se puede utilizar para obtener fechas en el lenguaje de programación. El módulo ofrece numerosas funciones y utiliza la especificación de tiempo de Unix y los objetos `struct_time`.

## ¿En qué consiste el módulo Python `time` y cómo se utiliza?

El módulo `time` de Python es de crucial importancia para la implementación y consideración de especificaciones de tiempo en el lenguaje de programación. Entre las tareas que puede realizar este módulo se encuentran **la presentación de la hora actual, el formateo de especificaciones de tiempo y la especificación de una duración concreta** al ejecutar una función. Para poder utilizar el módulo, primero se debe importar `time` de la siguiente forma:

```python
import time
```

Puedes llevar a cabo diversas funciones con este módulo. Te mostramos las más importantes en los siguientes apartados. Si buscas una alternativa a `time`, una buena opción es [datetime de Python](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-datetime/).

## `time.time()` y el significado de la marca de tiempo Unix

La base de la función `time.time()` es la marca de tiempo de Unix. Esto describe un punto exacto en el pasado a partir del cual se mide el tiempo en un sistema. Para Windows y muchos sistemas Unix, este punto en el tiempo es el **1 de enero de 1970, a las 00:00:00** (Tiempo Universal Coordinado). Python también utiliza este momento como base. Alternativamente, el cálculo a partir de este segundo se denomina “tiempo desde la época”. La función `time.time()` te da el número de segundos que han pasado desde este momento a principios de los años 70. Para ello, utiliza el siguiente código:

```python
import time 
tiempo_transcurrido = time.time() 
print("Segundos transcurridos desde la época: ", tiempo_transcurrido)
```

Obtendremos este resultado:

```python
1716816325
```

## `time.ctime()`: presentar los datos de forma legible

Sin embargo, como esta información es normalmente de poca utilidad, `time` te ofrece la opción de utilizar la marca de tiempo de Unix como **base para una fecha**. De este modo, te beneficias de la precisión de esta medida de tiempo, pero obtienes la marca en un formato comprensible. La función adecuada es `time.ctime()`. Esta convierte directamente la marca de tiempo Unix en una fecha. El código correspondiente sería el siguiente:

```python
import time 
tiempo_transcurrido = 1716816325 
tiempo_actual = time.ctime(tiempo_transcurrido) 
print("Este es el tiempo actual: ", tiempo_actual)
```

Nuestro resultado será el siguiente. Se tiene en cuenta la hora local:

```python
Esta es la fecha actual: Mon May 27 2024 15:25:25
```

Consejo La solución ideal para trabajar en tu proyecto web: con [Deploy Now](https://www.ionos.es/alojamiento/deploy-now "Deploy Now de IONOS") de IONOS, puedes desplegar cambios en el código directamente con GitHub y beneficiarte de la personalización en tiempo real. Busca la tarifa que se adecúe a tus necesidades.

## `time.sleep()`: programar la ejecución de un programa

Sin embargo, `time` de Python puede hacer mucho más que mostrar la hora actual. El módulo también se utiliza para controlar o retrasar la ejecución de un programa. La función correspondiente es `time.sleep()` y se ejecuta así:

```python
import time 
print("Esto se visualizará inmediatamente… ") 
time.sleep(5) 
print("…y esto en 5 segundos.")
```

Nuestro resultado sería el siguiente:

```python
Esto se visualizará inmediatamente… 
…y esto en 5 segundos.
```

Sin embargo, la segunda parte solo se emite tras un retardo de cinco segundos. Puedes averiguar para qué puedes utilizar [time.sleep() de Python](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-sleep/) en nuestro artículo de la Digital Guide.

## Objetos `struct_time` para `time`

El **objeto `struct_time`** es la base de muchas funciones `time` de Python. Normalmente se utiliza como parámetro o valor de retorno y produce una tupla cuyo valor puede especificarse mediante el índice o el atributo. Para ello se pueden utilizar los siguientes atributos:

<table>
  <thead>
    <tr>
      <th>Índice</th>
      <th>Atributo</th>
      <th>Descripción</th>
      <th>Valores posibles</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>tm\_year</td>
      <td>Año</td>
      <td>0000, …, 2024, …, 9999</td>
    </tr>
    <tr>
      <td>1</td>
      <td>tm\_mon</td>
      <td>Mes</td>
      <td>1, 2, 3, …, 12</td>
    </tr>
    <tr>
      <td>2</td>
      <td>tm\_mday</td>
      <td>Día del mes</td>
      <td>1, 2, 3, 31</td>
    </tr>
    <tr>
      <td>3</td>
      <td>tm\_hour</td>
      <td>Hora del día</td>
      <td>0, 1, 2, …, 23</td>
    </tr>
    <tr>
      <td>4</td>
      <td>tm\_min</td>
      <td>Minutos</td>
      <td>0, 1, 2, …, 59</td>
    </tr>
    <tr>
      <td>5</td>
      <td>tm\_sec</td>
      <td>Segundos</td>
      <td>0, 1, 2, …, 60, 61</td>
    </tr>
    <tr>
      <td>6</td>
      <td>tm\_wday</td>
      <td>Día de la semana</td>
      <td>0 (para lunes), …, 6 (para domingo)</td>
    </tr>
    <tr>
      <td>7</td>
      <td>tm\_yday</td>
      <td>Día del año</td>
      <td>1, 2, 3, …, 366</td>
    </tr>
    <tr>
      <td>8</td>
      <td>tm\_isdst</td>
      <td>Horario de verano o invierno</td>
      <td>0 (invierno), 1 (verano) o -1 (no especificado)</td>
    </tr>
  </tbody>
</table>

## `time.localtime()`: conexión de `struct_time` y el tiempo desde Epoch

La función **`time.localtime()`** utiliza un objeto `struct_time` basado en la marca de tiempo Unix. Este sería el código:

```python
import time 
tiempo_actual = time.time() 
hora_actual = time.localtime(tiempo_actual) 
print(hora_actual)
```

Así obtenemos el siguiente resultado:

```python
time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=15, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=1)
```

Alternativamente, también es posible seleccionar cualquier valor para el parámetro `localtime()`. El código será similar a este:

```python
import time 
tiempo = time.time() 
hora_actual = time.localtime(1716816325) 
print(hora_actual)
```

El resultado sería el siguiente:

```python
time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=15, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=1)
```

## `time.mktime()`: el equivalente inverso a `localtime()`

`time.mktime()` en `time` es la función inversa a `localtime()`. Utiliza un objeto `struct_time` como parámetro y el sistema devuelve la correspondiente marca de tiempo desde la época. Así se vería el código:

```python
import time 
marca_tiempo = time.mktime(hora_local) 
print(marca_tiempo)
```

El resultado es un valor de segundos en este formato:

```python
1716816325
```

## `time.gmtime()`: Tiempo Universal Coordinado para la visualización

`time.gmtime()` es en gran parte equivalente a `time.localtime()`. Sin embargo, el objeto `struct_time` correspondiente se devuelve en Tiempo Universal Coordinado. Este es el código:

```python
import time 
marca_tiempo = time.time() 
tiempo_universal = time.gmtime(marca_tiempo) 
print(tiempo_universal)
```

Por lo tanto, el resultado de esta función `time` difiere en algunos detalles del ejemplo anterior:

```python
time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=13, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=0)
```

## `time.asctime()`: convertir objetos `struct_time` en cadenas

Puedes usar `time.asctime()` para convertir un objeto `struct_time` en una [cadena Python](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-string/). Podría verse así, por ejemplo:

```python
import time 
momento_actual = time.localtime() 
formto_legible = time.asctime(momento_actual) 
print(formato_legible)
```

De este modo, obtendrás un mayor resultado inmediato:

```python
Mon May 27 15:25:25 2024
```

## `time.strftime()`: crea una cadena con `time`

Aquí utilizamos diferentes códigos de formato para mostrar la hora actual en el formato deseado. Para darte una idea de los diferentes códigos de formato, enumeramos aquí algunos de los más importantes:

- **%Y**: representa el año en el formato 0001, …, 2024, …, 9999
- **%m**: representa el mes y utiliza los números del 01 (enero) al 12 (diciembre)
- **%d**: representa el día del 01 del mes al 31
- **%H**: representa la hora en el rango de 00 a 23
- **%M**: representa el minuto y va de 00 a 59
- **%S**: representa el segundo del 00 al 61

El código podría ser el siguiente:

```python
import time 
momento_actual = time.localtime() 
formato_legible = time.strftime("%d-%m-%Y, %H:%M:%S", momento_actual) 
print(formato_legible)
```

En este caso, el resultado sería:

```python
27-05-2024, 15:25:25
```

## `time.strptime()`: convertir cadenas en objetos `struct_time`

`time` también tiene una contrapartida para esto: `time.strptime()` utiliza una cadena para dar salida a un objeto `struct_time`. Este es el código apropiado:

```python
import time 
momento_actual = time.strptime(formato_legible, "%d-%m-%Y, %H: %M:%S") 
print(momento_actual)
```

Obtenemos este resultado:

```python
time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=15, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=1)
```

Consejo En nuestra Digital Guide encontrarás muchos más artículos sobre este popular lenguaje de programación. Entre otras cosas, tenemos un [tutorial de Python](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/tutorial-de-python/), una guía para [instalar Python](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/instalar-python/) y un artículo sobre diferentes [operadores Python](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-operators/).


This is a markdown version of: [https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/modulo-time-de-python/](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/modulo-time-de-python/) for AI/LLM consumption.