# O que é e como usar Python time

Python `time` é o módulo que permite exibir dados de data e hora. Ele oferece diferentes funções, e usa a representação de tempo Unix e objetos `struct_time`.

## O que é Python `time` e como usar o módulo?

“Para trabalhar com informações de tempo nessa linguagem de programação, o módulo Python `time` é fundamental. Entre as tarefas que este módulo pode realizar estão a **exibição do tempo atual, a formatação de dados de tempo e a especificação de uma determinada duração** ao executar uma função. Para usar o módulo, o Python `time` deve ser importado com a seguinte palavra-chave:

```python
import time
```

Depois disso, você pode aplicar várias funções com o módulo. As mais importantes são apresentadas nas seções seguintes. Se você está procurando uma alternativa ao Python `time`, o Python datetime é uma boa escolha.

## Timestamp Unix e Python `time.time()`

A base para a função `time.time()` é o carimbo de data e hora Unix. Este descreve um ponto exato no passado, a partir do qual o tempo é medido em um sistema. Para Windows e muitos sistemas Unix, esse ponto é **1º de janeiro de 1970, às 00:00:00 (tempo universal coordenado)**. O Python também usa esse momento como base. O cálculo a partir desse segundo é chamado de “tempo Epoch”. A função `time.time()` retorna o número de segundos decorridos desde 1º de janeiro de 1970. Para isso, use o seguinte código:

```python
import time 
elapsed_time = time.time() 
print("Elapsed seconds since Epoch: ", elapsed_time)
```

No momento da redação deste texto, obtivemos esta saída:

```python
1716816325
```

## Exibir data legível com Python `time.ctime()`

Como essa informação pode não ser muito útil normalmente, o Python `time` oferece a possibilidade de usar o timestamp Unix como **base para uma data legível**. Assim, você se beneficia da precisão dessa medição de tempo, mas recebe o timestamp em um formato compreensível. A função apropriada é `time.ctime()`. Ela converte o carimbo de data e hora diretamente em uma data. O código correspondente é este:

```python
import time
elapsed_time = 1716816325
current_time = time.ctime(elapsed_time)
print("This is the current time: ", current_time)
```

Nossa saída será:

```python
This is the current time: Mon May 27 2024 15:25:25
```

