iPython notebook, c’est pratique, mais une seule personne peut coder à la fois. Si quelqu’un veut voir les changements, il faut recharger avec F5. A l’heure des Google Doc temps réel, c’est con. Surtout que c’est du ZMQ derrière.

Du coup je me suis lancé dans une expérimentation avec TogetherJS, la lib de Momo pour le travail collaboratif.

Pour lancer le truc, il suffit d’aller dans son dossier de profile iPython et éditer le fichier Javascript vierge fait pour étendre l’outil. Par exemple, sous Ubuntu, mon profile par défaut est dans ~/ipython/profile_default et le fichier à éditer est ./profile_default/static/custom/custom.js.

Dedans on met :

TogetherJSConfig_autoStart = true;
TogetherJSConfig_cloneClicks = false;
TogetherJSConfig_dontShowClicks = true;
$.getScript('https://togetherjs.com/togetherjs-min.js');

Et on est bon. Il faut ouvrir deux browsers différents pour bien tester le truc, par exemple un chrominou et un firefoune. Moi j’ai ouvert deux FF parce que j’ai pleins de profiles dessus.

La frappe est bien synchro, mais malheureusement pas l’affichage du résultat. Y a donc bien un truc intéressant à creuser, mais pour le moment, c’est pas utilisable.

Ensuite, il y a des services Web. SageMathCloud annonce faire cela, mais impossible de s’inscrire, le formulaire ne marche pas. Codebox propose un env complet de dev en ligne, mais l’inscription est temporairement suspendue. Codebunk marche pas mal, est plutôt bien foutu et clair, mais Python 2.7 uniquement, et aucun moyen d’installer une lib, donc adieu scipy ou matplotlib.

Celui qui s’en rapproche le plus est Pythonanywhere : des consoles synchronisées pour toutes les versions de Python, beaucoup de libs préinstallées (dont scipy et matplotlib), un vrai système de fichier sur lequel travailler, du pip a dispo. Et en prime un éditeur de texte pour des fichiers complets, mais qui lui, n’est pas collaboratif. Damn it. Et impossible d’afficher en ligne une image pondue via matplotlib. En plus, on a pas le concept des cellules d’iPython, qui est super pratique.

Bref, il manque vraiment un outil pour faire ce genre de choses.

playitagainsam, ou PIAS, a exactement pour but de faire cela: il lance un shell, enregistre ce qu’on y a tapé, et quand on quitte le shell, sauvegarde le tout dans un fichier. Ensuite, on peut lire le contenu du fichier et revoir la session shell telle qu’elle a été tapée.

C’est un programme Python, on peut donc le pip installer :

pip install playitagainsam --user

Ensuite, on lance une session à enregistrer avec la sous commande record :

pias record nom_du_fichier_ou_sauver_l_enregistrement

PIAS va lancer un nouveau shell, par défaut le même que votre shell actuel (souvent bash, pour moi fish), mais vous pouvez préciser un type de shell spécial avec --shell. Ex :

pias record ex1 --shell ipython

A partir de là il n’y a rien à faire. On peut travailler normalement et oublier qu’on a utilisé PIAS. Une fois qu’on a terminé sa petite affaire, il suffit de sortir du shell (CTRL + D, exit, etc), et la session va être sauvegardée dans un format JSON facile à corriger à la main si vous souhaitez la rendre plus agréable :

