Padroneggiare l’Arte della Gestione di Date e Orari in Django con il Modulo datetime di Python

 Frank    Gen. 2, 2024    6 min read    2.956

Gestire date e orari è un aspetto cruciale di molte applicazioni web, e Django, un popolare framework web per Python, fornisce strumenti robusti per gestire queste attività. In questo articolo, esploreremo come padroneggiare date e orari in Django utilizzando il modulo datetime di Python, insieme a frammenti di codice per guidarti attraverso il processo.

Comprensione del Modulo datetime di Python

Il modulo datetime in Python fornisce classi per lavorare con date e orari. Django sfrutta questo modulo per gestire vari aspetti temporali nelle tue applicazioni web. Prima di approfondire le implementazioni specifiche di Django, diamo un’occhiata veloce a alcuni concetti fondamentali del modulo datetime.

Utilizzo Base di datetime in Python

from datetime import datetime, date, timedelta

# Get the current date
current_date = date.today()
print('Current Date:', current_date)
# Current Date: 2024-01-01

# Get the current date and time
current_datetime = datetime.now()
print('Current Date and Time:', current_datetime)
# Current Date and Time: 2024-01-01 17:48:53.690755

Formattazione di Date e Orari

Utilizzo del metodo strftime per formattare date e orari.

from datetime import datetime, date, timedelta

# Get the current date and time
current_datetime = datetime.now()

# Formatting Dates and Times
formatted_date = current_date.strftime('%Y-%m-%d')
formatted_time = current_time.strftime('%H:%M:%S')
formatted_datetime = current_datetime.strftime('%Y-%m-%d %H:%M:%S')
print(f'formatted_date: {formatted_date}\nformatted_time: {formatted_time}\nformatted_datetime: {formatted_datetime}\n')
# formatted_date: 2024-01-01
# formatted_time: 18:53:47
# formatted_datetime: 2024-01-01 17:48:53

Per ulteriori informazioni su Python strftime visita il sito ufficiale di Python.

Analisi di Stringhe in Oggetti datetime

Utilizzo di strptime per convertire le stringhe in oggetti datetime.

from datetime import datetime

# Parsing Strings to `datetime` Objects
date_string = '2024-01-01'
date_format = '%Y-%m-%d'
parsed_date = datetime.strptime(date_string, date_format)
print('Parsed date:', parsed_date)
# Parsed date: 2024-01-01 00:00:00

# Using the Interpreter Without print()
# >> parsed_date
# datetime.datetime(2024, 1, 1, 0, 0)

Per ulteriori informazioni su Python strptime visita il sito ufficiale di Python.

Lavorare con i Fusi Orari in Python

Il modulo datetime supporta il lavoro con i fusi orari, consentendoti di gestire date e orari in diverse posizioni geografiche. Le applicazioni Django di solito utilizzano il UTC (Tempo Universale Coordinato) come fuso orario predefinito. Per lavorare con un fuso orario specifico, è possibile sfruttare la libreria pytz.

Se Django è già installato, pytz dovrebbe esserlo anche. In caso contrario, puoi installarlo utilizzando il seguente comando:

pip install pytz

from datetime import datetime

import pytz

# Timezone Awareness
specific_timezone = pytz.timezone("Europe/Berlin")

date_string = '2024-01-01'
date_format = '%Y-%m-%d'
parsed_date = datetime.strptime(date_string, date_format)
aware_datetime = parsed_date.astimezone(specific_timezone)
print('aware_datetime:', aware_datetime)
# aware_datetime: 2024-01-01 01:00:00+01:00

# Using the Interpreter Without print()
# >> aware_datetime
# datetime.datetime(2024, 1, 1, 1, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CET+1:00:00 STD>)

Esploreremo ulteriori esempi quando lavoriamo con i fusi orari in Django.

Eseguire Operazioni Aritmetiche sugli Oggetti datetime

from datetime import datetime, timedelta

# Get the current date and time
current_datetime = datetime.now()
print("Current Date and Time:", current_datetime)
# Current Date and Time: 2024-01-01 17:48:53.690755

# Perform arithmetic operations on dates
days = 7
future_datetime = current_datetime + timedelta(days=days)
print("Future Date:", future_datetime.date())
# Future Date: 2024-01-08

past_datetime = current_datetime - timedelta(days=days)
print("Past Date:", past_datetime.date())
# Past Date: 2023-12-25

Gestire gli Intervalli di Tempo con datetime

Il modulo datetime in Python fornisce funzionalità per lavorare con date e orari. Quando si tratta di gestire intervalli di tempo, è possibile calcolare la differenza tra due oggetti datetime.

Calcolare la Differenza tra Due Datetime

from datetime import datetime, timedelta

# Given number of days
days = 7

# Event start date
event_start = datetime.now()

# Calculate expiration date
expire_date = event_start + timedelta(days=days)

# Calculate the valid days
valid_days = expire_date - event_start

# Print the results
print(f'Event Start Date: {event_start}')
print(f'Event End Date: {expire_date}')
print(f'Event Duration: {valid_days.days} days')
# Event Start Date: 2024-01-01 22:27:17.199750
# Event End Date: 2024-01-08 22:27:17.199750
# Event Duration: 7 days

Pacchetto di Terze Parti

Per manipolazioni più avanzate di date e orari, consiglio di utilizzare dateutil. Fornisce funzionalità avanzate rispetto al modulo standard datetime di Python, semplificando calcoli e manipolazioni complesse. Per ulteriori dettagli su dateutil, puoi visitare la loro documentazione.

Integrare datetime con i Modelli Django

