Blog Django | Comment Créer Votre Premier Blog Avec Django

le


Codez un blog simple en utilisant Python et Django.

Blog Django | Comment Créer Votre Premier Blog Avec Django

Pour tous ceux qui cherchent à coder leur propre blog, Django est un outil utile pour ceux qui aiment coder avec Python. En tant que tel, Django peut essentiellement être utilisé comme blocs de construction pour éliminer les conjectures et gagner du temps de développement . Dans cet article, nous explorerons les avantages de Django, comment utiliser Django sur un VPS auto-hébergé et comment créer un blog avec Django.

Qu'est-ce que Django ?

Django est un framework web open-source, écrit en Python, qui suit le modèle architectural model-view-template. Par conséquent, un framework Web n'est qu'un ensemble de composants qui vous aident à développer des sites Web plus rapidement et plus facilement. Fondamentalement, il s'agit d'extraits de code prédéfinis, qui ont déjà été testés et débogués, qui peuvent être utilisés avec votre propre code. Cela permet une configuration rapide et facile du code complexe et complexe sans avoir à se soucier du développement de la base ou du framework.

Lors de la création d'un site Web, il faut toujours un ensemble de composants similaire : un moyen de gérer l'authentification des utilisateurs (inscription, connexion, déconnexion), un panneau de gestion pour votre site Web, des formulaires, un moyen de télécharger des fichiers, etc. Heureusement, d'autres personnes ont remarqué il y a longtemps que les développeurs Web sont confrontés à des problèmes similaires lors de la création d'un nouveau site, ils se sont donc associés et ont créé des frameworks (Django étant l'un d'entre eux) qui offrent des composants prêts à l'emploi à utiliser.

Les frameworks existent pour éviter aux développeurs d'avoir à réinventer la roue et pour aider à alléger une partie des frais généraux lors de la création d'un nouveau site à l'aide de Django.

Qu'est-ce que Python ?

Python est un langage de programmation interprété, orienté objet, de haut niveau avec une sémantique dynamique. En d'autres termes, il ne s'agit que d'un autre langage de programmation et de l'une des nombreuses options dont disposent les développeurs lorsqu'ils envisagent de créer un nouveau site ou une nouvelle application Web. Quelques exemples célèbres de sites Web construits avec python incluent Google, YouTube, DropBox et Reddit. Le plus grand avantage de Python par rapport à tous les autres langages de programmation et options est sa vitesse. En conséquence, Python 3.5 arrive généralement presque un TROISIÈME du temps ou plus rapidement qu'un site Web PHP 5.6!

Python est un langage orienté objet extrêmement polyvalent et puissant, ce qui signifie qu'il peut être utilisé pour créer des applications et des programmes Web assez puissants.

Avantages d'un blog Django ou d'une application Web Django

Le plus gros avantage d'utiliser Django pour créer un blog ou une application Web est assez clair, c'est la vitesse. Cependant, cette vitesse est double lorsqu'il s'agit de Django. Tout d'abord, il est en cours de développement, car vous n'avez pas besoin de réinventer la roue, vous constaterez que vous vous contentez de parcourir de nombreuses parties lourdes et chronophages du développement. Votre nouveau site ou application pourra monter en flèche plus loin et plus haut que jamais, car il a été construit sur le dos de géants. La plupart, sinon la totalité, du travail que vous feriez aura déjà été fait ET testé pour vous lorsque vous choisirez de travailler dans un cadre.

Deuxièmement, la vitesse des performances. Django est basé sur Python, qui a maintes fois surpassé Ruby et PHP. À l'heure actuelle des sites Web et des applications mobiles, il est important que vous relayiez les données le plus rapidement possible en effectuant le moins d'appels serveur possible. Vous voulez être sûr que vos clients ne perdent pas à la fois du temps et des données précieuses sur leurs plans, simplement en essayant de charger votre site Web.

Tutoriel Django : Comment créer un blog avec Django

