Comment déboguer dans Django, la bonne façon? [fermé]

J'ai donc commencé à apprendre à coder en Python et plus tard Django . Les premières fois, il était difficile de regarder les traces et de découvrir ce que j'avais fait de mal et où était l'erreur de syntaxe. Un certain temps s'est écoulé maintenant et en cours de route, je suppose que j'ai eu une routine de débogage de mon code Django. Comme cela a été fait au début de mon expérience de codage, je me suis assis et je me suis demandé si comment je faisais cela était inefficace et pourrait être fait plus rapidement. Je parviens généralement à trouver et à corriger les bogues dans mon code, mais je me demande si je devrais le faire plus rapidement?

J'utilise généralement les informations de débogage que Django donne lorsqu'il est activé. Lorsque les choses finissent comme je le pensais, je casse beaucoup le flux de code avec une erreur de syntaxe et regarde les variables à ce point du flux pour comprendre, où le code fait autre chose que ce que je voulais.

Mais cela peut-il être amélioré? Existe-t-il de bons outils ou de meilleures façons de déboguer votre code Django?

Il existe de nombreuses façons de le faire, mais le plus simple est d'utiliser simplement le débogueur Python . Ajoutez simplement la ligne suivante à une fonction de vue Django:

import pdb; pdb.set_trace()

ou

breakpoint()  #from Python3.7

Si vous essayez de charger cette page dans votre navigateur, le navigateur se bloque et vous obtenez une invite pour continuer le débogage sur le code d'exécution réel.

Cependant, il existe d'autres options (je ne les recommande pas):

* return HttpResponse({variable to inspect})

* print {variable to inspect}

* raise Exception({variable to inspect})

Mais le débogueur Python (pdb) est fortement recommandé pour tous les types de code Python. Si vous êtes déjà dans pdb, vous voudrez également jeter un œil à IPDB qui utilise ipython pour le débogage.

Certaines extensions plus utiles de pdb sont

pdb ++ , suggéré par Antash .

pudb , suggéré par PatDuJour .

Utilisation du débogueur Python dans Django , suggéré par Seafangs .

J'aime vraiment le débogueur interactif de Werkzeug . C'est similaire à la page de débogage de Django, sauf que vous obtenez un shell interactif à tous les niveaux du traceback. Si vous utilisez le extensions django , vous obtenez unrunserver_plus commande de gestion qui démarre le serveur de développement et vous donne le débogueur de Werkzeug sur les exceptions.

Bien sûr, vous ne devez l'exécuter que localement, car cela donne à toute personne disposant d'un navigateur le droit d'exécuter du code python arbitraire dans le contexte du serveur.

Un petit quickie pour les balises de modèle:

@register.filter 
def pdb(element):
    import pdb; pdb.set_trace()
    return element

Maintenant, à l'intérieur d'un modèle, vous pouvez le faire {{ template_var|pdb }}et entrer une session pdb (étant donné que vous exécutez le serveur de développement local) où vous pouvez inspecterelement le contenu de votre cœur.

C'est une très belle façon de voir ce qui est arrivé à votre objet lorsqu'il arrive au modèle.

Il existe quelques outils qui coopèrent bien et peuvent faciliter votre tâche de débogage.

Le plus important est la barre d'outils de débogage de Django .

Ensuite, vous avez besoin d'une bonne journalisation à l'aide de la fonction de journalisation Python . Vous pouvez envoyer la sortie de journalisation vers un fichier journal, mais une option plus simple consiste à envoyer la sortie de journal à firepython . Pour l'utiliser, vous devez utiliser le navigateur Firefox avec le firebug extension . Firepython inclut un plugin Firebug qui affichera toute journalisation côté serveur dans un onglet Firebug.

Firebug lui-même est également essentiel pour déboguer le côté Javascript de toute application que vous développez. (En supposant que vous ayez du code JS bien sûr).

J'ai aussi aimé django-viewtools pour déboguer des vues de manière interactive à l'aide de pdb, mais je ne l'utilise pas beaucoup.

