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

Comprensione del Modulo datetime di Python

Formattazione di Date e Orari

Analisi di Stringhe in Oggetti datetime

Lavorare con i Fusi Orari in Python

Eseguire Operazioni Aritmetiche sugli Oggetti datetime

Gestire gli Intervalli di Tempo con datetime

Pacchetto di Terze Parti

Integrare datetime con i Modelli Django

Lavorare con i Fusi Orari in Django

Gestione degli Oggetti datetime Non Consapevoli

Visualizzare Date e Orari nei Template

Utilizzo Base di datetime in Python

Frank Gen. 2, 2024 6 min read 2.709

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.

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.

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

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.

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.

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.

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

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

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.

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.

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

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>

< Gennaio 2024

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.

Offrimi un caffe'