{
  "events": [
    {
      "act": "OPEN",
      "size": [
        162,
        33
      ],
      "term": "1c53f048e3a74984b2a93af175e24e87"
    },
    {
      "act": "PAUSE",
      "duration": 0.10042214393615723
    },
    {
      "act": "WRITE",
      "data": "\u001b]0;sam@sametmax.com: /tmp\u0007sam@sametmax.com:/tmp$ ",
      "term": "1c53f048e3a74984b2a93af175e24e87"
    },
    {
      "act": "ECHO",
      "data": "touch essai",
      "term": "1c53f048e3a74984b2a93af175e24e87"
...
}

Quand vous voulez rejouer la session :

pias play fichier_d_enregistrement

Par défaut il faut appuyer sur une touche quelconque du clavier pour voir apparaitre chaque caractère, donnant l’impression que vous êtes un hacker de Hollywood. C’est rigolo, mais parfaitement chiant à la longue. On peut faire jouer la session automatiquement avec l’option --auto-type qui va taper chaque ligne automatiquement. Il suffira alors d’appuyer sur entrée à chaque ligne pour avoir le résultat suivant. C’est mon mode préféré.

Si vous êtes un gros feignant, vous pouvez tout jouer en automatique en rajoutant l’option --auto-waypoint qui va vous dispenser de taper entrée à chaque fin de ligne. Ex :

pias play ex1 --auto-type --auto-waypoint

La session jouée est simulée. Elle n’a aucun impacte sur le système. Si vous faites un mkdir dans bash ou un shutil.rmtree dans python, ça ne fera rien.

Néanmoins, parfois il est utile d’avoir le effets réels des commandes. Dans ce cas on peut utiliser --live-replay. Attention, faites bien gaffe à ce que vous allez jouer…

playitagainsam est intéressant pour tout ce qui est formation et tutorial, d’autant plus qu’il existe un player javascript pour faire la démonstration de vos sessions shell sur un blog ou un slideshow.

Magie d’internet, un autre lecteur lui a répondu en comment, mais je me dis que donner un peu de visibilité à la réponse peut pas faire de mal, vu que je n’ai pas trouvé facilement la solution via Google DuckDuckGo.

L’idée est tout simplement d’utiliser l’option -w dans la ligne de commande pour appeler l’éditeur. En effet, sans cela l’appel à ST est non bloquant, et IPython perd la référence au processus sans avoir de valeur de retour.

Par exemple, dans votre ipython_config.py :

c.TerminalInteractiveShell.editor = "sublime_text -w"

Aujourd’hui je vais vous parler d’une fonctionnalité fantastique est très peu connue de IPython : le notebook.

Si vous êtes scientifique ou manipulez pas mal de graphiques et de données numériques, c’est un must have. Mais personnellement je trouve que c’est aussi un fantastique outil d’éducation, c’est génial pour les cours, les démos, et expérimenter avec du code inconnu.

Ça se présente sous la forme d’un shell IPython intégré dans une page Web, mais que l’on peut avoir sur son desktop, pas besoin d’avoir un serveur distant. Si vous avez un peu de temps, voici une vidéo de démo (avec un musique horrible) :

L’installation sous Ubuntu, c’est juste :

sudo apt-get install ipython-notebook

Pour Windows, il me semble, de mémoire, que c’est intégré dans l’exe. Pour Mac, je ne sais pas.

Et derrière il suffit de lancer la commande :

ipython notebook

Et il va vous ouvrir votre navigateur avec un onglet sur votre notebook.

L’intérêt principal du notebook est que TOUT le code est coloré et est modifiable comme sur dans fichier mais TOUT le code est exécutable (et affiche son résultat juste après chaque ligne) comme dans un shell iPython, avec completion du code. Le meilleur des deux mondes quoi.

En prime on peut embeder du markdown (et donc des liens, des images, etc) dans le même notebook, sauvegarder ça pour plus tard, le partager, etc.

Personnellement, j’ai ceci dans mon .bashrc :

notebook () {
    processes=$(ps aux | grep -i -P "ipython notebook" | wc -l)
    if [[ $processes -lt 2 ]]
    then
        pushd /tmp
        nohup ipython notebook --port 8889 $1 &
        popd
    else
        firefox http://127.0.0.1:8889
    fi
}

Comme ça en une commande je lance le serveur du notebook sur le port que je veux si il ne tourne pas, et si il tourne, j’ouvre firefox et ouvre un onglet dessus.

Quelques autres options très utiles :

–pylab : Charger plein de libs pour transformer IPython en un matlab killer.
–gui=lib : permet d’intégrer l’event loop de QT, wx, gtk, etc.
–ip=0.0.0.0 : si on veut que d’autres puisse accéder à notre notebook.

Il existe un espèce de pastebin spécialement fait pour le notebook, qui permet de partager ses expérimentations.

Voici ce que j’ai dans mon ./.config/ipython/profile_default/ipython_config.py:

c.TerminalIPythonApp.exec_lines = [
'doctest_mode on',
'from __future__ import unicode_literals, absolute_import, division',
'import sys',
'import os',
'import re',
'import json',
'import base64',
'import calendar',
'import csv',
'import datetime',
'import itertools',
'import random',
'import hashlib',
'import tempfile',
'import argparse',
'import math',
'import random',
'import subprocess',
'from glob import glob',
'from uuid import uuid4',
'from datetime import datetime, timedelta',
'from collections import Counter, OrderedDict',
"""
def initial_imports():
 
    # ne faites pas ça dans un code de prod :-)
    global path, relativedelta, requests 
 
    print("\\nImported : 'sys', 'os', 're', 'json', 'base64', 'calendar', 'csv', 'datetime', 'itertools', 'random', 'hashlib', 'tempfile', 'argparse', 'math', 'random', 'glob', 'uuid4', 'datetime', 'timedelta', 'Counter', 'OrderedDict', 'subprocess'\\n")
 
    try:
        from path import path
        print('Imported : "path"')
    except ImportError:
        print("'path' is not available")
 
    try:
        from dateutil import relativedelta
        print('Imported : "relativedelta"')
    except ImportError:
        print("'dateutil' is not available")
 
    try:
        import requests
        print('Imported : "requests"')
    except ImportError:
        print("'requests' is not available")
 
    try:
        env = os.environ['VIRTUAL_ENV']
        print("\\nENV '{}'. You can import:\\n".format(os.path.basename(env)))
        cmd = subprocess.check_output([env + "/bin/pip", "freeze"],
                                      stderr=subprocess.STDOUT).strip().split("\\n")
        p = re.compile(r'(^.*\:\s)|((#|@).*$)|(==.*$)')
        print("'" + "', '".join(sorted(set(os.path.basename(p.sub('', f)) for f in cmd))) + "'")
    except KeyError:
        pass
 
    print('')
""",
"initial_imports()"
]

Du coup, au démarrage d’iPython j’ai les bénéfices suivant :

• Comportement de Python 3 pour l’unicode, les imports et la division. Ils sont plus sains et facile à manipuler (plus besoin de préfixer de ‘u’ les chaînes par exemple).
• J’ai tout de suite sous la main une tonne de modules que j’utilise souvent sans avoir à les importer (os, datetime, random, etc).
• J’importe aussi des modules optionnels (path, requests…).
• Je sais si je suis dans un environnement virtuel, et si oui, ce qu’il y a installé dedans.

Je vire aussi la bannière de démarrage :

c.TerminalIPythonApp.display_banner = False

Et hop, mon affichage au démarrage ressemble à ça :

$ ipython
Exception reporting mode: Plain
Doctest mode is: ON

Imported : 'sys', 'os', 're', 'json', 'base64', 'calendar', 'csv', 'datetime', 'itertools', 'random', 'hashlib', 'tempfile', 'argparse', 'math', 'random', 'glob', 'uuid4', 'datetime', 'timedelta', 'Counter', 'OrderedDict', 'subprocess'

'path' is not available
'dateutil' is not available
Imported : "requests"

ENV 'my_env'. You can import:

'BeautifulSoup', 'Django', 'Fabric', 'Jinja2', 'Pillow', 'Pygments', 'Sphinx', 'URLObject', 'Werkzeug', 'argparse', 'beautifulsoup4', 'colorlog', 'distribute', 'django-appconf', 'django-bootstrap-pagination', 'django-bootstrap-toolkit', 'django-compressor', 'django-debug-toolbar', 'django-extensions', 'django-guardian', 'django-loginas', 'django-model-utils', 'django-pdb', 'django-pytest', 'django-rest-framework.git', 'django-template-repl', 'docutils', 'easy-thumbnails', 'feedparser', 'gunicor

Ça fait un gros bloc visuellement, mais ça ne s’affiche qu’une fois, et le délai est acceptable.

Si j’ai besoin de l’info à nouveau, je peux toujours appeler :

initial_imports()

Que ce genre de choses soient possibles et faciles me font adorer Python. La force du langage, ce n’est pas seulement son core, c’est tout son environnement, ses libs, ses outils qui gravitent autour qui rendent l’expérience de dev fantastique.

Problème, la ligne de commande est à chier sous Windows. Alors oui, vous pouvez coder dans ces conditions, mais franchement, pourquoi ne pas passer 30 minutes pour vous mettre à l’aise ?

Max est sous Mac, et je suis sous Ubuntu, mais c’est pas pour ça qu’on oublie nos racines. On a tous les deux commencé sous Windows. Perso, j’ai fait mes premiers clics de souris sur 3.1 (avant j’avais pas de souris :-)). Alors suivez le guide.

Avoir les commandes Python sous la main

Les commandes installées par des scripts Python, parfois même la commande python elle-même, ne sont pas toujours accessibles depuis la console. Assurez-vous donc d’avoir bien “c:\Python27;c:\Python27\Scripts;” à la fin de votre System PATH.

Améliorer la console

Une fois que vous avez installé Python (toujours v2.7 en 32 bits. TOUJOURS), vous avez accès au shell. Premier constat, copier / coller dans un terminal cmd.exe est aussi plaisant qu’une coloscopie un lendemain de cuite (pour vous et le praticien).

Idéalement, il faut installer un terminal alternatif. Le logiciel opensource Console2 est parfait pour ça: on peut faire du copier / coller facilement, il a des onglets, on peut régler la taille de la fenêtre…

Pour l’installer suffit de télécharger le zip, l’extraire dans “C:\Programmes Files” et faire un raccourci sur le bureau vers “C:\Program Files\Console2\Console.exe”.

Améliorer le shell Python

Le shell Python est fantastique, à l’exception de tous les autres. Donc votre premier réflexe, c’est bien entendu d’installer iPython. Sauf que Windows n’a pas readline, du coup vous n’allez pas avoir la coloration du prompt ni la completion du code. Ca craint.

C’est là que pip va encore une fois nous sauver la mise:

pip install pyreadline

Et votre shell iPython, lancé depuis Console2 est maintenant un outil presque aussi confortable à utiliser que sous Linux ou Mac avec historique, auto indent et tout le toutim. Presque, faut pas abuser non plus.

Et pour quelques outils de plus

Windows n’ayant pas de truc comme grep, installer grin va vous permettre de rapidement et confortablement chercher dans votre code. Donc, pip install grin.

Mais aller directement dans le dossier voulu depuis la ligne de commande à grand coup de cd, c’est relou. On va arranger ça.

Ouvre l’éditeur de registre (“Windows + R” puis regedit puis “enter”) et naviguez dans l’arboresence jusqu’à:

HKEY_CLASSES_ROOT\Directory\shell\

Cliquez droit dans le panel de droite, et faites “Nouveau > Clé” et appelez la clé “open_shell”. Puis cliquez sur le dossier ainsi créé, et dans le panel de droite, cliquez sur l’espèce d’icône “AB” intitulée “(Par défaut)”, et donnez lui la valeur “Ouvrir Console2 ici”.

Dans le dossier “open_shell”, créez un dossier “Command” (en faisant “Clic Droit > Nouveau > Clé”).

Donnez à “(Par défaut)” pour valeur le chemin vers Console2 suivit de ‘-d “%1″‘, par exemple pour moi:

"C:\Program Files (x86)\Console2\Console.exe" -d "%1"

Fermer l’explorateur de fichiers, et réouvrez le. Hop ! Vous avez une nouvelle entrée dans le menu du clic droit qui permet d’ouvrir Console2 dans n’importe quel dossier.

Voici quelques commandes qui vous donneront moult raisons de plus pour très vite installer ce shell alternatif.

Autocall

Taper des parenthèses et des guillemets, c’est sooooooo 1995. iPython peut vous les rajouter automatiquement dans les appels de fonctions, il faut juste préfixer de “/”, “,” ou “;” votre appel de fonction pour qu’il fasse la conversion:

/f 1,2 => f(1,2)
,f 1 2 => f("1","2")
;f 1 2 => f("1 2")

Accès au shell système

Préfixez votre commande d’un “!” bien couillu, et iPython va vous exécuter ça dans le shell système (par exemple bash) et vous retourner le résulat:

>>> ! cat /etc/fstab | grep 'ext4'
UUID=e33c5b98-1570-44d6-a32f-5e7970e1e588 /               ext4    errors=remount-ro 0       1

Oui, oui, on est dans un shell Python là. Ou comment bien faire chier la coloration syntaxique de votre blog.

Et on peut mettre tout ça dans une variable et le traiter en Python derrière:

>>> files = !ls
>>> [f.upper() for f in files]
['BUREAU', 'DOCUMENTS', 'EXAMPLES.DESKTOP', 'IMAGES', 'MOD\xc3\xa8LES', 'MUSIQUE', 'PUBLIC', 'T\xc3\xa9L\xc3\xa9CHARGEMENTS', 'UBUNTU ONE', 'VID\xc3\xa9OS',]

A noter que tout est exécuté dans un autre process, ainsi !cd n’aura aucun effet. Mais tout est prévu: %cd et %pwd proxient tout ça vers os.chdir et os.getcwd :-)

