Résumé du développement avec Django

J'utilise généralement Laravel (PHP) ou ASP.NET MVC (C #), mais parfois je me souviens lorsque j'utilise Django.

Ce que vous voulez vérifier

Ce que je veux savoir c'est

J'ai dit ça. En ce sens, il est principalement couvert dans l'article ici (merci), mais c'est un peu différent de mes besoins. Il y en a aussi, donc je vais essayer de le résumer à ma manière.

Sur quoi les autres utilisateurs du framework sont confus

Parce que vous utilisez un autre framework? ?? ?? Les personnes qui utilisent déjà d'autres frameworks auront plus de facilité à comprendre la différence à l'avance.

Modèle MTV au lieu de MVC

Django utilise un modèle MTV, pas un MVC. Cependant, l'image est que le nom de la pièce VC est différent plutôt que le modèle est différent, il semble donc qu'aucun nouveau concept n'est nécessaire.

La correspondance entre MVC et MTV est-elle la suivante?

Le fait de jouer avec Viwe (views.py) est comme jouer avec le contrôleur dans MVC, et Template est comme jouer avec la vue (description HTML) de MVC.

Il y a un concept de projet et d'application

Il semble que le grand concept d'un projet inclut une application.

Les paramètres communs à l'ensemble sont définis dans le périmètre du projet, et les paramètres et descriptions de chaque application sont des images réalisées par l'application.

Personnellement, j'ai eu l'impression que la relation entre la solution Visual Studio et le projet.

La structure des répertoires est un peu déroutante (pour l'explication)

Je pense que c'est une question de familiarité, mais par exemple, si vous créez un projet nommé django_test, les fichiers suivants seront générés.

django_test/
    manage.py
    django_test/
        __init__.py
        settings.py
        urls.py
        wsgi.py

Puisqu'un répertoire contenant le projet entier (django_test de niveau supérieur) et un sous-répertoire avec le même nom contenant les fichiers associés du projet sont générés, il a tendance à être difficile de dire quel répertoire django_test se trouve lorsque vous dites simplement le répertoire django_test. ..

En outre, l'opération décrite dans cet article est l'opération avec le django_test de niveau supérieur comme répertoire de calendrier.

la forme (génération automatique) est un peu spéciale

Bien que cela ne soit pas abordé dans cet article, Django a une culture de «génération automatique de formulaires», il existe donc des classes Form et des classes ModelForm pour ce faire. Sans connaissance préalable de «générer automatiquement un formulaire»? ?? ?? Cela deviendra.

Environnement de développement

Procédez comme si vous disposiez déjà d'un environnement Python (3.x). Je crée et utilise un environnement virtuel avec venv sur mon Mac. Veuillez consulter ici pour la configuration de l'environnement.

La version de python est 3.6.1, et le résultat de pip freeze est le suivant.

pip freeze
Django==1.11
django-bootstrap-form==3.2.1
PyMySQL==0.7.11
pytz==2017.2

Préparation et confirmation

Avant d'entrer dans le codage spécifique, nous allons créer et configurer le projet.

Créer un projet

Tout d'abord, créez un projet Django. Lorsque vous exécutez la commande suivante, un répertoire appelé django_test sera créé et les fichiers nécessaires seront générés.

django-admin.py startproject django_test

Vérifiez si cela fonctionne pour le moment

À ce stade, vérifions si cela fonctionne pour le moment. Démarrez le serveur de développement.

python manage.py runserver

Django utilise manage.py comme diverses commandes de contrôle. Cela ressemble à l'artisan de Laravel.

Après avoir démarré, essayez d'accéder à l'URL suivante.

http://localhost:8000

Ce n'est pas grave si [Cela a fonctionné!] Apparaît sur l'écran hostile.

Je ne peux pas migrer! !! !! Un avertissement sera affiché, mais il n'y a pas de problème car il sera traité plus tard. Si vous êtes intéressé, veuillez d'abord exécuter la migration suivante.

Lorsque la confirmation est terminée, utilisez Ctr + C pour mettre fin au serveur de développement.

Paramètres de la base de données

Maintenant, définissons les paramètres pour utiliser la base de données. Django utilise SQLite par défaut, mais j'aimerais utiliser MySQL.

Installation des packages requis

Ensuite, installez les packages requis pour utiliser MySQL à partir de Python. Il semble y en avoir différents types, mais j'utiliserai PyMySQL.

pip install PyMySQL

Modifier les paramètres.py

Une fois le package en place, définissez les informations d'accès à la base de données. Dans Django, définissez les informations de connexion à la base de données dans settings.py sous le répertoire du projet (django_test dans ce cas).

Décrivez les bases de données comme suit. Modifiez le nom de la base de données et accédez aux informations le cas échéant.

django_test/settings.py


DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'djangodb',
        'USER': 'root',
        'PASSWORD': 'root',
        'HOST': '',
        'PORT': '',
    }
}

