La dernière fois, j'ai créé un environnement Django avec Docker et essayé de le toucher facilement, donc cette fois je vais creuser un peu plus dans Django à travers le tutoriel officiel tout en servant également de complément à la fois précédente. Cette fois, je suis PU de 1 à 3 du didacticiel, où j'ai personnellement estimé que c'était important.
ʻInclude () est une fonction qui représente une référence à URLconf (ici url.py). Définissez le chemin avec ʻurls.py dans l'argument et le nom de ʻurl.py auquel se référer dans le deuxième argument. Puisque nous voulons faire référence à ʻurls.py des sondages ici, nous allons définir polls.urls.
Vous pouvez définir quatre arguments pour path (): route, view, kwargs et name.
route sera l'adresse racine de l'application.
view spécifie la fonction de vue que vous voulez appeler.
kwargs peut passer n'importe quel mot-clé comme dictionnaire à view, c'est facultatif.
Si name a un nom dans ʻURL`, ce sera une URL globale qui peut être référencée de n'importe où dans Django.
Regardons ces deux exemples.
path('polls/', include('polls.urls'))
Par exemple, dans cette description, route devient la partie de'polls / '' et view devient include ('polls.urls') . Y avait-il une vue dans ʻinclude ('polls.urls')? Si vous pensez que oui, jetez un nouveau coup d'œil à ʻurls.py`. Vous pouvez voir qu'il a été importé au début.
Au fait, view dans le second argument peut aussi prendre la sortie de ʻas_views en plus de ʻinclude () comme cette fois.
ʻAs_views est une méthode de classe uniquement` qui crée une fonction qui satisfait les conditions de vue dans Django.
Pour plus de détails, voir Article de référence et le document. Il existe une méthode qui exécute une méthode du même nom que.
Dans ce cas, par exemple, de l'article précédent
class SampleView(View):
def get(self, request, *args, **kwargs):
return render(request, 'app_folder/page01.html')
def post(self, request, *args, **kwargs):
input_data = request.POST['input_data']
result = SampleDB.objects.filter(sample1=input_data)
result_sample1 = result[0].sample1
result_sample2 = result[0].sample2
context={'result_sample1':result_sample1, 'result_sample2':result_sample2}
return render(request, 'app_folder/page02.html', context=context,)
top_page = SampleView.as_view()
Dans cette partie, si request.method == 'GET' est ici, SampleView.get () sera exécuté.
ʻAs_view instancie comme cls(quand il devient une instance d'une méthode de classe, la classe elle-même est représentée parcls au lieu de self) et crée une fonction qui exécute cette méthode dispatch`. Sera «return», ce qui signifie qu'il peut être considéré comme un argument car il est classé comme «vue».
Eh bien, qu'est-ce que «nom»?
urlpatterns = [
path('', views.index, name='index')
]
C'est ce genre de gars.
En faisant cela, vous pouvez faire le processus que views.index est appelé lorsque vous frappez l'URL sous la forme de index racine / index ou index racine /.
Il y aura une utilisation plus compréhensible vers la fin, donc pour le moment, rappelez-vous simplement que le chemin sera nommé.
from django.db import models
# Create your models here.
class Question(models.Model):
question_next = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
class Choice(models.Model):
question = models.Foreignkey(Question, on_delete=models.CASCADE) #relation
choice_text = models.CharField(max_length=200)
votes = models.IntegerField(default=0)
Défini sous la forme de models.Foreignkey (nom de classe de la table à associer, on_delete = models.CASCADE).
Dans ce cas, la relation est «Question: Choix = 1: multiple».
Pour faire simple, il y a plusieurs réponses à une question.
ʻOn_delete` Ce qui suit définit s'il faut supprimer ou conserver l'objet associé à l'objet référencé lorsqu'il est supprimé. Dans le cas de «CASCADE», cela signifie que tous les objets associés sont supprimés. Par exemple
# polls_question
id question_next
0 What`s_up?
# polls_choice
id choice_text votes question_id
0 I`m_heading 0 0
1 Stomachache 1 1
Supposons que vous ayez une table comme
Ici, les données de ʻid = 0 dans la table polls_question sont supprimées, et les données de ʻid = 0 et ʻid = 1dans la tablepolls_choicequi y font référence sont également supprimées. Ce sera. Il s'agit du processus de suppression des données lorsqueCASCADEest spécifié. Il existe d'autres options, mais il semble que j'utilise souventCASCADE`.
Étant donné que les données de la relation sont un peu difficiles à gérer, j'interprète qu'il est préférable de supprimer toutes les données des deux tables qui dépendent l'une de l'autre lors de la suppression d'un.
Bien entendu, vous pouvez spécifier que l'autre est traité comme nul, ou que seul l'autre est complètement supprimé.
Eh bien, si vous terminez jusqu'à ce point, vous pouvez compléter le tableau en migrant avec migrate, mais il existe une commande qui génère une instruction SQL et montre ce que fait migrate, donc je vais l'essayer. ..
python manage.py makemigrations polls
Dans le cas de docker, utilisez la commande docker exec pour entrer dans le conteneur, passez au répertoire contenant le fichier manage.py et exécutez-le.
Vous pouvez enregistrer les migrations pour cette application en spécifiant le nom du dossier de l'application dans la commande makemigrations.
Par exemple, si vous exécutez cette commande cette fois
Migrations for 'polls':
polls/migrations/0001_initial.py
- Create model Question
- Create model Choice
Ainsi, le nom 0001 est donné à la migration et le fichier est sauvegardé. Au fait, cette fois, j'ai fait une erreur lors de la migration, et j'ai fait une erreur dans les propriétés des données enregistrées dans le tableau, donc je l'ai changé et j'ai fait à nouveau des migrations.
Dans ce cas, le fichier suivant «0002_auto_20200408_1848.py» sera créé et la table sera mise à jour lors de la «migration» à nouveau.
0002_auto_20200408_1848.py
# Generated by Django 3.0 on 2020-04-08 18:48
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('polls', '0001_initial'),
]
operations = [
migrations.RenameField(
model_name='question',
old_name='question_next',
new_name='question_text',
),
]
Ensuite, voyons ce qui se passe lorsque cette migration est «migrate».
py manage.py sqlmigrate polls 0001
Si vous spécifiez le dossier d'application et la migration dans la commande sqlmigrate comme ceci
--
-- Create model Question
--
CREATE TABLE `polls_question` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `question_next` varchar(200) NOT NULL, `pub_date` datetime(6) NOT NULL);
--
-- Create model Choice
--
CREATE TABLE `polls_choice` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `choice_text` varchar(200) NOT NULL, `votes` integer NOT NULL, `question_id` integer NOT NULL);
ALTER TABLE `polls_choice` ADD CONSTRAINT `polls_choice_question_id_c5b4b260_fk_polls_question_id` FOREIGN KEY (`question_id`) REFERENCES `polls_question` (`id`);
L'instruction SQL est affichée comme ceci, et vous pouvez voir ce que fait la commande migrate.
Il est facile de voir quel type d'instruction SQL est utilisé pour créer une table.
Après avoir vérifié jusqu'à présent, créons un tableau avec migrate.
Essayons la commande shell comme dans le tutoriel et interagissons avec la base de données.
#Importez le modèle et récupérez la classe
>>> from polls.models import Choice, Question # Import the model classes we just wrote.
#Obtenez tous les objets de la classe Question. Puisqu'il n'y a pas de données, le résultat est vide.
>>> Question.objects.all()
OUT:<QuerySet []>
#Pour utiliser le module datetime, django.Importez-y la classe timezone à partir d'utils.
>>> from django.utils import timezone
#Attribuer des données à des variables sous forme d'objets
>>> q = Question(question_text="What's new?", pub_date=timezone.now())
#Enregistrer des données
>>> q.save()
#Obtenir les propriétés des données
>>> q.id
1
>>> q.question_text
"What's new?"
>>> q.pub_date
datetime.datetime(2012, 2, 26, 13, 0, 0, 775217, tzinfo=<UTC>)
#Essayez de changer les propriétés
>>> q.question_text = "What's up?"
>>> q.save()
#Échec
>>> Question.objects.all()
<QuerySet [<Question: Question object (1)>]>
Réécrivez models.py pour éviter l'échec.
import datetime
from django.db import models
from django.utils import timezone
# Create your models here.
class Question(models.Model):
question_text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
#Ajouter 1
def __str__(self):
return self.question_text
#Ajouter 2
def was_published_recently(self):
return self.pub_date >= timezone.now() - datetime.timedelta(days=1)
class Choice(models.Model):
question = models.ForeignKey(Question, on_delete=models.CASCADE)
choice_text = models.CharField(max_length=200)
votes = models.IntegerField(default=0)
#Ajouter 3
def __str__(self):
return self.choice_text
__str__ () est une méthode objet.
Par exemple, ici, il est chargé de définir self comme argument pour instrumenter la classe et rendre chaque propriété lisible par l'homme.
La raison pour laquelle l'objet ne s'affichait pas correctement dans Question.objects.all () plus tôt est que l'objet restait lisible par machine.
En d'autres termes, l'objet ressemble à un «objet de cette classe» à nos yeux tel qu'il est, nous allons donc lui donner un nom.
L'ajout 2 sera la méthode originale.
Puisqu'il s'agit d'une formule après retour, elle renverra True ou False.
Puisque timezone.now () est la date actuelle et datetime.timedelta (days = 1) est un jour plus tard, aujourd'hui - demain est hier, et plus que cela, self.pub_date est vrai. ..
En d'autres termes, c'est une méthode qui renvoie «True» si les données de la table Question ont été créées après hier.
Cependant, dans l'état actuel des choses, il existe un bogue indiquant que «True» est renvoyé même s'il s'agit d'une date dite future.
La table de questions signifie enregistrer le contenu de la question, mais poser une question doit toujours être passée ou présente en termes de temps.
Vous avez demandé hier, vous avez dit que vous avez demandé aujourd'hui, mais vous n'avez pas dit que vous avez demandé demain, n'est-ce pas?
Ce bug semble être corrigé dans les éléments après 4 du tutoriel, donc je vais le laisser tel quel pour le moment.
Maintenant, exécutez à nouveau la commande shell.
>>> from polls.models import Choice, Question
# __str__Depuis que j'ai ajouté la méthode, question de la propriété Question_text est appelé comme nom de l'objet.
>>> Question.objects.all()
<QuerySet [<Question: What's up?>]>
#Confirmez que vous pouvez affiner les objets par identifiant avec la méthode de filtrage.
>>> Question.objects.filter(id=1)
<QuerySet [<Question: What's up?>]>
#Question de la même manière_Essayez de restreindre les objets dont le texte commence par quoi.
>>> Question.objects.filter(question_text__startswith='What')
<QuerySet [<Question: What's up?>]>
#Obtenez des objets ajoutés cette année
>>> from django.utils import timezone
>>> current_year = timezone.now().year
>>> Question.objects.get(pub_date__year=current_year)
<Question: What's up?>
# id=Erreur car les données de 2 n'existent pas
>>> Question.objects.get(id=2)
Traceback (most recent call last):
...
DoesNotExist: Question matching query does not exist.
#Obtient un objet avec une clé primaire de 1. Habituellement, la clé primaire est id. Alors ici pk=1 == id=Devenir 1
>>> Question.objects.get(pk=1)
<Question: What's up?>
#Vérifiez le fonctionnement des 2 méthodes supplémentaires
>>> q = Question.objects.get(pk=1)
>>> q.was_published_recently()
True
#Instanciez un objet dont la clé primaire est 1.
>>> q = Question.objects.get(pk=1)
#Appelez l'objet de choix associé aux objets ci-dessus. Le point est de savoir combien de réponses à la question. Puisqu'il n'y a aucune donnée dans la table Choice, elle est renvoyée vide.
>>> q.choice_set.all()
<QuerySet []>
# Question.objects.get(pk=1)En tant que réponse associée à, ajoutez trois données à la table de choix.
>>> q.choice_set.create(choice_text='Not much', votes=0)
<Choice: Not much>
>>> q.choice_set.create(choice_text='The sky', votes=0)
<Choice: The sky>
>>> c = q.choice_set.create(choice_text='Just hacking again', votes=0)
#La propriété question est la clé externe de la table Choice, c'est-à-dire la référence de clé primaire de la table Question.
>>> c.question
#Par conséquent, comme mentionné ci-dessus, la variable c est q= Question.objects.get(pk=1)Puisqu'il est lié à, le résultat suivant est renvoyé.
<Question: What's up?>
# q = Question.objects.get(pk=1)Appelez l'objet Choice associé et comptez le nombre d'objets
>>> q.choice_set.all()
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>
>>> q.choice_set.count()
3
#Parmi les objets Choice, affinez les objets dont la date de création de la question associée à la clé primaire de la table Question référencée est cette année.
>>> Choice.objects.filter(question__pub_date__year=current_year)
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>
#Supprimer un objet Choice spécifique.
>>> c = q.choice_set.filter(choice_text__startswith='Just hacking')
>>> c.delete()
polls/views.py
from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse
from .models import Question
# Create your views here.
def index(request):
latest_question_list = Question.objects.order_by('-pub_date')[:5]
context = {
'latest_question_list': latest_question_list,
}
return render(request, 'polls/index.html', context)
def detail(request, question_id):
"""
try:
question = Question.objects.get(pk=question_id)
except Question.DoesNotExist:
raise Http404("Question does not exist")
return render(request, 'polls/detaill.html', {'question': question})
"""
#Ce qui précède est un raccourci Django. avoir_object_or_Méthode 404
question = get_object_or_404(Question, pk=question_id)
return render(request, 'polls/detail.html', {'question': question})
def results(request, question_id):
response = "You`re looking at the results of question %s."
return HttpResponse(response % question_id)
def vote(request, question_id):
return HttpResponse("You`re voting on question %s." question_id)
polls/urls.py
from django.urls import path
from . import views
app_name = 'polls'
urlpatterns = [
path('', views.index, name='index'),
path('<int:question_id>/', views.detail, name='detail'),
path('<int:question_id>/results/', views.results, name='results'),
path('<int:question_id>/vote/', vies.vote, name='vote'),
]
J'ai mentionné path () plus tôt.
Par exemple, supposons que vous ayez accès à / polls / 34 / ici.
Vous souvenez-vous de ce qui se passe avec les paramètres ci-dessus?
La bonne réponse est de se référer aux ʻurl patterns dans ʻurls.py pour déterminer à quelle fonction de vue envoyer la demande, puis d'exécuter la fonction de vue qui y est appelée.
Creusons un peu plus loin.
Tout d'abord, regardez la partie spécifiée dans le premier argument de path (). J'ai fait plus tôt que l'adresse racine est entrée dans cette partie.
Par exemple, la première description est facile à comprendre. Avec cette notation, le modèle d'URL spécifié ici est / polls /.
En d'autres termes, vous pouvez voir que polls / est automatiquement spécifié même si le premier argument est vide. (Si non spécifié, une erreur se produira.)
Cela signifie que lorsque Django reçoit la requête, il charge d'abord le fichier ʻurls.pyspécifié dansROOT_URLCONF de settings.py. Il s'agit d'un fichier qui conçoit l'URL de l'ensemble du système. Dans l'exemple précédent, il s'agit de projet / projet / urls.py`.
Disons qu'il y a une telle description là-bas.
urlpatterns = [
#URL pour accéder au site de gestion
path('admin/', admin.site.urls),
#URL pour accéder à l'application "app" créée cette fois
path('app/', include('app.urls')),
#Si vous ne spécifiez aucune URL
path('', views.index, name='index'),
path('polls/', include('polls.urls')),
]
Certaines personnes ont peut-être déjà compris le mécanisme lorsqu'elles sont arrivées à ce point.
Pensez à la première partie «chemin ()» comme un sort. La troisième description est la même que précédemment.
Il convient de noter les deuxième et quatrième descriptions.
En faisant une telle description ici, vous pouvez faire référence à ʻurls.py de chaque application, et vous pouvez faire correspondre la demande avec la variable ʻurl patterns.
De plus, si vous écrivez path ('polls /', include ('polls.urls')) ici, il y a une requête telle que / polls / 34 / dans polls / url.py. , Il est déjà jugé que polls correspond, et il est jugé à quel chemin () l'autre partie correspond.
Dans ce cas, / polls / 34 / ne correspondra pas au premier path () de polls / url.py.
Ensuite, que se passe-t-il avec la deuxième description et les suivantes, regardons <int: question_id>.
Cela signifie chercher ʻintdans le modèle d'URL et le nommerquestion_id`.
À partir du document
Avec les crochets angulaires, une partie de l'URL est "capturée" et envoyée à la fonction de vue comme argument de mot-clé. La partie: question_id> de la chaîne définit le nom utilisé pour identifier le modèle correspondant, et la partie <int: est le convertisseur qui détermine le modèle qui correspond à cette partie du chemin de l'URL.
Dans ce cas, l'accès / polls / 34 / laissera la chaîne de caractères 34 /, donc il correspondra avec le deuxième path ().
Après cela, la demande est transmise à la fonction d'affichage spécifiée.
Dans ce cas, la requête est transmise à la méthode detail () de polls / views.py.
En regardant cela, request et question_id sont spécifiés comme arguments, donc par conséquent
detail(request=<HttpRequest object>, question_id=34)
Les arguments sont passés à detail () et la méthode est exécutée.
Nous vérifierons plus tard quel type de traitement est réellement effectué.
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
Cette partie de settings.py est la clé, spécifiez d'abord où placer le modèle html dans DIRS.
Si vous spécifiez un modèle pour une seule application, le nom du dossier de l'application sera entré à la place de BASE_DIR, mais si vous définissez BASE_DIR puis définissez ʻAPP_DIRS sur True`, le sous-répertoire du dossier spécifié ci-dessus sera l'application. Vous pouvez le configurer pour rechercher par le nom du dossier d'application et appliquer le modèle.
En d'autres termes, cette fois, le nom du dossier de l'application est «polls», le répertoire dans lequel les modèles sont enregistrés est donc «templates / polls».
La méthode render () peut spécifier une requête comme premier argument, un nom de modèle comme deuxième argument et un dictionnairecomme troisième argument. Ensuite, il a pour rôle de créer un objetHttpResponse` basé sur l'argument reçu et de le renvoyer.
Il semble que ce type de traitement s'appelle rendu.
Le rendu est une image du traitement qui exprime certaines informations en les transformant en un formulaire. Dans ce cas, des informations telles que les objets "request" ("session" et "get, post") et "context" (données de base de données) Et le fichier modèle html est bien combiné,
Il semble qu'il traite comme un moulage comme un écran de navigateur.
De plus, en important la classe render, vous n'aurez pas à importer la classe loader et la classe HttpResponse.
Cependant, la classe HttpResponse a d'autres rôles, il semble donc prudent de la conserver.
La prochaine exception est.
from django.http import Http404
from django.shortcuts import render
from .models import Question
# ...
def detail(request, question_id):
try:
question = Question.objects.get(pk=question_id)
except Question.DoesNotExist:
raise Http404("Question does not exist")
return render(request, 'polls/detail.html', {'question': question})
C'est une forme familière du soi-disant «try-catch».
Vous pouvez obtenir une erreur 404 en important la classe Http404 depuis le module django.http.
Code qui déclenche une exception selon qu'il existe ou non une variable «question» affectée à l'objet «Question».
Pour le dire un peu plus facilement, le processus consiste à lever une exception si les données avec l'ID demandé n'existent pas.
Comme pour la méthode render (), qui jouait également le rôle de loader et HttpRespose, vous pouvez importer des méthodes écrites de manière plus concise depuis le module django.shortcuts.
from django.shortcuts import get_object_or_404, render
from .models import Question
# ...
def detail(request, question_id):
question = get_object_or_404(Question, pk=question_id)
return render(request, 'polls/detail.html', {'question': question})
En spécifiant le nom du modèle et la clé dans la méthode get_object_or_404 (), try-catch sera traité automatiquement.
Vous pouvez définir plusieurs clés, par exemple, si vous spécifiez get_object_or_404 (User, pk = 1, name = 'tanaka'), la clé primaire est 1 et la valeur de la clé de nom est tanaka. Vous obtiendrez une erreur 404.
Au fait, il existe également une méthode appelée get_list_or_404 ().
C'est une méthode pour obtenir la valeur du modèle de la même manière, mais cette fois, elle se réduira avec la méthode filter () basée sur la clé spécifiée et obtiendra tout avec la liste.
Par exemple, si vous spécifiez get_list_or_404 (User, pk = 1, name = 'tanaka') comme précédemment, obtiendrez-vous toutes les données avec la clé primaire de 1 et la valeur de la clé name de tanaka et les renvoyer sous forme de liste? S'il n'y en a pas, vous obtiendrez une erreur 404.
C'est un système de modèle qui était également Laravel, mais il n'y a pas beaucoup de différence d'écriture et d'utilisation.
<h1>{{ question.question_text }}</h1>
<ul>
{% for choice in question.choice_set.all %}
<li>{{ choice.choice_text }}</li>
{% endfor %}
</ul>
Par exemple, avec cette description, vous l'avez peut-être remarqué simplement en la regardant, mais s'il s'agit de {{}} et de doubles accolades, ce sera une expression variable.
En d'autres termes, il exprime les attributs des variables et il est écrit que la partie «question_text» de l'objet «Question» est saisie ici.
En tant que processus
À partir du document
Le système de modèles utilise la syntaxe de recherche par points pour accéder aux attributs des variables. En prenant {{question.question_text}} comme exemple, Django effectue d'abord une recherche dans le dictionnaire sur l'objet question. Si cela échoue, il recherchera maintenant en tant qu'attribut et dans ce cas, il réussira. Si la recherche d'attribut échoue, l'index de la liste sera recherché.
Cela signifie que.
Comme vous pouvez le voir du fait que ce didacticiel est créé, le contenu de la question est inclus dans la balise h1.
Par conséquent, il y a plusieurs questions, et il est difficile de créer un modèle à chaque fois ... Donc, ce n'est pas grave si vous écrivez de cette façon et comprenez que le contenu contenu dans la balise h1 changera en fonction du contenu de la question. ..
Ensuite, dans le cas d'une parenthèse ondulée {}. Ceci fait un appel de méthode.
Le traitement cette fois est le suivant.
À partir du document
L'appel de méthode est effectué dans une boucle {% for%}. question.choice_set.all est interprété comme question.choice_set.all () dans le code Python. En conséquence, il renvoie un objet itérable composé d'objets Choice, qui peuvent être utilisés avec la balise {% for%}.
En d'autres termes, vous pouvez lister autant de balises li que d'objets choice.choice_text obtenus par cette méthode.
Dans ce cas, il s'agit d'une expression de la réponse au contenu de la question.
Il y a plusieurs façons de répondre à une question, donc ce n'est pas grave si vous savez qu'elle est exprimée de cette manière.
Rappelez-vous également, par exemple, que vous avez spécifié name plus tôt dans polls.urls?
path('<int:question_id>/', views.detail, name='detail'),
C'est comme ça. Si vous le spécifiez comme ceci, vous n'avez pas besoin d'écrire le chemin de l'URL en utilisant la balise url dans le modèle. Par exemple
<li><a href="{% url 'detail' question.id %}">{{ question.question_text }}</a></li>
C'est une telle description.
Normalement, vous devez spécifier ʻURL ou chemin dans l'attribut href de la balise ʻa.
Cependant, j'ai défini à l'avance que detail est le nom du chemin/ polls / '<int: question_id> /' '. Donc, si vous écrivezdetail comme ci-dessus et que vous mettez ensuite ʻint type named question_id (question.id ici), ce sera un chemin.
En passant, si vous voulez que ce chemin ressemble à polls / specifics / 12 /, éditez polls / urls.py.
Enfin, l'espace de noms.
En prédéfinissant un espace de noms dans ʻurls.py de chaque dossier d'application, il déterminera automatiquement quelle application ʻURLconf doit être utilisée lors de la gestion de plusieurs dossiers d'application dans un projet. Je vais.
polls/urls.py
#Ajoutez ce qui suit
app_name = 'polls'
Précisez comme ceci. Et du côté du modèle, dans la partie de la spécification du nom du chemin de l'URL
<li><a href="{% url 'polls:detail' question.id %}">{{ question.question_text }}</a></li>
Je vais le spécifier avec un espace de noms comme celui-ci.
Cela signifie que le chemin de la vue détaillée de l'application de sondages va ici.
Qu'est-ce que le rendu en premier lieu? [Explication facile à comprendre pour les débutants] Qu'est-ce que as_view dans la vue basée sur les classes de Django?
Recommended Posts