Comment créer un blog avec Django. Source de la capture d'écran : django-planet

Étape 1 : Installation de Django

Connectez-vous d' abord à votre tableau de bord SkySilk et sélectionnez "Créer un conteneur", puis sélectionnez simplement un plan.

 

Lorsque votre plan est sélectionné, choisissez une configuration matérielle ou configurez votre propre matériel personnalisé.

Une fois que vous avez configuré votre matériel, sélectionnez « Applications et outils », puis recherchez « Django » et sélectionnez-le.

Enfin, entrez simplement les informations requises et appuyez sur « Go ! »

LIRE : Avantages des applications Linux clé en main sur un VPS Linux SkySilk

Étape 2 : Démarrage de l'application

Accédez à votre répertoire de projet, il doit contenir un __init__.py, manage.py, settings.py et urls.py . Il peut aussi y en avoir d'autres. Pour référence, mon nom de projet est djangorocks, vous devrez remplacer toutes les références à djangorocks tout au long de ce didacticiel.

De plus, tapez ce qui suit dans le terminal ; cela crée un nouveau dossier d'application et des fichiers clés que nous utiliserons pour notre blog :

python manage.py startapp blog

En conséquence, vous devriez maintenant avoir un dossier appelé blog contenant 3 fichiers : __init__.py , models.py et views.py .

Important:

Ouvrez votre settings.py, il se trouve dans votre dossier de projet. Recherchez INSTALLED_APPS et ajoutez « blog ». Par conséquent, vous devriez avoir quelque chose de similaire à ce qui suit ;

INSTALLED_APPS = (

   'django.contrib.auth',

   'django.contrib.contenttypes',

   'django.contrib.sessions',
   
   'django.contrib.sites',

   'djangorocks.blog',

)

Django connaît maintenant votre nouvelle application, il ne reste plus qu'à la créer.

Étape 3 : Définissez vos modèles

Le modèle est la structure de votre base de données. Commençons par ouvrir le fichier models.py et commençons à ajouter des champs. Comme il s'agit d'un simple quide, il n'inclura pas les utilisateurs à ce stade.

Blog de classe (modèles.Modèle):
   title = models.CharField(max_length=100, unique=True)
   slug = models.SlugField(max_length=100, unique=True)
   corps = modèles.TextField()
   posté = models.DateField(db_index=True, auto_now_add=True)
   catégorie = modèles.ForeignKey('blog.Category')

Catégorie de classe (modèles.Modèle) :
   title = models.CharField(max_length=100, db_index=True)
   slug = models.SlugField(max_length=100, db_index=True)

Cela crée une table de base de données avec le nom "Blog". En conséquence, cela doit être quelque chose d'évident et sera beaucoup utilisé.

Blog de classe (modèles.Modèle):

Ce sont des champs de base à créer dans votre base de données :

title = models.CharField(max_length=100, db_index=True)
slug = models.SlugField(max_length=100, db_index=True)
corps = modèles.TextField()
posté = models.DateTimeField(db_index=True, auto_now_add=True)

Le dernier champ, un peu plus avancé. Ce champ remplit ses données à partir d'une autre table de base de données, dans ce cas, Catégorie, vous devrez donc d'abord remplir le champ de la table Catégorie.

catégorie = modèles.ForeignKey('blog.Category')

Finir

Il y a donc quelques éléments supplémentaires à ajouter au modèle maintenant que nous avons décidé de la structure de la base de données. Votre fichier de modèle terminé devrait ressembler à ceci.

depuis django.db importer des modèles
de django.db.models importer un lien permanent

# Créez vos modèles ici.

Blog de classe (modèles.Modèle):
   title = models.CharField(max_length=100, unique=True)
   slug = models.SlugField(max_length=100, unique=True)
   corps = modèles.TextField()
   posté = models.DateTimeField(db_index=True, auto_now_add=True)
   catégorie = modèles.ForeignKey('blog.Category')

   def __unicode__(self):
       renvoie '%s' % self.title

   @lien permanent
   def get_absolute_url(self):
       return ('view_blog_post', None, { 'slug': self.slug })