Bien sûr, on suppose que MySQL est en cours d'exécution et qu'une base de données appelée djangodb a été créée.

Ajoutez également la description suivante en haut de settings.py afin que le projet charge le package PyMySQL.

settings.py


import pymysql
pymysql.install_as_MySQLdb()

Où dois-je vraiment l'écrire? S'il vous plaît, faites-moi savoir.

Effectuer la migration

Maintenant que vous avez défini les informations de connexion à la base de données, essayez de migrer.

python manage.py migrate

Si les paramètres de la base de données sont corrects, cela devrait fonctionner correctement. S'il y a une erreur, vérifiez divers paramètres. Lorsqu'il est exécuté correctement, il semble que le tableau suivant a été créé. Il n'y en a pas beaucoup.

+----------------------------+
| Tables_in_djangodb         |
+----------------------------+
| auth_group                 |
| auth_group_permissions     |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| django_admin_log           |
| django_content_type        |
| django_migrations          |
| django_session             |
+----------------------------+

Jouez également avec LANGUAGE_CODE et TIME_ZONE

Tout en jouant avec settings.py, jouez également avec d'autres paramètres.

LANGUAGE_CODE = 'ja'

TIME_ZONE = 'Asia/Tokyo'

À ce stade, exécutez runserver et vérifiez à nouveau http: // localhost: 8000 et le message doit être en japonais.

Créer une application

Maintenant que les paramètres relatifs à l'ensemble du projet sont terminés, créez une application. Ici, créez une application nommée sample.

Créer une application

Exécutez la commande suivante pour créer une application.

python manage.py startapp sample

Une fois exécuté, un répertoire appelé sample sera ajouté et des fichiers liés à l'application seront générés sous celui-ci. La structure hiérarchique devrait ressembler à ceci:

django_test/
    sample/
        __init__.py
        admin.py
        apps.py
        migrations/
            __init__.py
        models.py
        tests.py
        views.py
    manage.py
    django_test/

Ajouter une application

Une fois que vous avez créé une application, la projeter? Ajoutez-le à INSTALLED_APPS dans settings.py afin qu'il puisse être reconnu. Je pense que ce domaine est de type "magique", je vais donc continuer sans me plaindre.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
+   'sample',
]

Définition du modèle

Il est enfin temps de commencer à coder. Vous pouvez tout écrire, mais nous commencerons par le modèle.

Décrivez le modèle

Décrivez le modèle dans models.py généré sous sample.

Ici, définissons un modèle de membre qui imagine le stockage des informations sur les membres. Cette description est utilisée comme informations de génération de table lors de la génération d'un fichier de migration.

Il semble y avoir un moyen d'utiliser une table existante.

sample/models.py


class Member(models.Model):
	name = models.CharField('Nom complet', max_length=255)
	email = models.CharField('E-Mail', max_length=255)
	age = models.IntegerField('âge', blank=True, default=0)

	def __str__(self):
		return self.name

Créer et exécuter un fichier de migration

Maintenant, générez un fichier de migration et exécutez la migration. Générez un fichier de migration en spécifiant le nom de l'application qui a généré le modèle.

python manage.py makemigrations sample
python manage.py migrate

Faites cela chaque fois que vous apportez des modifications au modèle.

Il semble que la migration a réussi, donc je regarde la table générée. Apparemment, le nom de la table est nommé nom_application_tablename (plutôt que pluriel).

+----------------------------+
| Tables_in_djangodb         |
+----------------------------+
| auth_group                 |
| auth_group_permissions     |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| django_admin_log           |
| django_content_type        |
| django_migrations          |
| django_session             |
| sample_member              |
+----------------------------+

Jetons un coup d'œil au contenu.

Il semble que la valeur par défaut ne soit pas 0, mais je me fiche des détails et continuez.

