Conseils et fonctionnalités Django préférés?

308

Inspiré par la série de questions «Caractéristiques cachées de ...», je suis curieux de connaître vos astuces Django préférées ou des fonctionnalités moins connues mais utiles que vous connaissez.

  • Veuillez inclure un seul pourboire par réponse.
  • Ajoutez les exigences de version de Django s'il y en a.
Haes
la source

Réponses:

221

Je vais juste commencer par un conseil de moi-même :)

Utilisez os.path.dirname () dans settings.py pour éviter les noms de répertoire codés en dur.

Ne codez pas en dur le chemin d'accès dans votre settings.py si vous souhaitez exécuter votre projet à différents endroits. Utilisez le code suivant dans settings.py si vos modèles et fichiers statiques se trouvent dans le répertoire du projet Django:

# settings.py
import os
PROJECT_DIR = os.path.dirname(__file__)
...
STATIC_DOC_ROOT = os.path.join(PROJECT_DIR, "static")
...
TEMPLATE_DIRS = (
    os.path.join(PROJECT_DIR, "templates"),
)

Crédits: J'ai obtenu cette astuce du screencast ' Django From the Ground Up '.

Haes
la source
75
Vous ne devriez pas dévaloriser les personnes qui répondent à leurs propres questions. Il est encouragé, même s'il est prédéterminé.
Paolo Bergantino
19
C'est une si bonne idée que j'ai encore du mal à comprendre pourquoi ce n'est pas par défaut. Combien de personnes testent et déploient sur la même machine?
SingleNegationElimination
19
Cela vous soulage de toujours le type os.path.join () qui devient assez vite ennuyeux: j = lambda filename: os.path.join(PROJECT_DIR, filename). Ensuite, il vous suffit de taper j("static").
wr.
13
Si vous êtes sous Windows, remplacez les barres obliques inversées: os.path.join (PROJECT_DIR, "templates"). Replace ('\\', '/')
Peter Mortensen
7
Si vous aimez vraiment que cela soit corrigé dans Django, laissez un commentaire à code.djangoproject.com/ticket/694 demandant aux développeurs principaux de reconsidérer la wontfixdécision.
sorin
128

Installez les extensions de commande Django et pygraphviz , puis exécutez la commande suivante pour obtenir une visualisation de modèle Django très agréable:

./manage.py graph_models -a -g -o my_project.png
Haes
la source
Nice, n'a pas pu installer le pygraphviz correctement dans Windows, mais peut toujours être caché à partir du fichier dot en utilisant graphviz.
monkut
J'adore partager des diagrammes de modèle avec ce définitivement un +1
BozoJoe
Existe-t-il une option svg pour cela?
Keyo
l'image de sortie semble être détruite maintenant
Brian Wigginton
119

Utilisez le render_to décorateur de django-ennuyeux au lieu de render_to_response.

@render_to('template.html')
def foo(request):
    bars = Bar.objects.all()
    if request.user.is_authenticated():
        return HttpResponseRedirect("/some/url/")
    else:
        return {'bars': bars}

# equals to
def foo(request):
    bars = Bar.objects.all()
    if request.user.is_authenticated():
        return HttpResponseRedirect("/some/url/")
    else:
        return render_to_response('template.html',
                              {'bars': bars},
                              context_instance=RequestContext(request))

Modifié pour souligner que le retour d'une réponse HttpResponse (telle qu'une redirection) court-circuitera le décorateur et fonctionnera comme prévu.

user20955
la source
4
@becomingGuru - cela se produit automatiquement.
Dominic Rodger
15
C'est très bien, à moins que vous ne retourniez des HttpResponseRedirect () et des render_to_response (). Ensuite, les redirections échouent.
Matthew Schinckel
17
Je n'aime pas ça. "Explicite vaut mieux qu'implicite". Le décorateur ne dit pas exactement quand il va être rendu.
Tamás Szelei
2
@Matthew Schinckel, il ne gâche en fait pas les redirections - si vous retournez un objet HttpResponse, il le passe simplement sans le modifier
Jiaaro
20
Je crois que cette approche est désormais redondante à partir de Django 1.3, voir django.shortcuts.render () docs.djangoproject.com/en/dev/topics/http/shortcuts/#render
Dolph
101

Il y a un ensemble de balises personnalisées que j'utilise partout dans les modèles de mon site. Vous cherchez un moyen de le charger automatiquement (SEC, rappelez-vous?), J'ai trouvé ce qui suit:

