J'utilise généralement Laravel (PHP) ou ASP.NET MVC (C #), mais parfois je me souviens lorsque j'utilise Django.
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.
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.
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 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.
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.
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.
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
Avant d'entrer dans le codage spécifique, nous allons créer et configurer le 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
À 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.
Maintenant, définissons les paramètres pour utiliser la base de données. Django utilise SQLite par défaut, mais j'aimerais utiliser MySQL.
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
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.
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 |
+----------------------------+
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.
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.
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/
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',
]
Il est enfin temps de commencer à coder. Vous pouvez tout écrire, mais nous commencerons par 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
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 | |
+-------+--------------+------+-----+---------+----------------+
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.
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.
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.
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.
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!")
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.
Maintenant que nous connaissons la relation entre views.py et urls.py, définissons un modèle (HTML) et utilisons-le.
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. 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.
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é?
Maintenant, affichons les données stockées dans la base de données.
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
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é.
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.
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).
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
}
]
}
Maintenant que je comprends le fonctionnement de base, je pense que la prochaine étape est Je veux essayer CRUD.
Recommended Posts