+-------+--------------+------+-----+---------+----------------+
| Field | Type         | Null | Key | Default | Extra          |
+-------+--------------+------+-----+---------+----------------+
| id    | int(11)      | NO   | PRI | NULL    | auto_increment |
| name  | varchar(255) | NO   |     | NULL    |                |
| email | varchar(255) | NO   |     | NULL    |                |
| age   | int(11)      | NO   |     | NULL    |                |
+-------+--------------+------+-----+---------+----------------+

Utilisez le site de gestion

Django n'a pas d'échafaudage, mais il a un site d'administration prédéfini pour gérer le modèle. Vous pouvez INSÉRER les données directement dans la base de données, mais comme c'est un gros problème, activez le site de gestion et essayez de l'utiliser.

Il existe également un mécanisme appelé Fixture qui entre les données.

Créer un utilisateur de connexion

Si vous allez sur http: // localhost: 8000 / admin sans rien faire, vous pouvez accéder au site d'administration lui-même, mais il n'est pas disponible car l'utilisateur et le mot de passe de connexion ne sont pas définis. Alors générez-le.

Si le serveur de développement n'est pas en cours d'exécution, démarrez-le avec runserver.

python manage.py createsuperuser

Veuillez définir le nom d'utilisateur, l'adresse e-mail et le mot de passe selon vos besoins. Lorsque vous avez terminé, essayez de vous connecter avec l'utilisateur et le mot de passe générés.

Ajouter une table gérée

Lorsque je me connecte au site de gestion, il y a des éléments qui indiquent des groupes et des utilisateurs, mais je ne trouve pas de membres. Il semble que vous deviez vous inscrire en tant que cible de gestion pour en faire une cible de gestion.

Créez admin.py sous l'exemple comme suit.

sample/admin.py


from django.contrib import admin
from sample.models import Member

# Register your models here.
admin.site.register(Member)

Lorsque vous vous connectez (mise à jour) à l'écran de gestion à nouveau, la description «membres» est ajoutée. Maintenant, ajoutons des données car nous voulons les utiliser pour les afficher plus tard.

Montrons-le (préparation)

Avant d'afficher les données enregistrées, examinons comment elles sont affichées. Pour l'affichage

Il semble qu'il soit courant de suivre le flux, mais d'abord, utilisons uniquement la vue et la définition de routage sans utiliser de modèles.

Mécanisme d'affichage 1 (essayez d'afficher quelque chose pour le moment)

Jouez avec views.py

Définissons maintenant la vue. Plus précisément, ajoutez la description à views.py sous sample. Pour le moment, j'ai écrit une description qui renvoie directement "Index!" À la méthode appelée index.

sample/views.py


from django.shortcuts import render
from django.http import HttpResponse

# Create your views here.
def index(request):
	#Renvoie la chaîne de caractères pour le moment.
	return HttpResponse("Indice!")

Définir le routage

Ensuite, mappez l'URL et la méthode. Notez que la définition du routage dans Django ne décrit pas tout dans un seul fichier.

C'est comme une manière, alors suivez-la.

Ensuite, générez urls.py sous l'exemple et décrivez-le comme suit.

sample/urls.py


from django.conf.urls import url
from sample import views

urlpatterns = [
	url(r'^members/$', views.index, name='index'),
]

La route (URL à mapper) semble être écrite dans une expression régulière. C'est ennuyeux quand il s'agit de problèmes, mais c'est certain quand il s'agit de certitude. De plus, le premier r «» semble signifier que les caractères spéciaux tels que \ sont également traités comme des caractères ordinaires dans «».

Maintenant que la description dans l'application est terminée, écrivez ce qui suit dans urls.py sous la solution (django_test).

urls.py


from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^sample/', include('sample.urls', namespace='sample'))
]

Maintenant que la définition est terminée, exécute le serveur et essayez d'accéder à l'URL ci-dessous.

http://localhost:8000/sample/index

Si le message «Index!» S'affiche, c'est OK.

Mécanisme d'affichage 2 (essayez d'utiliser un modèle)

Maintenant que nous connaissons la relation entre views.py et urls.py, définissons un modèle (HTML) et utilisons-le.

Créer un fichier commun

Dans Django, le modèle commun est

project_name/application_name/templates/base.html

Cela semble être organisé selon la règle. ici,

django_test/sample/templates/base.html

Générez et décrivez le fichier. Le répertoire des modèles n'existe pas, alors créez-le.

J'utilise beaucoup Bootstrap, donc j'ai un peu changé l'exemple Bootstrap (changé pour utiliser CDN) et en ai fait un modèle commun.

