{{ form.as_table }} – Visualizza i moduli Django come tabella

Nell'arena dello sviluppo web, Django è emerso come un famoso framework Internet Python open source e di alto livello che incoraggia il miglioramento rapido e una progettazione semplice e pragmatica. Django vanta un solido modo di gestire i dispositivi, che consente agli sviluppatori di creare, convalidare e gestire documenti cartacei senza sforzo. Una componente essenziale della forma di Django che gestisce i dispositivi è la sua capacità di rendere i moduli come tabelle HTML.

In questo post, esamineremo la procedura per rendere i moduli Django come tabelle, che includono le benedizioni, come ottenerle e alcune pratiche eccezionali da osservare. Entro la fine di questo post, avrai informazioni approfondite su come semplificare il tuo metodo di sviluppo web rendendo efficacemente i moduli Django come tabelle.

Perché visualizzare i moduli Django come tabella?

Il rendering dei moduli Django come tabelle può offrire una serie di vantaggi agli sviluppatori web. Alcuni di questi vantaggi includono:

Layout strutturato: la visualizzazione dei fattori di forma in una tabella fornisce un layout fluido e preparato, facilitando la comprensione e l'interazione dei clienti con il modulo.
Layout reattivo: con il CSS appropriato, le tabelle possono adattarsi facilmente a dimensioni e dispositivi speciali dello schermo, assicurandosi che una persona costante possa godere di un paio di sistemi.
Manutenibilità migliorata: visualizzando i moduli come tabelle, i programmatori possono ridurre la quantità di codice guida HTML e CSS che desiderano mettere per iscritto, rendendo meno difficile la conservazione e l'aggiornamento dei moduli alla fine.
Accessibilità: l'utilizzo delle tabelle per il rendering dei moduli può migliorare l'accessibilità per i clienti con disabilità, poiché gli screen reader possono interpretare meglio la forma e la relazione tra i fattori di forma.

Come visualizzare i moduli Django come tabella

Ora che abbiamo compreso i vantaggi del rendering dei moduli Django come tabelle, esploriamo i passaggi necessari per raggiungere questo obiettivo.

Pacchetti da installare

Installa Django: apri il terminale e digita il seguente comando per installare Django

pip install django

Crea un nuovo progetto Django: sempre nel terminale, digita il seguente comando per creare un nuovo progetto Django:

django−admin startproject myproject

Naviga nella directory del tuo progetto

cd myproject

Crea una nuova app Django

python manage.py startapp myapp

Crea un nuovo file form.py nella directory Myapp

Per cominciare, dobbiamo creare un modulo Django. Ciò verrà ottenuto caratterizzando una classe di modulo nel file form.py, acquisendo da django.forms.ModelForm o django.forms.Form.

Importa i moduli fondamentali: moduli dal pacchetto django e il modello Utente dal file models.py dell'app corrente.
Crea una classe di modulo chiamata UserForm che eredita da Forms.ModelForm.
All'interno della classe UserForm, crea una classe Meta nidificata.
Imposta l'attributo del modello della classe Meta sul modello Utente. Questo dice a Django che il modulo verrà utilizzato per creare o modificare le istanze dell'utente.
Crea un elenco di nomi di campo all'interno della qualità del campo della classe Meta. Questi sono i campi che verranno inclusi nel modulo.

from django import forms
from .models import User

class UserForm(forms.ModelForm):
    class Meta:
        model = User
        fields = ['first_name', 'last_name', 'roll_no', 'password']

Aggiorna views.py nella directory Myapp

Il codice importa UserForm dai moduli e lo utilizza nella funzione user_form_view, che rende il modulo in "form.html".

from django.shortcuts import render
from .forms import UserForm

def user_form_view(request):
    form = UserForm()
    return render(request, 'form.html', {'form': form})

Crea una nuova directory templates nella directory myapp e crea un nuovo file form.html nella directory templates