Il existe des outils plus utiles comme le bulldozer pour traquer les fuites de mémoire (il y a aussi d'autres bonnes suggestions données dans les réponses ici sur SO pour le suivi de la mémoire).

J'utilise PyCharm (même moteur pydev qu'eclipse). M'aide vraiment à pouvoir visuellement parcourir mon code et voir ce qui se passe.

Presque tout a été mentionné jusqu'à présent, donc je vais seulement ajouter qu'au lieu d' pdb.set_trace()un, on peut utiliser ipdb.set_trace () qui utilise iPython et est donc plus puissant (saisie semi-automatique et autres goodies). Cela nécessite un package ipdb, vous n'avez donc qu'àpip install ipdb

J'ai poussé django-pdbvers PyPI . C'est une application simple qui signifie que vous n'avez pas besoin de modifier votre code source à chaque fois que vous souhaitez pénétrer dans pdb.

L'installation est juste ...

1. pip install django-pdb
2. Ajoutez 'django_pdb'à votreINSTALLED_APPS

Vous pouvez maintenant exécuter: manage.py runserver --pdbpour pénétrer dans pdb au début de chaque vue ...

bash: manage.py runserver --pdb
Validating models...

0 errors found
Django version 1.3, using settings 'testproject.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

GET /
function "myview" in testapp/views.py:6
args: ()
kwargs: {}

> /Users/tom/github/django-pdb/testproject/testapp/views.py(7)myview()
-> a = 1
(Pdb)

Et exécutez: manage.py test --pdbpour pénétrer dans pdb sur les échecs / erreurs de test ...

bash: manage.py test testapp --pdb
Creating test database for alias 'default'...
E
======================================================================
>>> test_error (testapp.tests.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File ".../django-pdb/testproject/testapp/tests.py", line 16, in test_error
    one_plus_one = four
NameError: global name 'four' is not defined
======================================================================

> /Users/tom/github/django-pdb/testproject/testapp/tests.py(16)test_error()
-> one_plus_one = four
(Pdb)

Le projet est hébergé sur GitHub , les contributions sont bien sûr les bienvenues.

Le moyen le plus simple de déboguer python - en particulier pour les programmeurs habitués à Visual Studio - est d'utiliser PTVS (Python Tools for Visual Studio). Les étapes sont simples:

1. Téléchargez et installez-le depuis http://pytools.codeplex.com/
2. Définissez des points d'arrêt et appuyez sur F5.
3. Votre point d'arrêt est atteint, vous pouvez afficher / modifier les variables aussi facilement que le débogage de programmes C # / C ++.
4. C'est tout :)

Si vous souhaitez déboguer Django à l'aide de PTVS, vous devez procéder comme suit:

1. Dans Paramètres du projet - onglet Général, définissez "Fichier de démarrage" sur "manage.py", le point d'entrée du programme Django.
2. Dans Paramètres du projet - onglet Débogage, définissez "Arguments de script" sur "runserver --noreload". Le point clé est le "--noreload" ici. Si vous ne le définissez pas, vos points d'arrêt ne seront pas atteints.
3. Profitez-en.

J'utilise pyDev avec Eclipse vraiment bien, je fixe des points d'arrêt, j'entre dans le code, je vois les valeurs de tous les objets et variables, j'essaye.

J'utilise PyCharm et je le maintiens tout le long. Cela m'a coûté un peu mais je dois dire que l'avantage que j'en retire est inestimable. J'ai essayé de déboguer à partir de la console et je donne beaucoup de crédit aux gens qui peuvent le faire, mais pour moi, pouvoir déboguer visuellement ma ou mes applications est génial.

Je dois dire cependant que PyCharm prend beaucoup de mémoire. Mais là encore, rien de bon n'est gratuit dans la vie. Ils viennent tout juste de sortir avec leur dernière version 3. Elle fonctionne également très bien avec Django, Flask et Google AppEngine. Donc, dans l'ensemble, je dirais que c'est un excellent outil pratique pour tout développeur.

Si vous ne l'utilisez pas encore, je vous recommande d'obtenir la version d'essai pendant 30 jours pour jeter un œil à la puissance de PyCharm. Je suis sûr qu'il existe également d'autres outils, comme Aptana. Mais je suppose que j'aime aussi l'apparence de PyCharm. Je me sens très à l'aise pour déboguer mes applications là-bas.

Parfois, lorsque je veux explorer une méthode particulière et que l'invocation de pdb est trop lourde, j'ajoute:

import IPython; IPython.embed()

IPython.embed() démarre un shell IPython qui a accès aux variables locales à partir du point où vous l'appelez.

De mon point de vue, nous pourrions décomposer les tâches de débogage de code courantes en trois modèles d'utilisation distincts:

1. Quelque chose a levé une exception : runserver_plus le débogueur Werkzeug de à la rescousse. La possibilité d'exécuter du code personnalisé à tous les niveaux de trace est un tueur. Et si vous êtes complètement bloqué, vous pouvez créer un Gist à partager en un seul clic.
2. La page est rendue, mais le résultat est faux : encore une fois, Werkzeug bascule. Pour créer un point d'arrêt dans le code, tapez simplement assert Falsel'endroit où vous souhaitez vous arrêter.
3. Le code fonctionne mal , mais la recherche rapide n'aide pas. Très probablement, un problème algorithmique. Soupir. Ensuite , je fais feu habituellement une console débogueur PUDB : import pudb; pudb.set_trace(). Le principal avantage par rapport à [i] pdb est que PuDB (tout en ayant l'air des années 80) facilite la définition d'expressions de montre personnalisées. Et le débogage d'un tas de boucles imbriquées est beaucoup plus simple avec une interface graphique.