Debugger

Entrez %timeit expression pour qu’il qu’iPython vous l’exécute 10000000 fois et vous donne sa performance.

>>> %timeit x=2**100
10000000 loops, best of 3: 22.5 ns per loop

Autre commande: %pdb vous lancera automatiquement votre débuggeur favoris si une exception se lève durant votre session.

Se faciliter la vie

%edit ouvre un editeur (par défault VI sous nunux, mais c’est configurable), et si vous sauvegardez, le contenu tapé est récupéré et exécuté par iPython. Génial pour les bouts de code trop relou à taper sur le prompt.

%gui qt|wx|gtk lance l’intégration de la main loop d’un des toolkits graphiques afin pour de pouvoir faire mumuse avec des widgets sans bloquer votre shell.

Vous étiez vous demandé pourquoi le prompt iPython était plein de In et de Out, et pas de >>> ? Parce que tout l’historique est numéroté, et accessible:

In [38]: 1 + 1
Out[38]: 2
 
In [39]: In[38]
Out[39]: u'1 + 1'
 
In [40]: Out[38]
Out[40]: 2

Mais vous pouvez aussi utiliser %doctest_mode qui donne à votre prompt un air de shell Python normal. L’avantage ? On peut copier le contenu d’un autre shell dedans (et donc d’une doctest) avec les chevrons !