sample/templates/base.html


{% load staticfiles %}
<!DOCTYPE html>
<html lang="ja">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>{% block title %}My books{% endblock %}</title>
    <!-- Bootstrap -->
    <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
  </head>
  <body>
    <div class="container">
      {% block content %}
        {{ content }}
      {% endblock %}
    </div>
    <!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
    <!-- Include all compiled plugins (below), or include individual files as needed -->
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
  </body>
</html>

Comme vous pouvez le voir, dans la description ci-dessus,

<title>{% block title %}My books{% endblock %}</title>

<div class="container">
      {% block content %}
        {{ content }}
      {% endblock %}
</div>

Les pièces sont remplacées dynamiquement au besoin.

Vous pouvez également définir un répertoire pour mettre du contenu statique, mais je vais l'omettre ici. En ce sens, je ne pense pas que la description {% load staticfiles%} soit nécessaire dans cette plage.

Décrivez chaque page (index.html)

Décrivez chaque page. Dans Django, il semble qu'il n'y ait pas d'association stricte entre le nom de View (contrôleur) et le nom de dossier pour d'autres frameworks MVC, mais ici, créez un répertoire appelé membres sous templates et créez index.html en dessous. · Décris.

Lisons base.html et décrivons uniquement le contenu à mapper sur le bloc défini dans base.html pour le moment.

sample/templates/members/index.html


{% extends "base.html" %}

{% block title %}
Programmé pour afficher une liste
{% endblock title %}

{% block content %}
<h1>Contenu pour le moment</h1>
{% endblock content %}

Dans le système de template de Django

{% block block_name %}{% endblock block_name %}

Il semble que l'affichage dynamique se réalise en définissant un bloc avec la règle et en préparant une variable correspondant à block_name.

Modifiez la description de views.py pour accéder à la base individuelle

Maintenant, modifiez la description de views.py afin que vous puissiez voir l'index.html créé au lieu de la description qui répondait directement à "Index!".

sample/views.py


def index(request):
	# return HttpResponse("Indice!")
	return render(request, 'members/index.html')

Lorsque l'édition est terminée, exécute le serveur et

http://localhost:8000/sample/members/

Veuillez accéder pour vérifier s'il s'affiche correctement. Le titre est-il correctement remplacé?

Essayez d'afficher les données

Maintenant, affichons les données stockées dans la base de données.

Modifier à nouveau views.py

Modifiez views.py et modifiez la description pour obtenir la valeur de la base de données et la renvoyer au modèle.

sample/views.py


from django.shortcuts import render
from django.http import HttpResponse

from sample.models import Member

# Create your views here.
def index(request):
	# return HttpResponse("Indice!")
	members = Member.objects.all().order_by('id') #Obtenez de la valeur
	return render(request, 'members/index.html', {'members':members}) #Passer une valeur au modèle

Modifier index.html

Modifiez également le côté d'affichage. Affiche les données reçues sous forme de tableau.

index.html


{% extends "base.html" %}

{% block title %}
Programmé pour afficher une liste
{% endblock title %}

{% block content %}
<h3>Affichage de la liste</h3>
<table class="table table-striped table-bordered">
	<thead>
		<tr>
			<th>ID</th>
			<th>Nom complet</th>
			<th>E-Mail</th>
			<th>âge</th>
		</tr>
	</thead>
	<tbody>
		{% for member in members %}
		<tr>
			<td>{{ member.id }}</td>
			<td>{{ member.name }}</td>
			<td>{{ member.email }}</td>
			<td>{{ member.age }}</td>
		</tr>
		{% endfor %}
	</tbody>
</table>
{% endblock content %}

Ce n'est pas particulièrement difficile, mais la partie boucle,

{% for member in members %}
<tr><td>Que faire en boucle</td></tr>
{% endfor %}

Il est décrit comme.

Veuillez vérifier et voir quand vous avez terminé.

Essayez de renvoyer JSON

Enfin, créons une API Web. Le point est la réponse dans json. Malheureusement chez Django? Il semble qu'un effort soit nécessaire.

De plus, est-ce à grande échelle? Il semble que vous puissiez également utiliser Django Rest Framework pour l'API.

Description dans views.py

Ajoutez la méthode suivante à sample / views.py. J'ai choisi une méthode appelée api ici (pas bon pour nommer).

Il semble que vous devriez répondre après avoir stocké les données acquises dans OrderedDict.