Ah, oui, les problèmes des modèles. Le problème le plus courant (pour moi et mes collègues) est un mauvais contexte: soit vous n'avez pas de variable, soit votre variable n'a pas d'attribut. Si vous utilisez la barre d'outils de débogage , inspectez simplement le contexte dans la section "Modèles" ou, si cela ne suffit pas, définissez une rupture dans le code de vos vues juste après que votre contexte soit rempli.

Alors ça va.

Je recommande fortement epdb (Extended Python Debugger).

https://bitbucket.org/dugan/epdb

Une chose que j'aime avec epdb pour le débogage de Django ou d'autres serveurs Web Python est la commande epdb.serve (). Cela définit une trace et la sert sur un port local auquel vous pouvez vous connecter. Cas d'utilisation typique:

Je pense que je veux passer par étape. Je vais insérer ce qui suit au point où je veux définir la trace.

import epdb; epdb.serve()

Une fois ce code exécuté, j'ouvre un interpréteur Python et me connecte à l'instance de desserte. Je peux analyser toutes les valeurs et parcourir le code en utilisant les commandes pdb standard comme n, s, etc.

In [2]: import epdb; epdb.connect()
(Epdb) request
<WSGIRequest
path:/foo,
GET:<QueryDict: {}>, 
POST:<QuestDict: {}>,
...
>
(Epdb) request.session.session_key
'i31kq7lljj3up5v7hbw9cff0rga2vlq5'
(Epdb) list
 85         raise some_error.CustomError()
 86 
 87     # Example login view
 88     def login(request, username, password):
 89         import epdb; epdb.serve()
 90  ->     return my_login_method(username, password)
 91
 92     # Example view to show session key
 93     def get_session_key(request):
 94         return request.session.session_key
 95

Et des tonnes de plus que vous pouvez à tout moment apprendre à taper l'aide epdb.

Si vous souhaitez servir ou vous connecter à plusieurs instances epdb en même temps, vous pouvez spécifier le port sur lequel écouter (la valeur par défaut est 8080). C'est à dire

import epdb; epdb.serve(4242)

>> import epdb; epdb.connect(host='192.168.3.2', port=4242)

l'hôte par défaut est «localhost» s'il n'est pas spécifié. Je l'ai ajouté ici pour montrer comment vous pouvez l'utiliser pour déboguer autre chose qu'une instance locale, comme un serveur de développement sur votre réseau local. Évidemment, si vous faites cela, faites attention à ce que la trace définie ne parvienne jamais sur votre serveur de production!