In [49]: %doctest_mode
Exception reporting mode: Plain
Doctest mode is: ON
>>> >>> for pom in ('pom', 'pom', 'pom', 'pom'):
...     ...     print pom
...     ... 
pom
pom
pom
pom

Avant on ajoutait un peu de sel à notre super shell en éditant les fichiers .ipython/ipythonrc et .ipython/ipy_user_conf.py. Mais ça c’était avant.

Maintenant on fait :

$ ipython profile create

Ce qui va créer un fichier ~/.config/ipython/profile_default/ipython_config.py (et ipython_qtconsole_config.py si vous avez installé la version qt).

Il ne vous reste plus qu’à éditer ce fichier pour personnaliser le démarrage de iPython.

Executer du code au démarrage

N’importe quelle ligne de code Python ou de commande magique (les trucs qui commencent pas ‘%’ qui ne fonctionnent que dans iPython) !

Très utile pour les imports par exemple. Voici ce que je fais moi au démarrage :

c.TerminalIPythonApp.exec_lines = [
'%doctest_mode',
'import os, sys, re, json',
'from datetime import datetime, timedelta',
'''
try:
    from path import path
except ImportError:
    pass
''',
'''
try:
    import requests
except ImportError:
    pass
''',
'''
try:
    from batbelt.structs import *
    from batbelt.objects import attr
    from batbelt.strings import slugify, normalize, json_dumps, json_loads
except ImportError:
    pass
'''
]