Catégorie de classe (modèles.Modèle) :
   title = models.CharField(max_length=100, db_index=True)
   slug = models.SlugField(max_length=100, db_index=True)

   def __unicode__(self):
       renvoie '%s' % self.title

   @lien permanent
   def get_absolute_url(self):
       return ('view_blog_category', None, { 'slug': self.slug })

A quoi servent ces suppléments ?

La fonction __unicode__ définit la référence de texte pour chaque enregistrement. Ceci est principalement utilisé dans l'administration automatisée de Django, mais il est toujours disponible pour une utilisation sur votre propre site.

La fonction get_absolute_url définit une URL, à nouveau utilisée dans la zone d'administration, pour chaque enregistrement.

Sans le décorateur @permalink , ce qui suit ne fonctionnerait pas. Cela renvoie une URL calculée à partir du fichier urls.py qui sera expliqué sous peu. Je recommanderais d'utiliser cette méthode car elle vous permet de modifier l'URL d'une page à un seul endroit.

return ('view_blog_post', None, { 'slug': self.slug })

Exemple

Titre : Comment créer un blog avec Django

Réponse de __unicode__ : Comment créer un blog avec Django

Réponse de get_absolute_url : /blog/view/how-to-make-a-blog-with-django.html

Étape 4 : Configurer l'Auto-Admin

Dans bon nombre de vos propres applications, vous souhaiterez probablement écrire vos propres fonctions d'administration :

Créez admin.py dans le dossier du blog que nous avons créé précédemment. Ce fichier admin.py est automatiquement vérifié par l'administrateur Django pour chaque application définie sous INSTALLED_APPS dans settings.py

de django.contrib administrateur d'importation
de blog.models importer Blog, Catégorie

admin.site.register(Blog)
admin.site.register(Catégorie)

Importez la commande qui nous permet d'enregistrer le modèle que nous avons créé

de django.contrib administrateur d'importation

Aussi, importez nos modèles

de blog.models importer Blog, Catégorie

Enregistrez nos modèles Blog & Catégorie avec l'administrateur

admin.site.register(Blog)
admin.site.register(Catégorie)

Bien que ces trois lignes suffisent à faire fonctionner l'administrateur, nous souhaitons ajouter un peu plus de fonctionnalités. Voici le fichier admin.py final .

de django.contrib administrateur d'importation
de djangorocks.blog.models importer Blog, Catégorie

classe BlogAdmin(admin.ModelAdmin):
   exclure = ['publié']
   prepopulated_fields = {'slug': ('title',)}

classe CategoryAdmin(admin.ModelAdmin):
   prepopulated_fields = {'slug': ('title',)}

admin.site.register (Blog, BlogAdmin)
admin.site.register (Catégorie, CategoryAdmin)

Maintenant que vous avez ajouté ces modèles dans l'administrateur, vous souhaiterez peut-être vous connecter et ajouter quelques catégories et articles de blog.

Étape 5 : Rédaction des vues

La vue est l'endroit où vous effectuez toute la logique à envoyer à vos modèles. Dans cet exemple, nous ne traiterons pas de RequestContext . En conséquence, cela vous donnerait accès à l' objet de demande qui contient les détails de l'utilisateur actuellement connecté, ainsi qu'à quelques autres fonctionnalités que vous serez susceptible d'utiliser à l'avenir.

Pour cet exemple, nous devons créer 3 vues.

  • Affichez vos catégories et derniers articles
  • Afficher les publications dans une catégorie spécifique
  • Afficher la publication

Voici une copie du view.py .

# Créez vos vues ici.

de djangorocks.blog.models importer Blog, Catégorie
de django.shortcuts importer render_to_response, get_object_or_404

def index (demande):
   return render_to_response('index.html', {
       'catégories' : Category.objects.all(),
       « messages » : Blog.objects.all()[:5]
   })