OrderedDict, comme son nom l'indique, est un type de dictionnaire ordonné, et dans un type de dictionnaire normal, l'ordre des données sera dans le désordre, il semble donc être stocké une fois dans le type OrderedDict.

sample/views.py


def api(request):
	members = []
	for member in Member.objects.all().order_by('id'):
		member_dict = OrderedDict([
				('id',member.id),
				('name',member.name),
				('email',member.email),
				('age',member.age),
			])
		members.append(member_dict)

	data = OrderedDict([
			('status','ok'),
			('members',members),
		])
	
	json_str = json.dumps(data, ensure_ascii=False, indent=2)
	return HttpResponse(json_str, content_type='application/json; charset=utf-8')

Il n'utilise pas de modèle et répond directement dans views.py. J'ai également ajouté quelque chose comme le statut au niveau supérieur (car je l'utilise souvent personnellement).

Ajouter un itinéraire

Mappez l'URL qui correspond à la méthode API que vous avez ajoutée. Pour le moment, j'ai fait ce qui suit.

from django.conf.urls import url
from sample import views

urlpatterns = [
	url(r'^members/$', views.index, name='Index'),
	url(r'^members/api/$', views.api, name='Api'),
]

Puis runserver et

http://localhost:8000/members/api/

Veuillez visiter pour voir si le json attendu est retourné.

Le json suivant est de retour.

{
  "status": "ok",
  "members": [
    {
      "id": 1,
      "name": "hoge",
      "email": "[email protected]",
      "age": 20
    },
    {
      "id": 2,
      "name": "foo",
      "email": "[email protected]",
      "age": 40
    }
  ]
}

à partir de maintenant

Maintenant que je comprends le fonctionnement de base, je pense que la prochaine étape est Je veux essayer CRUD.

Recommended Posts

Résumé du développement avec Django
Développement piloté par les tests avec Django Partie 3
Développement piloté par les tests avec Django Partie 4
Développement piloté par les tests avec Django Partie 6
Développement piloté par les tests avec Django Partie 2
Développement piloté par les tests avec Django Partie 1
Développement piloté par les tests avec Django Partie 5
Internationalisation avec Django
CRUD avec Django
Premier développement Django
Développement d'applications à l'aide de SQLite avec Django (PTVS)
Authentifier Google avec Django
Django 1.11 a démarré avec Python3.6
Télécharger des fichiers avec Django
Sortie PDF avec Django
Sortie Markdown avec Django
Utiliser Gentelella avec Django
Twitter OAuth avec Django
[Python] Créer un environnement de développement Django avec Docker
Premiers pas avec Django 1
Envoyer des e-mails avec Django
Téléchargement de fichiers avec django
Créer un environnement de développement Django à l'aide de Doker Toolbox
Utilisez LESS avec Django
La mutualisation mécanise avec Django
Utiliser MySQL avec Django
[Memo] Environnement de développement Django
Django à partir d'aujourd'hui
Premiers pas avec Django 2
Créez un environnement de développement avec Poetry Django Docker Pycharm
Articles permettant le développement de systèmes avec Django (Python) _Introduction
Faites Django avec CodeStar (Python3.6.8, Django2.2.9)
Lancez-vous avec Django! ~ Tutoriel ⑤ ~
Environnement de site Web de configuration minimale avec django
Créer une API avec Django
Mémo de construction de l'environnement de développement Django
Faites Django avec CodeStar (Python3.8, Django2.1.15)
Déployer Django sans serveur avec Lambda
Python3 + Django ~ Mac ~ avec Apache
Premiers pas avec Python Django (1)
Développement d'applications Web avec Flask
Créer une page d'accueil avec django
Lancez-vous avec Django! ~ Tutoriel ④ ~
Premiers pas avec Python Django (4)
Créer une application Web avec Django
Premiers pas avec Python Django (3)
Combinez Fast API avec Django ORM
Lancez-vous avec Django! ~ Tutoriel ⑥ ~
Développement de l'environnement Django sur Windows 10
Utilisez Django pour enregistrer les données de tweet
Effectuer le cryptage AES avec DJango
Introduction à Python Django (6)
Combinez deux images avec Django
Premiers pas avec Django avec PyCharm
Web en temps réel avec les chaînes Django
construction de l'environnement de développement de projet django
Suppression de double envoi avec Django
Framework Django REST avec Vue.js
Utilisez prefetch_related commodément avec Django