Django fornisce il campo DateTimeField per i modelli, consentendoti di memorizzare e manipolare informazioni di data e orario nel tuo database. Ecco un esempio di come puoi usarlo in un modello Django:

from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User

class Post(models.Model):
    # ...
    publish = models.DateTimeField(default=timezone.now)
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    # ...

Per ulteriori dettagli, puoi fare riferimento a Creare un applicazione blog con django, parte 2: creare modelli django.

Lavorare con i Fusi Orari in Django

Gestire i fusi orari è una sfida comune nello sviluppo web. Django fornisce il modulo timezone per gestire ciò in modo trasparente.

Nel nostro settings.py, abbiamo già quanto segue:

TIME_ZONE = 'UTC'
USE_TZ = True

import pytz
from django.utils import timezone

# Get the current time in UTC
current_utc_time = timezone.now()
print("Current UTC Time:", current_utc_time)
# Current UTC Time: 2024-01-02 14:33:45.025955+00:00

# Convert time to a specific time zone
current_utc_time = timezone.now()
specific_timezone = pytz.timezone("Europe/Berlin")
localized_time = timezone.localtime(current_utc_time, timezone=specific_timezone)
print("Localized Time:", localized_time)
# Localized Time: 2024-01-02 15:41:46.788069+01:00

Gestione degli Oggetti datetime Non Consapevoli

Iniziamo creando alcuni post per illustrare come gestire oggetti datetime consapevoli e non consapevoli. Assicurati che il tuo ambiente Python isolato sia attivato. Inserisci il seguente comando per aprire l’interprete Python:

(tutorialenv) ➜  mysite git:(master) ✗ python manage.py shell

Dovresti vedere qualcosa di simile:

Python 3.11.6 (main, Nov  2 2023, 04:39:40) [Clang 14.0.0 (clang-1400.0.29.202)]
Type 'copyright', 'credits' or 'license' for more information
IPython 8.19.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]:

Se non hai IPython già installato, ti consiglio di farlo eseguendo:

pip install ipython

Cominciamo importando i moduli necessari:

In [1]: from datetime import datetime

In [2]: import pytz

In [3]: from django.utils import timezone

In [4]: from django.contrib.auth.models import User

In [5]: from blog.models import Post

In [6]: pub_date = '2024-01-01'

In [7]: date_format = '%Y-%m-%d'

In [8]: parsed_pub_date = datetime.strptime(pub_date, date_format)

In [9]: author = User.objects.get(id=1)

# First Post
Post.objects.create(
    title='Naive datetime', slug='naive-datetime',
    author=author, body='content about naive datetime',
    publish=parsed_pub_date
)
~/.virtualenvs/tutorialenv/lib/python3.11/site-packages/django/db/models/fields/__init__.py:1654: RuntimeWarning: DateTimeField Post.publish received a naive datetime (2024-01-01 00:00:00) while time zone support is active.
  warnings.warn(
Out[10]: <Post: Naive datetime>

Abbiamo incontrato un RuntimeWarning da parte di Django, lamentandosi di un oggetto datetime non consapevole, ma il post è stato comunque salvato nel database.

Come possiamo eliminare questo avvertimento?

Torniamo alla shell IPython e creiamo un secondo post che risolva questo problema:

# Second post
In [11]: Post.objects.create(
    ...:     title='Aware datetime', slug='naive-datetime',
    ...:     author=author, body='content about Django aware datetime',
    ...:     publish=timezone.make_aware(parsed_pub_date)
    ...: )
Out[11]: <Post: Aware datetime>

Come puoi vedere, timezone.make_aware(parsed_pub_date) ha risolto il problema e l’avvertimento è scomparso.

Un altro punto importante che voglio sottolineare quando si gestiscono i fusi orari in Django, come ho menzionato in precedenza, Django utilizza UTC per impostazione predefinita. Come possiamo creare un post con un fuso orario specifico?

Torniamo alla shell IPython e creiamo un altro post:

# Third post
In [12]: tz = pytz.timezone("Europe/Berlin")

In [13]: specific_timezone = parsed_pub_date.astimezone(tz)

In [14]: Post.objects.create(
    ...:     title='Specific timezone', slug='specific-timezone',
    ...:     author=author, body='content about specific timezone',
    ...:     publish=specific_timezone,
    ...:     status='published'
    ...: )
Out[14]: <Post: Specific timezone>

Visualizzare Date e Orari nei Template

Quando si renderizzano date e orari nei template, è possibile utilizzare i filtri dei template di Django date e time.

<!-- post_list.html -->
{% extends "base.html" %}
{% block title %}My Blog{% endblock %}
{% block content%}
  <h1>My Blog</h1>
  {% for post in posts %}
    <h2>
      <a href="{{ post.get_absolute_url }}"> {{ post.title }} </a>
    </h2>
    <p class="date">
      Published {{ post.publish|date:"F j, Y" }} {{ post.publish|time:"g:i A" }} by {{ post.author }}
    </p>
    {{ post.body|truncatewords:30|linebreaks }}
    <hr class="border" />
  {% endfor %}<br />
  {% include "pagination.html" with page=posts %}
{% endblock %}

Per ulteriori informazioni sulla visualizzazione di date e orari nei template, visita il sito ufficiale di Django.

Non dimenticare di prendere il codice sorgente del tutorial.

Questo è tutto per ora. Resta connesso per ulteriori funzionalità avanzate e informazioni. Se hai ulteriori domande o argomenti che vorresti esplorare, sentiti libero di chiedere. Happy coding!

Se ti piace il mio contenuto, supportami! grazie.

Buy me a coffeeOffrimi un caffe'

Post correlati