En bref, vous pouvez toujours faire la même chose que la réponse acceptée avec epdb ( import epdb; epdb.set_trace()) mais je voulais mettre en évidence la fonctionnalité de service car je l'ai trouvée si utile.

Je viens de trouver wdb ( http://www.rkblog.rk.edu.pl/w/p/debugging-python-code-browser-wdb-debugger/?goback=%2Egde_25827_member_255996401 ). Il a une interface utilisateur / GUI assez agréable avec toutes les cloches et les sifflets. L'auteur dit ceci à propos de wdb -

"Il existe des IDE comme PyCharm qui ont leurs propres débogueurs. Ils offrent un ensemble de fonctionnalités similaires ou égales ... Cependant, pour les utiliser, vous devez utiliser ces IDE spécifiques (et certains d'entre eux ne sont pas gratuits ou peuvent ne pas être disponibles pour tous) Choisissez l'outil adapté à vos besoins. "

Je pensais que je le transmettrais.

Également un article très utile sur les débogueurs python: https://zapier.com/engineering/debugging-python-boss/

Enfin , si vous souhaitez voir une belle impression graphique de votre pile d'appels dans Django, consultez: https://github.com/joerick/pyinstrument . Ajoutez simplement pyinstrument.middleware.ProfilerMiddleware à MIDDLEWARE_CLASSES, puis ajoutez? Profile à la fin de l'URL de la demande pour activer le profileur.

Peut également exécuter pyinstrument à partir de la ligne de commande ou en l'important en tant que module.

Ajoutez import pdb; pdb.set_trace()ou breakpoint() (forme python3.7) à la ligne correspondante dans le code Python et exécutez-le. L'exécution s'arrêtera avec un shell interactif. Dans le shell, vous pouvez exécuter du code Python (c'est-à-dire imprimer des variables) ou utiliser des commandes telles que:

• c continuer l'exécution
• n passer à la ligne suivante dans la même fonction
• s passer à la ligne suivante dans cette fonction ou une fonction appelée
• q quitter le débogueur / exécution

Voir également: https://poweruser.blog/setting-a-breakpoint-in-python-438e23fe6b28

L'une de vos meilleures options pour déboguer le code Django est via wdb: https://github.com/Kozea/wdb

wdb fonctionne avec python 2 (2.6, 2.7), python 3 (3.2, 3.3, 3.4, 3.5) et pypy. Encore mieux, il est possible de déboguer un programme python 2 avec un serveur wdb s'exécutant sur python 3 et vice-versa ou de déboguer un programme s'exécutant sur un ordinateur avec un serveur de débogage s'exécutant sur un autre ordinateur à l'intérieur d'une page web sur un troisième ordinateur! Encore mieux, il est maintenant possible de suspendre un processus / thread python en cours d'exécution en utilisant l'injection de code à partir de l'interface Web. (Cela nécessite gdb et ptrace activés) En d'autres termes, c'est une version très améliorée de pdb directement dans votre navigateur avec de belles fonctionnalités.

Installez et exécutez le serveur, et dans votre code ajoutez:

import wdb
wdb.set_trace()

Selon l'auteur, les principales différences en ce qui pdbconcerne:

Pour ceux qui ne connaissent pas le projet, wdb est un débogueur python comme pdb, mais avec une interface Web fluide et de nombreuses fonctionnalités supplémentaires, telles que:

• Mise en évidence de la syntaxe source
• Points d'arrêt visuels
• Complétion de code interactive à l'aide de jedi
• Points d'arrêt persistants
• Inspection d'objets en profondeur à l'aide de la souris Prise en charge du multithreading / multiprocessing
• Débogage à distance
• Regarder les expressions
• Dans l'édition du code du débogueur
• Intégration de serveurs Web populaires pour rompre en cas d'erreur
• En cas de rupture d'exception pendant la trace (pas post-mortem) contrairement au débogueur werkzeug par exemple
• Interruption des programmes en cours d'exécution par injection de code (sur les systèmes pris en charge)

Il a une excellente interface utilisateur basée sur un navigateur. Une joie à utiliser! :)

J'utilise PyCharm et différents outils de débogage. Ayez également de beaux articles sur la configuration facile de ces choses pour les novices. Vous pouvez commencer ici. Il raconte le débogage PDB et GUI en général avec les projets Django. J'espère que quelqu'un en bénéficierait.

Si vous utilisez Aptana pour le développement de django, regardez ceci: http://www.youtube.com/watch?v=qQh-UQFltJQ

Sinon, envisagez de l'utiliser.

La plupart des options sont déjà mentionnées. Pour imprimer le contexte du modèle, j'ai créé une bibliothèque simple pour cela. Voir https://github.com/edoburu/django-debugtools

Vous pouvez l'utiliser pour imprimer le contexte du modèle sans aucune {% load %}construction:

{% print var %}   prints variable
{% print %}       prints all

Il utilise un format d'impression personnalisé pour afficher les variables dans une <pre>balise.

Je trouve que Visual Studio Code est génial pour le débogage des applications Django. Les paramètres standard de launch.json de python s'exécutent python manage.pyavec le débogueur attaché, vous pouvez donc définir des points d'arrêt et parcourir votre code comme vous le souhaitez.

Pour ceux qui peuvent accidentellement ajouter pdb dans des validations en direct, je peux suggérer cette extension de la réponse #Koobz:

@register.filter 
def pdb(element):
    from django.conf import settings
    if settings.DEBUG:    
        import pdb
        pdb.set_trace()
    return element

D'après ma propre expérience, il y a deux façons:

1. utilisez ipdb , qui est un débogueur amélioré comme pdb.

   import ipdb;ipdb.set_trace()ou breakpoint() (à partir de python3.7)

2. utilisez le shell django, utilisez simplement la commande ci-dessous. Ceci est très utile lorsque vous développez une nouvelle vue.

   python manage.py shell

je suggère fortement d'utiliser PDB.

import pdb
pdb.set_trace()

Vous pouvez inspecter toutes les valeurs des variables, intervenir dans la fonction et bien plus encore. https://docs.python.org/2/library/pdb.html

pour vérifier tous les types de requêtes, de réponses et de hits sur la base de données. J'utilise django-debug-toolbar https://github.com/django-debug-toolbar/django-debug-toolbar

Comme mentionné dans d'autres articles ici - définir des points d'arrêt dans votre code et parcourir le code pour voir s'il se comporte comme prévu est un excellent moyen d'apprendre quelque chose comme Django jusqu'à ce que vous ayez une bonne idée de la façon dont tout se comporte - et de ce que votre code fait.

Pour ce faire, je recommanderais d'utiliser WingIde. Tout comme les autres IDE mentionnés sont agréables et faciles à utiliser, une mise en page agréable et des points d'arrêt faciles à définir évaluent / modifient la pile, etc. Parfait pour visualiser ce que fait votre code lorsque vous le parcourez. J'en suis un grand fan.

J'utilise également PyCharm - il a une excellente analyse de code statique et peut parfois aider à repérer les problèmes avant de vous rendre compte qu'ils sont là.

Comme déjà mentionné, django-debug-toolbar est essentiel - https://github.com/django-debug-toolbar/django-debug-toolbar

Et bien qu'il ne soit pas explicitement un outil de débogage ou d'analyse - l'un de mes favoris est le middleware d'impression SQL disponible auprès de Django Snippets à https://djangosnippets.org/snippets/290/

Cela affichera les requêtes SQL que votre vue a générées. Cela vous donnera une bonne idée de ce que fait l'ORM et si vos requêtes sont efficaces ou si vous devez retravailler votre code (ou ajouter la mise en cache).

Je le trouve inestimable pour garder un œil sur les performances des requêtes lors du développement et du débogage de mon application.

Juste une autre astuce - je l'ai légèrement modifiée pour mon usage personnel afin d'afficher uniquement le résumé et non l'instruction SQL .... Je l'utilise donc toujours lors du développement et des tests. J'ai également ajouté que si le len (connection.queries) est supérieur à un seuil prédéfini, il affiche un avertissement supplémentaire.

Ensuite, si je constate que quelque chose de mauvais (du point de vue des performances ou du nombre de requêtes) se produit, je reviens à l'affichage complet des instructions SQL pour voir exactement ce qui se passe. Très pratique lorsque vous travaillez sur un grand projet Django avec plusieurs développeurs.

utiliser pdbou ipdb. La différence entre ces deux est que ipdb prend en charge la saisie semi-automatique.

pour pdb

import pdb
pdb.set_trace()

pour ipdb

import ipdb
ipdb.set_trace()

Pour exécuter une nouvelle touche de ligne n, pour continuer la touche de ctouche. vérifier plus d'options en utilisanthelp(pdb)

Une suggestion supplémentaire.

Vous pouvez tirer parti nosetests et pdb ensemble, plutôt injecter pdb.set_trace()dans vos vues manuellement. L'avantage est que vous pouvez observer les conditions d'erreur lors de leur premier démarrage, potentiellement dans du code tiers.

Voici une erreur pour moi aujourd'hui.

TypeError at /db/hcm91dmo/catalog/records/

render_option() argument after * must be a sequence, not int

....


Error during template rendering

In template /opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/crispy_forms/templates/bootstrap3/field.html, error at line 28
render_option() argument after * must be a sequence, not int
18  
19          {% if field|is_checkboxselectmultiple %}
20              {% include 'bootstrap3/layout/checkboxselectmultiple.html' %}
21          {% endif %}
22  
23          {% if field|is_radioselect %}
24              {% include 'bootstrap3/layout/radioselect.html' %}
25          {% endif %}
26  
27          {% if not field|is_checkboxselectmultiple and not field|is_radioselect %}
28  

      {% if field|is_checkbox and form_show_labels %}

Maintenant, je sais que cela signifie que j'ai gaffé le constructeur du formulaire, et j'ai même une bonne idée de quel champ est un problème. Mais, puis-je utiliser pdb pour voir de quoi se plaignent les formulaires croustillants dans un modèle ?

Oui je peux. Utilisation de la --pdb option sur nosetests:

tests$ nosetests test_urls_catalog.py --pdb

Dès que je frappe une exception (y compris celles gérées avec élégance), pdb s'arrête là où cela se produit et je peux regarder autour de moi.

  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/forms.py", line 537, in __str__
    return self.as_widget()
  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/forms.py", line 593, in as_widget
    return force_text(widget.render(name, self.value(), attrs=attrs))
  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/widgets.py", line 513, in render
    options = self.render_options(choices, [value])
  File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/widgets.py", line 543, in render_options
    output.append(self.render_option(selected_choices, *option))
TypeError: render_option() argument after * must be a sequence, not int
INFO lib.capture_middleware log write_to_index(http://localhost:8082/db/hcm91dmo/catalog/records.html)
INFO lib.capture_middleware log write_to_index:end
> /opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/django/forms/widgets.py(543)render_options()
-> output.append(self.render_option(selected_choices, *option))
(Pdb) import pprint
(Pdb) pprint.PrettyPrinter(indent=4).pprint(self)
<django.forms.widgets.Select object at 0x115fe7d10>
(Pdb) pprint.PrettyPrinter(indent=4).pprint(vars(self))
{   'attrs': {   'class': 'select form-control'},
    'choices': [[('_', 'any type'), (7, (7, 'type 7', 'RECTYPE_TABLE'))]],
    'is_required': False}
(Pdb)         

Maintenant, il est clair que mon argument de choix pour le constructeur de champ croustillant était comme s'il s'agissait d'une liste dans une liste, plutôt que d'une liste / d'un tuple de tuples.

 'choices': [[('_', 'any type'), (7, (7, 'type 7', 'RECTYPE_TABLE'))]]

La chose intéressante est que ce pdb se déroule dans le code de crispy, pas le mien et je n'ai pas eu besoin de l'insérer manuellement.

Pendant le développement, l'ajout d'un

assert False, value

peut aider à diagnostiquer les problèmes dans les vues ou ailleurs, sans avoir besoin d'utiliser un débogueur.