from django import template
template.add_to_builtins('project.app.templatetags.custom_tag_module')

Si vous placez cela dans un module qui est chargé par défaut (votre URL principale par exemple), vous aurez les balises et les filtres de votre module de balises personnalisées disponibles dans n'importe quel modèle, sans utiliser {% load custom_tag_module %}.

L'argument passé à template.add_to_builtins()peut être n'importe quel chemin de module; votre module de balise personnalisé ne doit pas nécessairement vivre dans une application spécifique. Par exemple, il peut également s'agir d'un module dans le répertoire racine de votre projet (par exemple. 'project.custom_tag_module').

Steef
la source
@Steef, vous venez de m'économiser beaucoup de temps / chagrin / octets, merci.
orokusaki
Vraiment sympa. Merci. Un référentiel de balises personnalisées serait également formidable pour partager des trucs, vous ne pensez pas?
Leandro Ardissone
C'est génial jusqu'à ce que quelqu'un d'autre doive maintenir votre code. Pensez: "principe du moins magique"
Rich
96

Virtualenv + Python = économiseur de vie si vous travaillez sur plusieurs projets Django et qu'il est possible qu'ils ne dépendent pas tous de la même version de Django / d'une application.

phillc
la source
15
C'est SEULEMENT une façon de rouler!
postfuturiste
3
Pourriez-vous ajouter des liens de tutoriel pour virtualenv avec django?
BozoJoe
2
@BozoJoe: Faites ceci dans votre terminal: virtualenv myNewEnv --no-site-packages; . myNewEnv/bin/activate; pip install django; Et ça marche!
SingleNegationElimination
87

Ne codez pas en dur vos URL!

Utilisez plutôt les noms d'URL et la reversefonction pour obtenir l'URL elle-même.

Lorsque vous définissez vos mappages d'URL, donnez des noms à vos URL.

urlpatterns += ('project.application.views'
   url( r'^something/$', 'view_function', name="url-name" ),
   ....
)

Assurez-vous que le nom est unique par URL.

J'ai généralement un format cohérent "project-appplication-view", par exemple "cbx-forum-thread" pour une vue de thread.

MISE À JOUR (volant sans vergogne l'ajout d'ayaz ):

Ce nom peut être utilisé dans les modèles avec la urlbalise .