Di seguito utilizzeremo il metodo integrato di Django per il rendering dei moduli come tabelle: il metodo as_table. Nel tuo modello, chiamerai il metodo as_table nell'occorrenza del modulo come quello riportato di seguito:

Crea un componente frame HTML con la proprietà metodo="POST" per indicare che il frame utilizzerà il metodo POST durante l'invio dei dati.
Utilizzare il tag di formato {% csrf_token %} per includere un token CSRF all'interno del modulo, che consente di proteggersi dagli attacchi di imitazione di richieste intersito.
Crea un elemento tabella HTML.
All'interno dell'elemento table, utilizza il tag template {{ form.as_table }} per eseguire il rendering del modulo Django come tabella. Ciò produrrà l'HTML vitale per ciascun campo del modulo, con ciascun campo mostrato nella propria riga della tabella.
Aggiungi un componente di input HTML con l'attributo type="submit" per creare un pulsante di invio per il modulo.

<form method="POST">
  {% csrf_token %}
  <table class="form-table" style="width: 100%;">
    {{ form.as_table }}
  </table>
  <input type="submit" value="Submit">
</form>

Aggiorna urls.py nella directory myapp

Questo frammento di codice sta creando un routing URL per l'applicazione Django myapp. Definisce un percorso per la visualizzazione del modulo utente nell'URL di base.

from django.urls import path
from .views import user_form_view

urlpatterns = [
    path('', user_form_view, name='user_form'),
]

Aggiorna urls.py nella directory Myproject

Questo codice imposta le principali configurazioni URL per il progetto Django myproject. Include le configurazioni URL sia per il sito di amministrazione che per l'applicazione myapp.

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

Esegui il server

python manage.py runserver

Ora, se accedi a http://127.0.0.1:8000/ nel tuo browser web, dovresti vedere il tuo modulo. Questo è l'"output" della tua applicazione Django.

Produzione

Ce l'abbiamo fatta! Il nostro modulo Django è stato renderizzato con successo come tabella. Ecco il modulo di registrazione dell'utente finale, che mostra elegantemente quattro campi.

Un'applicazione Web in Django è costituita da più parti interconnesse e non è possibile condensarla in un unico script Python autonomo che è possibile eseguire per un output nella console.

Best practice per il rendering dei moduli Django come tabella

Per garantire la migliore esperienza utente e manutenibilità possibili, seguire queste best practice durante il rendering dei moduli Django come tabelle:

Utilizza markup semantico: utilizza i componenti della tabella di adattamento, come thead, tbody e tfoot, per fornire impostazioni molto migliori e migliorare l'accessibilità.
Aggiungi nomi e segnaposto: assicurati di incorporare oltre ogni dubbio nomi per ogni campo del modulo, così come segnaposto, per indirizzare gli utenti attraverso il processo di compilazione del modulo.
Applica un piano reattivo: assicurati che la tua tabella sia reattiva utilizzando query multimediali CSS o un framework CSS, come Bootstrap, che fornisce classi di tabelle reattive.
Implementa la protezione CSRF: proteggi i tuoi moduli dagli attacchi CSRF (cross-site request forgery) includendo il tag del modello {% csrf_token %} all'interno dell'elemento del modulo. Django gestirà automaticamente la protezione CSRF quando viene utilizzato questo tag.

Conclusione

Il rendering dei moduli Django come tabelle offre vari vantaggi, tra cui un formato organizzato, un design reattivo, una manutenibilità avanzata e una migliore disponibilità. Seguendo i passaggi delineati in questo articolo e seguendo le migliori pratiche, sarai ben attrezzato per creare applicazioni web semplificate, facili da usare e praticabili utilizzando Django.

Mentre procedi a creare le tue abilità Django, tieni presente di rimanere aggiornato con le migliori pratiche, strumenti e procedure più recenti per garantire che i tuoi progetti siano continuamente efficaci, sicuri e facili da usare.