Dica A solução ideal para trabalhar com projetos web: com [Deploy Now](https://www.ionos.com/hosting/deploy-now "Deploy Now — IONOS") da IONOS, você faz a implantação de alterações no código diretamente pelo GitHub e se beneficia de atualizações em tempo real. Encontre agora o plano adequado para as suas necessidades!

## Planejar execução de programa com Python `time.sleep()`

Python `time` pode fazer muito mais do que apenas mostrar o tempo atual. O módulo também é usado para controlar ou atrasar a execução de um programa. A função apropriada é `time.sleep()` e é escrita assim:

```python
import time
print("This text is displayed immediately… ")
time.sleep(5)
print("…and this one is displayed 5 seconds later.")
```

Nossa saída será:

```python
This text is displayed immediately…
…and this one is displayed 5 seconds later.
```

A segunda parte será exibida apenas após um atraso de cinco segundos. Para saber mais sobre o que você pode fazer com [Python time.sleep()](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-sleep/ " Python Sleep"), consulte o guia detalhado do Digital Guide.

## Objetos `struct_time` e Python `time`

Para muitas funções do Python `time`, o **objeto `struct_time`** é a base. Ele é frequentemente usado como parâmetro ou valor de retorno e fornece uma tupla cujos valores podem ser acessados por índice ou atributo. Os seguintes atributos estão disponíveis:

<table>
  <thead>
    <tr>
      <th>Índice</th>
      <th>Atributo</th>
      <th>Descrição</th>
      <th>Valores possíveis</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>tm\_year</td>
      <td>Ano</td>
      <td>0000, …, 2024, …, 9999</td>
    </tr>
    <tr>
      <td>1</td>
      <td>tm\_mon</td>
      <td>Mês</td>
      <td>1, 2, 3, …, 12</td>
    </tr>
    <tr>
      <td>2</td>
      <td>tm\_mday</td>
      <td>Dia do mês</td>
      <td>1, 2, 3, 31</td>
    </tr>
    <tr>
      <td>3</td>
      <td>tm\_hour</td>
      <td>Hora</td>
      <td>0, 1, 2, …, 23</td>
    </tr>
    <tr>
      <td>4</td>
      <td>tm\_min</td>
      <td>Minuto</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>Dia da semana</td>
      <td>0 (segunda-feira), …, 6 (domingo)</td>
    </tr>
    <tr>
      <td>7</td>
      <td>tm\_yday</td>
      <td>Dia do ano</td>
      <td>1, 2, 3, …, 366</td>
    </tr>
    <tr>
      <td>8</td>
      <td>tm\_isdst</td>
      <td>Horário de verão</td>
      <td>0 (inverno), 1 (verão) ou -1 (não especificado)</td>
    </tr>
  </tbody>
</table>

## Conectar `struct_time` e tempo Epoch com Python `time.localtime()`

A função **`time.localtime()`** utiliza um objeto `struct_time` com base no timestamp Unix. Isso é feito no código da seguinte forma:

```python
import time
timestamp = time.time()
current_time = time.localtime(timestamp)
print(current_time)
```

Obtivemos a seguinte saída:

```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)
```

Também é possível usar um valor arbitrário para o parâmetro `localtime()`. O código ficaria assim:

```python
import time
timestamp = time.time()
current_time = time.localtime(1716816325)
print(current_time)
```

A saída será novamente:

```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)
```

## Função oposta a `localtime()`: Python `time.mktime()`

A função `time.mktime()` é oposta à `localtime()` no Python. Você usa um objeto `struct_time` como parâmetro e o sistema retorna o carimbo de data e hora correspondente para o tempo Epoch. O código é:

```python
import time
timestamp = time.mktime(local_time)
print(timestamp)
```

Como saída, você obterá um valor em segundos no formato:

```python
1716816325
```

## Tempo universal coordenado para exibição: Python `time.gmtime()`

A função `time.gmtime()` é semelhante à `time.localtime()` em muitos aspectos. No entanto, o objeto `struct_time` retornado aqui está em Tempo Universal Coordenado (UTC). O código é:

```python
import time
time_stamp = time.time()
utc_time = time.gmtime(time_stamp)
print(utc_time)
```

A saída será diferente em alguns detalhes em relação ao exemplo acima:

```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)
```

## Converter objetos `struct_time` em strings com Python `time.asctime()`

Você pode usar `time.asctime()` para converter um objeto `struct_time` em uma [Python string](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-string/ "String em Python"). Um exemplo seria:

```python
import time
point_in_time = time.localtime()
readable_format = time.asctime(point_in_time)
print(readable_format)
```

A saída será:

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

## Criar strings com Python `time.strftime()`

Muitas variações são possíveis com `time.strftime()`. Você pode usar formas para exibir o tempo atual no formato desejado. Aqui estão alguns dos códigos de formato mais importantes:

- **%Y**: ano no formato 0001, …, 2024, …, 9999
- **%m**: mês usando números de 01 (janeiro) a 12 (dezembro)
- **%d**: dia do mês de 01 a 31
- **%H**: hora no intervalo de 00 a 23
- **%M**: minuto no intervalo de 00 a 59
- **%S**: segundo no intervalo de 00 a 61

No código, isso poderia ser feito assim:

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

Neste caso, a saída seria:

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

## Converter strings em objetos `struct_time` com Python `time.strptime()`

Para isso, o Python `time` tem uma função correspondente: `time.strptime()`. Ela usa uma string para gerar um objeto `struct_time`. O código é:

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

A saída será:

```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)
```

Dica No nosso Digital Guide, você encontra muitos outros artigos sobre a popular linguagem de programação Python. Temos um [tutorial Python para iniciantes](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/aprender-python/), um guia de instalação do Python e um artigo específico sobre [operadores Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operadores-python/).


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/modulo-python-time/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/modulo-python-time/) for AI/LLM consumption.