Du coup j’ai quasiment jamais besoin d’importer un truc, car ce que j’utilise le plus est déjà là. %doctest_mode me permet de coller des docstrings sans me fouler.

Programmation graphique

iPython possède une boucle principale. Les toolkits graphiques aussi. Si vous faites vos essais du code du second dans le premier, ça va bloquer. Heureusement on peut demander à iPython d’intégrer la main loop d’un des toolkits graphiques les plus célèbres en choisissant parmi : ‘qt’, ‘wx’, ‘gtk’, ‘glut’, ‘pyglet’ et ‘osx’ et en settant :

c.TerminalIPythonApp.gui = 'qt'

Virer le header

Quand on lance le shell, il vous raconte sa vie. Pour lui dire de fermer sa gueule :

c.TerminalIPythonApp.display_banner = False

Lancer un script complet

Bon, ça c’est si vous avez de gros besoins…

c.TerminalIPythonApp.file_to_run = '/path/to/script.py'

Sauter la confirmation à la fermeture

Oui, je suis sûr te vouloir te fermer connard ! Tu crois que j’ai appuyé sur Ctrl + d par erreur en éternuant ?

c.TerminalInteractiveShell.confirm_exit = False

Choisir son éditeur externe

Si vous tapez %edit dans iPython, il ouvre un éditeur. Vous tapez votre code, vous sauvegardez, vous fermez. Et iPython récupère le code et l’éxécute. Par défault il utilise VI. On peut faire mieux.

c.TerminalInteractiveShell.editor = '/chemin/vers/sublime-text -w'

Oui mais quand votre programme plante, il faut lancer l’éditeur, trouver la ligne, faire un try/except, et en plus ramer si c’est dans une boucle.

On peut faire mieux. Si vous avez ipdb et ipython installés (et si ce n’est pas le cas, un pip install les deux car on ne peut pas vivre sans), au lieu de lancer votre script ainsi:

python script.py

Lancez le ainsi:

ipython --pdb script.py