def view_post(request, slug):   
   return render_to_response('view_post.html', {
       'post' : get_object_or_404(Blog, slug=slug)
   })

def view_category(request, slug):
   catégorie = get_object_or_404(Catégorie, slug=slug)
   return render_to_response('view_category.html', {
       'catégorie' : catégorie,
       « messages » : Blog.objects.filter(category=category)[:5]
   })

Comme pour le fichier admin.py , nous devons importer les modèles.

de djangorocks.blog.models importer Blog, Catégorie

Nous devons également importer quelques fonctions pour afficher notre modèle.

de django.shortcuts importer render_to_response, get_object_or_404

Ce qui suit est pour votre page d'index, qui affichera une liste de toutes vos catégories et 5 messages les plus récents.

Lors de la définition des fonctions, vous devez toujours spécifier la variable request . Il s'agit de l'objet request, qui contient les détails des données User, POST & GET ainsi que quelques autres bits. Dans l'exemple suivant, nous spécifions également slug qui est mappé à partir du fichier urls.py comme vous le verrez dans une minute

def view_category(request, slug):

Cette première partie définit le fichier modèle que nous allons utiliser.

render_to_response('test.html', {

La partie suivante interroge la base de données pour les catégories et les articles. Catégorie et Blog sont les noms des modèles que nous avons créés précédemment.

'catégories' : Category.objects.all(),
« messages » : Blog.objects.all()[:5]

Dans les deux autres fonctions view_post & view_category, nous utilisons l'un des raccourcis Django plutôt utiles. Cela interroge la base de données en essayant de faire correspondre où slug=slug , le premier slug étant le champ du modèle, le deuxième slug étant l'entrée dans l'appel de fonction, plus à ce sujet dans une seconde lorsque nous définissons les URL.

get_object_or_404(Blog, slug=slug)

Étape 6 : Définir les URL

Ouvrez le urls.py situé dans votre dossier de projet, ajoutez les 3 lignes suivantes.

(r'^$', 'djangorocks.blog.views.index'),
URL(
   r'^blog/view/(?P<slug>[^\.]+).html', 
   'djangorocks.blog.views.view_post', 
   name='view_blog_post'),
URL(
   r'^blog/category/(?P<slug>[^\.]+).html', 
   'djangorocks.blog.views.view_category', 
   name='view_blog_category'),

La première correspondance d'URL n'est qu'une simple correspondance rien, c'est-à-dire http://www.votredomaine.com/, et la mappe à l' index de vue . Les deux derniers ont des variables personnalisées transmises à la vue. Ce ne sont que des expressions régulières dont le paramètre correspond à la syntaxe de Django.

(?P<slug>[^\.]+)


L'utilisation de l'extension .html sur les URL devrait fonctionner correctement. Cela correspond à tout jusqu'à '.', il existe d'autres façons de le faire, et il mappe le résultat sur slug qui est également le nom d'un paramètre dans les fonctions view_post et view_category .

La dernière partie étiquetée nom est ce que nous avons utilisé lors de la définition des modèles. get_absolute_url renvoie une URL calculée automatiquement en fonction de l'URL saisie ici. Définir cela une seule fois signifie que si vous modifiez l'URL de mappage, elle changera également dans tout le site. Vous pouvez également utiliser la balise template fournie par Django pour faire une chose similaire, cependant, cela n'est pas utilisé dans notre exemple.

Étape 7 : Création de modèles

Le système de modèles de Django est extrêmement puissant, par conséquent, nous n'utiliserons qu'une petite poignée de ses fonctionnalités dans cet exemple.

Tout d'abord, créons notre modèle de base. Ceci est juste un exemple très basique, qui n'est pas du XHTML valide. Ce modèle seul ne fait pas grand-chose.

base.html

<html>
   <tête>
       <title>{% block head_title %}Bienvenue sur mon blog{% endblock %}</title>
   </head>
   <corps>
       <h1>{% block title %}Bienvenue dans mon bloc{% endblock %}</h1>
       {% contenu du bloc %}

       {% bloc final %}
   </body>
</html>
index.html

{% étend 'base.html' %}
{% block title %}Bienvenue sur mon blog{% endblock %}

{% contenu du bloc %}
   <h2>Catégories</h2>
   {% si catégories %}
       <ul>
       {% pour la catégorie dans les catégories %}
           <li><a href="{{ category.get_absolute_url }}">{{ category.title }}</a></li>
       {% fin pour %}
       </ul>
   {% autre %}
       <p>Il n'y a pas de messages.</p>
   {% fin si %}

   <h2>Messages</h2>
   {% si messages %}
       <ul>
       {% pour la publication dans les publications %}
           <li><a href="{{ post.get_absolute_url }}">{{ post.title }}</a></li>
       {% fin pour %}
       </ul>
   {% autre %}
       <p>Il n'y a pas de messages.</p>
   {% fin si %}

{% bloc final %}


vue_post.html

{% étend 'base.html' %} 
{% block head_title %}{{ post.title }}{% endblock %}
{% block title %}{{ post.title }}{% endblock %}

{% contenu du bloc %}
   {{ post.body }}
{% bloc final %}
vue_catégorie.html

{% étend 'base.html' %} 
{% block head_title %}Affichage de la catégorie {{ category.title }}{% endblock %}
{% titre du bloc %}{{ category.title }}{% endblock %}

{% contenu du bloc %}
   {% si messages %}
       <ul>
       {% pour la publication dans les publications %}
           <li><a href="{{ post.get_absolute_url }}">{{ post.title }}</a></li>
       {% fin pour %}
       </ul>
   {% autre %}
       <p>Il n'y a pas de messages.</p>
   {% fin si %}
{% bloc final %}

Ainsi, dans le fichier base.html, nous définissons le contenu de base, <html> , <body> etc., ainsi que les blocs que nous souhaitons afficher. Par conséquent, le contenu de ces derniers est généré en fonction du contenu qui étend le modèle de base.

Sur la première ligne des trois autres fichiers, vous remarquerez

{% étend 'base.html' %}

Cette ligne appelle le fichier modèle base.html . À l'intérieur, nous définissons les blocs de la même manière que dans le fichier base.html , mais cette fois nous ajoutons le contenu que nous voulons afficher. En utilisant l'exemple de index.html

Nous définissons le bloc pour le contenu :

{% contenu du bloc %}
   ...
{% bloc final %}

À l'intérieur, nous vérifions s'il existe des catégories. De plus, les variables que nous utilisons ici ont été définis dans le views.py fichier dans la render_to_response fonction.

{% si catégories %}
   ....
{% autre %}
   <p>Il n'y a pas de messages.</p>
{% fin si %}

S'il y a des catégories, alors ce qui suit est exécuté :

<ul>
   {% pour la catégorie dans les catégories %}
       <li><a href="{{ category.get_absolute_url }}">{{ category.title }}</a></li>
   {% fin pour %}
</ul>

Enfin, il bouclera la réponse du modèle Category tel que défini dans views.py et imprimera les résultats entrés dans la base de données.

Comment créer un blog avec Django : conclusion

Toutes nos félicitations! Vous avez parcouru tout le didacticiel et vous devriez maintenant être en mesure de répondre à des questions telles que :

Qu'est-ce que Django ?

Qu'est-ce que Python ?

Qu'est-ce qu'un framework Web ?

Comment créer un blog avec Django ?

Avec ces connaissances, vous pouvez commencer à coder un blog avec Django comme base de votre framework Web. Particulièrement pertinent, avec un VPS Linux SkySilk auto-hébergé et un modèle Django clé en main, vous pouvez déployer les ressources exactes dont vous avez besoin pour la portée du projet en quelques secondes et, en outre, les faire évoluer selon vos besoins.

Commentaires

Enregistrer un commentaire