hasen
la source
1
Je suis d'accord à 100% sur celui-ci. J'ai commencé à utiliser des URL codées en dur, et cela m'a mordu dans un projet lorsque j'ai changé le format d'URL un peu pour s'adapter à certains changements. J'ai pris le temps de revenir en arrière et de tout fouiller et de remplacer les URL codées en dur. Mon seul gros reproche est que les erreurs de balise url tuent toute la page alors que le codage en dur ne gâche que le lien individuel.
ricree
21
Cela ne devrait pas être une fonction cachée, c'est la meilleure pratique et la seule façon de voler.
Skylar Saveland,
1
@skyl Ce n'est guère "la seule façon de voler". J'étais à un sprint de développement de Django et Adrian Holovaty (l'un des créateurs de Django) a dit qu'il n'utilisait même pas le urltag ... Sa position est que les URL ne devraient pas changer de toute façon (si vous voulez être amical avec votre utilisateurs).
TM.
vous pouvez également l'utiliser dans les modèles, comme dans {% url path.to.view.name arg1 arg2 %} docs.djangoproject.com/en/dev/ref/templates/builtins/…
SingleNegationElimination
Si vous utilisez jinja2, ajoutez simplement reversececi environment.filters['url'] = django.core.urlresolvers.reverseet vous pouvez l'utiliser dans vos modèles comme ceci: {{ 'view-name'|url(arg1, arg2)|e }}(le "e" est nécessaire pour échapper certains caractères à inclure dans HTML)
SingleNegationElimination
81

Utilisez la barre d'outils de débogage django . Par exemple, il permet d'afficher toutes les requêtes SQL effectuées lors du rendu de la vue et vous pouvez également afficher la trace de pile pour chacune d'entre elles.

Eugene Morozov
la source
79

N'écrivez pas vos propres pages de connexion. Si vous utilisez django.contrib.auth.

Le vrai et sale secret est que si vous utilisez également django.contrib.admin et que django.template.loaders.app_directories.load_template_source se trouve dans vos chargeurs de modèles, vous pouvez également obtenir vos modèles gratuitement!

# somewhere in urls.py
urlpatterns += patterns('django.contrib.auth',
    (r'^accounts/login/$','views.login', {'template_name': 'admin/login.html'}),
    (r'^accounts/logout/$','views.logout'),
)
SingleNegationElimination
la source
1
Cool! Je ne savais pas que nous pouvions réutiliser la page de connexion des administrateurs. Merci!
Joshua Partogi
66

Les processeurs de contexte sont géniaux.

Supposons que vous ayez un modèle d'utilisateur différent et que vous souhaitiez l'inclure dans chaque réponse. Au lieu de faire ceci:

def myview(request, arg, arg2=None, template='my/template.html'):
    ''' My view... '''
    response = dict()
    myuser = MyUser.objects.get(user=request.user)
    response['my_user'] = myuser
    ...
    return render_to_response(template,
                              response,
                              context_instance=RequestContext(request))

Les processus contextuels vous permettent de transmettre n'importe quelle variable à vos modèles. Je mets généralement le mien dans 'my_project/apps/core/context.py:

def my_context(request):
    try:
        return dict(my_user=MyUser.objects.get(user=request.user))
    except ObjectNotFound:
        return dict(my_user='')

Dans votre, settings.pyajoutez la ligne suivante à votreTEMPLATE_CONTEXT_PROCESSORS

TEMPLATE_CONTEXT_PROCESSORS = (
    'my_project.apps.core.context.my_context',
    ...
)

Désormais, chaque fois qu'une demande est faite, elle inclut my_userautomatiquement la clé.

Signale également la victoire.

J'ai écrit un article à ce sujet il y a quelques mois, donc je vais juste copier-coller:

Hors de la boîte Django vous donne plusieurs signaux qui sont incroyablement utiles. Vous avez la possibilité de faire des choses avant et après l'enregistrement, l'initialisation, la suppression ou même lorsqu'une demande est en cours de traitement. Permet donc de s'éloigner des concepts et de montrer comment ils sont utilisés. Disons que nous avons un blog

from django.utils.translation import ugettext_lazy as _
class Post(models.Model):
    title = models.CharField(_('title'), max_length=255)
    body = models.TextField(_('body'))
    created = models.DateTimeField(auto_now_add=True)

Donc, d'une manière ou d'une autre, vous souhaitez informer l'un des nombreux services de ping de blog que nous avons créé un nouveau message, reconstruire le cache des messages les plus récents et tweeter à ce sujet. Eh bien, avec les signaux, vous avez la possibilité de faire tout cela sans avoir à ajouter de méthodes à la classe Post.

import twitter

from django.core.cache import cache
from django.db.models.signals import post_save
from django.conf import settings

def posted_blog(sender, created=None, instance=None, **kwargs):
    ''' Listens for a blog post to save and alerts some services. '''
    if (created and instance is not None):
        tweet = 'New blog post! %s' instance.title
        t = twitter.PostUpdate(settings.TWITTER_USER,
                               settings.TWITTER_PASSWD,
                               tweet)
        cache.set(instance.cache_key, instance, 60*5)
       # send pingbacks
       # ...
       # whatever else
    else:
        cache.delete(instance.cache_key)
post_save.connect(posted_blog, sender=Post)

Nous y voilà, en définissant cette fonction et en utilisant le signal post_init pour connecter la fonction au modèle Post et l'exécuter après l'avoir enregistrée.

notzach
la source
4
Les signaux de Django sont une fonctionnalité incontournable pour moi de nos jours, lorsque l'on compare des frameworks web. Écrire un forum faiblement couplé, par exemple, qui peut écouter, par exemple, les mises à jour d'un module "signature", mais qui ne nécessite pas réellement que ce module fonctionne, et qui peut également fonctionner avec des modules compatibles mettant en œuvre la même fonctionnalité, est excellent. Je ne sais pas pourquoi les signaux ne sont pas plus connus et populaires.
Lee B
Les signaux sont très importants pour éviter les couplages serrés et les dégâts de code en général si nous utilisons des applications réutilisables dans notre projet. Vous avez fourni un excellent exemple de couplage lâche des applications django, +1 pour cela.
Lukasz Korzybski
Savez-vous si les signaux sont asynchrones?
Kedare
"Supposons que vous ayez un modèle d'utilisateur différent et que vous souhaitiez l'inclure dans chaque réponse." - Mettez l'utilisateur dans la session . Cela vous permet d'économiser un accès à la base de données pour chaque demande.
jammon
Les appels des signaux sont synchrones. À mon avis, une sorte de mécanisme de travail asynchrone convient mieux, par exemple, à la publication sur Twitter / Facebook / etc (c'est-à-dire - rabbitmq), de sorte que les utilisateurs de notre site Web ne se bloquent pas sur demande.
gorsky
58

Quand je commençais, je ne savais pas qu'il y avait un Paginator , assurez-vous de connaître son existence !!

hasen
la source
2
: D pareil pour moi! J'ai passé des jours à paginer!
vikingosegundo
46

Utilisez IPython pour accéder à votre code à n'importe quel niveau et déboguer en utilisant la puissance d'IPython. Une fois que vous avez installé IPython, placez simplement ce code là où vous voulez déboguer:

from IPython.Shell import IPShellEmbed; IPShellEmbed()()

Ensuite, actualisez la page, allez dans votre fenêtre runserver et vous serez dans une fenêtre IPython interactive.

J'ai un extrait de code mis en place dans TextMate donc je tape juste ipshell et appuie sur tab. Je ne pourrais pas vivre sans ça.

sheats
la source
22
Mieux installer ipdbet puis tapez simplementipdb.set_trace()
Tomasz Zieliński
Ou utilisez le débogueur d'Eclipse / PyDev. :-)
jMyles
3
import ipdb; ipdb.set_trace () FTW!
Hassek
43

Exécutez un serveur SMTP de développement qui ne fera que sortir tout ce qui lui est envoyé (si vous ne voulez pas réellement installer SMTP sur votre serveur de développement.)

ligne de commande:

python -m smtpd -n -c DebuggingServer localhost:1025
Carl G
la source
12
vous pouvez utiliser la console et déposer des backends de messagerie dans django 1.2 dans le même but
Dmitry Shevchenko
exceptionnel! parfait pour l'inscription! +1
BozoJoe
3
Alternative dans Django 1.2 avec les paramètres: EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' .. qui imprimera l'e-mail à la manage.pysortie.
vdboor
41

Depuis la documentation de django-admin :

Si vous utilisez le shell Bash, envisagez d'installer le script d'achèvement de bash Django, qui réside extras/django_bash_completiondans la distribution Django. Il permet la complétion par tabulation des commandes django-admin.pyet manage.py, vous pouvez donc, par exemple ...

  • Tapez django-admin.py.
  • Appuyez sur [TAB] pour voir toutes les options disponibles.
  • Tapez sql, puis [TAB], pour voir toutes les options disponibles dont les noms commencent par sql.
John
la source
1
C'est plus utile que ce à quoi je m'attendais. Merci!
Jeeyoung Kim
C'est par défaut dans les Ubuntu plus récents au moins. :-) J'ai été étonné quand il est sorti de nulle part.
odinho - Velmont
40

La ./manage.py runserver_plusfacilité qui vient avec django_extensions est vraiment géniale.

Il crée une page de débogage améliorée qui, entre autres, utilise le débogueur Werkzeug pour créer des consoles de débogage interactives pour chaque point de la pile (voir capture d'écran). Il fournit également une méthode de débogage pratique très utile dump()pour afficher des informations sur un objet / cadre.

entrez la description de l'image ici

Pour installer, vous pouvez utiliser pip:

pip install django_extensions
pip install Werkzeug

Ajoutez ensuite 'django_extensions'à votre INSTALLED_APPStuple settings.pyet démarrez le serveur de développement avec la nouvelle extension:

./manage.py runserver_plus

Cela va changer la façon dont vous déboguez.

DavidWinterbottom
la source
37

J'aime utiliser le débogueur Python pdb pour déboguer des projets Django.

Il s'agit d'un lien utile pour apprendre à l'utiliser: http://www.ferg.org/papers/debugging_in_python.html

Harold
la source
13
C'est une aubaine. Pour donner un peu plus d'informations, ajoutez simplement ceci: "import pdb; pdb.set_trace ()" sur n'importe quelle ligne de votre code. Actualisez votre page. Il va se bloquer. Allez maintenant dans la fenêtre de votre terminal où vous exécutez le serveur de développement. Il doit maintenant s'agir d'un shell interactif où vous pouvez accéder à toutes les variables telles qu'elles se trouvent à ce point de votre code où vous avez collé le code de débogage.
prêtre le
37

Lorsque vous essayez d'échanger des données entre Django et une autre application, request.raw_post_datac'est un bon ami. Utilisez-le pour recevoir et traiter, par exemple, des données XML.

Documentation: http://docs.djangoproject.com/en/dev/ref/request-response/

chefsmart
la source
5
C'est comme ça que tu le fais. Thankyou, +1
SingleNegationElimination
36

Utilisez Jinja2 aux côtés de Django.

Si vous trouvez le langage de gabarit Django extrêmement restrictif (comme moi!), Alors vous n'avez pas à vous en tenir à lui. Django est flexible, et le langage de modèle est vaguement couplé au reste du système, alors il suffit de brancher un autre langage de modèle et de l'utiliser pour rendre vos réponses http!

J'utilise Jinja2 , c'est presque comme une version optimisée du langage de modèle django, il utilise la même syntaxe et vous permet d'utiliser des expressions dans les instructions if! plus besoin de faire des if-tags personnalisés comme if_item_in_list! vous pouvez simplement dire %{ if item in list %}, ou {% if object.field < 10 %}.

Mais ce n'est pas tout; il a beaucoup plus de fonctionnalités pour faciliter la création de modèles, que je ne peux pas parcourir tous ici.

hasen
la source
J'utilise et j'apprécie aussi Jinja2, mais j'ai trouvé qu'il y a des couplages aux applications "contrib". En particulier, l'outil d'administration est assez fortement lié aux modèles Django. De plus, j'ai dû recréer les décorateurs de connexion dans contrib.auth pour être convivial avec Jinja2, mais pas trop dur.
Joe Holloway
24
Ne remplacez pas le système de modèles par jinja2, ajoutez-le simplement, ne supprimez pas les modèles django. Utilisez Jinja2 pour vos propres vues et laissez l'interface d'administration continuer à utiliser le langage de modèle django.
hasen
4
Je suis fermement d'accord avec cela. La syntaxe limitée de Django est tolérable, la plupart du temps, mais lorsque vous arrivez au point de créer des balises personnalisées et découvrez à quel point c'est difficile, Jinja2 est une bouffée d'air frais
SingleNegationElimination
De plus, si vous souhaitez effectuer une métaprogrammation sur la source du modèle, Jinja2 est beaucoup plus agréable, car vous pouvez accéder directement à l'AST des modèles analysés. En parcourant l'AST, il est presque facile de rechercher des modèles qui étendent un modèle de base ou de répertorier les variables non liées dans un bloc source de modèle.
rcoder
5
Heureusement dans Django 1.2, la balise IF est beaucoup plus intelligente
Nixarn
35

Ajoutez assert Falsevotre code d'affichage pour vider les informations de débogage.

zgoda
la source
4
Je pense que l'affirmation de False est plus intuitive = D
Jiaaro
13
si vous exécutez votre projet sur le serveur de développement django, utilisez le module pdb de python. C'est un moyen beaucoup plus puissant de déboguer: import pdb; pdb.stack_trace ()
mazelife
pdb est très utile, vous risquez de voir vos connexions expirer à moins que vous ne soyez très rapide à déboguer.
Stephen Paulger
4
Je me sers toujours 5 / 0. Pourquoi cinq? Aucune idée.
JasonSmith
@StephenPaulger vraiment? Mon navigateur (firefox / w firebug) semble content d'attendre plusieurs minutes une réponse pendant que je débogue.
TM.
34

Cela ajoute à la réponse ci-dessus à propos des noms d'URL de Django et de la répartition inverse des URL .

Les noms d'URL peuvent également être utilisés efficacement dans les modèles. Par exemple, pour un modèle d'URL donné:

url(r'(?P<project_id>\d+)/team/$', 'project_team', name='project_team')

vous pouvez avoir les éléments suivants dans les modèles:

<a href="{% url project_team project.id %}">Team</a>
ayaz
la source
27

Étant donné que les "vues" Django doivent uniquement être des callables qui renvoient une HttpResponse, vous pouvez facilement créer des vues basées sur des classes comme celles de Ruby on Rails et d'autres frameworks.

Il existe plusieurs façons de créer des vues basées sur une classe, voici ma préférée:

from django import http

class RestView(object):
    methods = ('GET', 'HEAD')

    @classmethod
    def dispatch(cls, request, *args, **kwargs):
        resource = cls()
        if request.method.lower() not in (method.lower() for method in resource.methods):
            return http.HttpResponseNotAllowed(resource.methods)
        try:
            method = getattr(resource, request.method.lower())
        except AttributeError:
            raise Exception("View method `%s` does not exist." % request.method.lower())
        if not callable(method):
            raise Exception("View method `%s` is not callable." % request.method.lower())
        return method(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        return http.HttpResponse()

    def head(self, request, *args, **kwargs):
        response = self.get(request, *args, **kwargs)
        response.content = ''
        return response

Vous pouvez ajouter toutes sortes d'autres éléments, tels que le traitement et l'autorisation conditionnelle des demandes dans votre vue de base.

Une fois que vous avez configuré vos vues, votre urls.py ressemblera à ceci:

from django.conf.urls.defaults import *
from views import MyRestView

urlpatterns = patterns('',
    (r'^restview/', MyRestView.dispatch),
)
mmalone
la source
2
FWIW, les auteurs de django utilisent en fait des vues basées sur les classes à quelques endroits, par exemple contrib.formtools: code.djangoproject.com/browser/django/trunk/django/contrib/…
mazelife
3
Si vous ajoutez une méthode d' appel , vous pouvez créer une classe appelée RestfulResource, puis faire pointer vos urls.py vers des instances.
Stephen Paulger
1
Les nouvelles vues génériques (Django 1.3?) Sont basées sur des classes.
gorsky
21

Au lieu d'utiliser render_to_responsepour lier votre contexte à un modèle et le rendre (ce que les documents Django montrent généralement), utilisez la vue générique direct_to_template. Il fait la même chose render_to_responsemais ajoute automatiquement RequestContext au contexte du modèle, permettant implicitement d'utiliser des processeurs de contexte. Vous pouvez le faire manuellement en utilisant render_to_response, mais pourquoi s'embêter? C'est juste une autre étape à retenir et un autre LOC. En plus d'utiliser des processeurs de contexte, avoir RequestContext dans votre modèle vous permet de faire des choses comme:

<a href="{{MEDIA_URL}}images/frog.jpg">A frog</a> 

ce qui est très utile. En fait, +1 sur les vues génériques en général. Les documents Django les montrent principalement sous forme de raccourcis pour ne même pas avoir de fichier views.py pour des applications simples, mais vous pouvez également les utiliser dans vos propres fonctions d'affichage:

from django.views.generic import simple

def article_detail(request, slug=None):
    article = get_object_or_404(Article, slug=slug)
    return simple.direct_to_template(request, 
        template="articles/article_detail.html",
        extra_context={'article': article}
    )
Mazelife
la source
Économisez encore plus de LOC en utilisant le décorateur @render_to disponible dans django-ennuyeux. bitbucket.org/offline/django-annoying
pithyless
6
..ou utilisez la nouvelle renderméthode de raccourci de Django 1.3 ( docs.djangoproject.com/en/dev/topics/http/shortcuts/#render )
gorsky
20

Je n'ai pas assez de réputation pour répondre au commentaire en question, mais il est important de noter que si vous allez utiliser Jinja , il ne prend pas en charge le caractère «-» dans les noms de blocs de modèle, contrairement à Django. Cela m'a causé beaucoup de problèmes et perdu du temps à essayer de retrouver le message d'erreur très obscur qu'il a généré.

user61000
la source
Une remarque qui peut ou non s'appliquer aux "messages d'erreur obscurs de jinja". Assurez-vous de définir TEMPLATE_DEBUG = False dans settings.py. Pour une raison quelconque, cela vous donnera des erreurs significatives à partir des modèles Jinja.
Carl G
19

L' application webdesign est très utile lorsque vous commencez à concevoir votre site Web. Une fois importé, vous pouvez l'ajouter pour générer un exemple de texte:

{% load webdesign %}
{% lorem 5 p %}
Ross Light
la source
4
Pour info, pour toute personne utilisant Jinja2 au lieu des modèles Django, vous pouvez faire: {{lipsum (5)}}
Joe Holloway
19

Tout le monde sait qu'il existe un serveur de développement que vous pouvez exécuter avec "manage.py runserver", mais saviez-vous qu'il existe également une vue de développement pour servir des fichiers statiques (CSS / JS / IMG)?

Les nouveaux arrivants sont toujours perplexes car Django ne propose aucun moyen de servir des fichiers statiques. C'est parce que l'équipe de développement pense que c'est le travail d'un serveur Web réel.

Mais lors du développement, vous ne voudrez peut-être pas configurer Apache + mod_wisgi, c'est lourd. Ensuite, vous pouvez simplement ajouter ce qui suit à urls.py:

(r'^site_media/(?P<path>.*)$', 'django.views.static.serve',
        {'document_root': '/path/to/media'}),

Votre CSS / JS / IMG sera disponible sur www.yoursite.com/site_media/.

Bien sûr, ne l'utilisez pas dans un environnement de production.

e-satis
la source
6
J'utilise ceci en mode dev, et juste pour être sûr de ne pas oublier de désactiver cela en production, j'encapsule cette règle URL dans un DEBUG uniquement conditionnel.
sghael
18

J'ai appris celui-ci dans la documentation de l'application sorl-thumbnails . Vous pouvez utiliser le mot clé "as" dans les balises de modèle pour utiliser les résultats de l'appel ailleurs dans votre modèle.

Par exemple:

{% url image-processor uid as img_src %}
<img src="{% thumbnail img_src 100x100 %}"/>

Ceci est mentionné en passant dans la documentation Django templatetag, mais en référence aux boucles uniquement. Ils n'appellent pas que vous pouvez également l'utiliser ailleurs (n'importe où?).

Joe Kueser
la source
7
Si un mot clé comme "as" peut être utilisé avec une balise de modèle, cela dépend de cette balise particulière. Il n'est pas défini par django lui-même mais par des balises uniques, selon leur signification. Jetez un œil dans la balise url mentionnée pour voir comment "as" est utilisé: code.djangoproject.com/browser/django/trunk/django/template/…
vikingosegundo
16

django.views.generic.list_detail.object_list - Il fournit toutes les variables de logique et de modèle pour la pagination (une de ces tâches que j'ai écrites mille fois maintenant). L'emballage permet à toute logique dont vous avez besoin. Cette gemme m'a sauvé de nombreuses heures de débogage des erreurs ponctuelles dans mes pages "Résultats de la recherche" et rend le code d'affichage plus propre dans le processus.

jds
la source
1
Vous pouvez trouver la nouvelle version du chapitre du livre sur les vues génériques sur djangobook.com/en/2.0/chapter11 . Celui sur le commentaire va à la version Django pré-1.0 du livre (Django livre 1.0)
Esteban Küber
16

PyCharm IDE est un environnement agréable pour coder et surtout déboguer, avec un support intégré pour Django.

Art
la source
14

Utilisez xml_models pour créer des modèles Django qui utilisent un backend d'API REST XML (au lieu d'un SQL). Cela est très utile, en particulier lors de la modélisation d'API tierces - vous obtenez la même syntaxe QuerySet que celle à laquelle vous êtes habitué. Vous pouvez l'installer à partir de PyPI.

XML à partir d'une API:

<profile id=4>
    <email>joe@example.com</email>
    <first_name>Joe</first_name>
    <last_name>Example</last_name>
    <date_of_birth>1975-05-15</date_of_birth>
</profile>

Et maintenant en python:

class Profile(xml_models.Model):
    user_id = xml_models.IntField(xpath='/profile/@id')
    email = xml_models.CharField(xpath='/profile/email')
    first = xml_models.CharField(xpath='/profile/first_name')
    last = xml_models.CharField(xpath='/profile/last_name')
    birthday = xml_models.DateField(xpath='/profile/date_of_birth')

    finders = {
        (user_id,):  settings.API_URL +'/api/v1/profile/userid/%s',
        (email,):  settings.API_URL +'/api/v1/profile/email/%s',
    }

profile = Profile.objects.get(user_id=4)
print profile.email
# would print '[email protected]'

Il peut également gérer les relations et les collections. Nous l'utilisons tous les jours dans du code de production très utilisé, donc même s'il s'agit d'une version bêta, il est très utilisable. Il dispose également d'un bon ensemble de talons que vous pouvez utiliser dans vos tests.

(Avertissement: bien que je ne sois pas l'auteur de cette bibliothèque, je suis maintenant un committer, après avoir fait quelques commits mineurs)

godswearhats
la source
projet intéressant, continuez!
Sergey Golovchenko
Merci, c'est assez pratique :-)
godswearhats
14

Utilisez les migrations de base de données. Utilisez Sud .

vad
la source