Et à la première exception, votre shell va directement s’ouvrir en mode debugger à la bonne ligne.

C’est pas merveilleux, ça ?

Pour la plupart des langages, on utilise un debugger intégré dans un IDE ou un programme à part. Ou alors on se contente de fonctions telles que var_dump ou print_r. En Python, on utilise le module pdb.

Quand vous voulez savoir ce qui se passe à un endroit du programme, à la ligne précise où vous souhaitez explorer le problème, ajoutez à votre code :

import pdb; pdb.set_trace()

Et relancez votre programme depuis une console.

L’exécution du programme va alors se figer, et dans la console vous aurez accès à un shell special:

(Pdb)

A quoi sert pdb

Dans ce shell vous pouvez entrer deux choses:

• N’importe quelle expression Python qui tient sur une ligne.
• Des commandes pdb speciales.

Ce qui est génial, c’est que toute expression Python sera éxécutée dans le context de la ligne où le programme s’est arrêté.

Donc vous pouvez faire des print, des if, des listes en intention, bref, tous les tests que vous voulez, avec les variables du programme dans l’état où elles sont à ce moment là.

Vous avez accès à tout le code, y compris vos propres objets, classes et fonctions. En fait, vous avez même accès à l’import, et donc à toutes les librairies importables.

L’essentiel des commandes

En plus de pouvoir exécuter du Python, vous pouvez utiliser des commandes. Il y en a des nombreuses, mais vous pouvez tirer l’essentiel de pdb avec six d’entre elles:

•  l: Liste quelques lignes de code avant et après là où vous vous trouver. Utile pour se resituer dans le contexte du programme. ‘l’ pour ‘list’.
•  n: Exécute la ligne suivante. Vous pouvez ainsi continuer l’exécution du programme de bout en bout, ligne par ligne, et le tester en entier. ‘n’ pour ‘next’.
•  s: Si votre ligne contient un appel de fonction ou de méthode, rentre dans à l’intérieur. ‘s’ pour ‘step in’.
•  r: Si vous êtes dans une fonction ou une méthode, celà permet d’en sortir et de passer dans le scope du dessus. ‘r’ pour ‘return’.
• unt: Si vous êtes à la dernière ligne d’une boucle, permet de reprendre l’exécution jusqu’à la sortie de la boucle. ‘unt’ pour ‘until’.
• q: Quitte brutalement le programme en le faisant crasher. ‘q’ pour ‘quit’.
• c: Quitte le debugger et continue l’exécution du programme normalement. Tous les changements que vous avez fait dans le code sont pris en compte. ‘c’ pour ‘continue’.

Pour utiliser une commande, il suffit de taper la lettre et d’appuyer sur entrée. Si vous appuyez sur entrée sans rien saisir, la commande précédente est exécutée, ce qui vous évitera de spammer le shell de commandes n.

Les limites de pdb

• Les commandes ont priorité sur le code Python. Vous ne pouvez donc pas assigner des variables dont le nom est en une seul lettre. C’est ennuyeux pour accéder à la variable ‘i‘ dans une boucle for. Dans ce cas, prefixez ‘i‘ par un ‘!‘ et il sera considéré comme du Python, et non comme une commande.
• Si vous mettez set_trace dans une boucle, le debugger va se lancer à chaque tour de boucle, ce qui embrouille tout. Dans ce cas, et dans tous les cas où vous voulez que le debugger se lance à un moment particulier, utilisez un if ou un try/except pour que set_trace ne soit appelé que dans un cas précis.
• Dans le cas de threads, de processus séparés, ou quand vous n’avez pas accès à stdout, pdb ne peut rien pour vous. Dans ce cas, le module logging est votre ami.

pdb + ipython = ipdb

Si vous êtes fan d’ipython, un coup de pip:

pip install ipdb

Et ensuite dans le programme:

import ipdb; ipdb.set_trace()

Vous aurez alors accès au shell de pdb, mais avec en prime les commandes et l’autocompletion d’ipython

Mettre un break point programmatiquement en javascript

Dans une moindre mesure, on peut aussi lancer un shell de debug depuis javascript. Ouvrez votre fenêtre d’outils Web intégrés au navigateur, Firebug ou équivalent.

Normalement il faut trouver votre script, puis la ligne, et mettre un break point.

Mais dans les navigateurs récents, vous pouvez juste ajouter:

debugger;

A la ligne voulue, et recharger la page. Votre outil de debuggage se mettra au break point automatiquement