Qual é a maneira correta de depurar no notebook iPython?

Como eu sei, %debug magicpode fazer depuração dentro de uma célula.

No entanto, tenho chamadas de função em várias células.

Por exemplo,

In[1]: def fun1(a)
           def fun2(b)
               # I want to set a breakpoint for the following line #
               return do_some_thing_about(b)

       return fun2(a)

In[2]: import multiprocessing as mp
       pool=mp.Pool(processes=2)
       results=pool.map(fun1, 1.0)
       pool.close()
       pool.join

O que eu tentei:

1. Eu tentei definir %debugna primeira linha da célula 1. Mas ele entra no modo de depuração imediatamente, mesmo antes de executar a célula 2.

2. Eu tentei adicionar %debuga linha logo antes do código return do_some_thing_about(b). Mas o código é executado para sempre, nunca para.

Qual é a maneira correta de definir um ponto de interrupção no notebook ipython?

Use ipdb

Instale-o via

pip install ipdb

Uso:

In[1]: def fun1(a):
   def fun2(a):
       import ipdb; ipdb.set_trace() # debugging starts here
       return do_some_thing_about(b)
   return fun2(a)
In[2]: fun1(1)

Para executar o uso linha a linha ne para entrar em uma função, use se para sair do uso do prompt de depuração c.

Para obter uma lista completa dos comandos disponíveis: https://appletree.or.kr/quick_reference_cards/Python/Python%20Debugger%20Cheatsheet.pdf

Você pode usar o ipdbjupyter interno com:

from IPython.core.debugger import Tracer; Tracer()()

Edit : as funções acima estão obsoletas desde o IPython 5.1. Esta é a nova abordagem:

from IPython.core.debugger import set_trace

Adicione set_trace()onde você precisa de um ponto de interrupção. Digite helppara ipdbcomandos quando o campo de entrada aparecer.

Sua função de retorno está na linha de função def (função principal), você deve fornecer uma guia para ela. E use

%%debug 

ao invés de

%debug 

para depurar a célula inteira, não apenas a linha. Espero que talvez isso ajude você.

Você sempre pode adicionar isso em qualquer célula:

import pdb; pdb.set_trace()

e o depurador irá parar nessa linha. Por exemplo:

In[1]: def fun1(a):
           def fun2(a):
               import pdb; pdb.set_trace() # debugging starts here
           return fun2(a)

In[2]: fun1(1)

No Python 3.7, você pode usar a função breakpoint () . Basta entrar

breakpoint()

onde quer que você queira que o tempo de execução pare e a partir daí, você pode usar os mesmos comandos pdb (r, c, n, ...) ou avaliar suas variáveis.

Basta digitar import pdbno caderno jupyter, e depois usar este cheatsheet para depurar. É muito conveniente.

c-> continue, s-> passo, b 12-> defina o ponto de interrupção na linha 12 e assim por diante.

Alguns links úteis: Documento oficial do Python sobre pdb , exemplos de depurador do Python pdb para entender melhor como usar os comandos do depurador .

Algumas capturas de tela úteis:

Depois de receber um erro, na próxima célula, execute %debuge é isso.

O %pdbcomando mágico também é bom de usar. Basta dizer %pdb one, posteriormente, o pdbdepurador será executado em todas as exceções, independentemente da profundidade da pilha de chamadas. Muito conveniente.

Se você tem uma linha específica que deseja depurar, apenas crie uma exceção (geralmente você já está!) Ou use o %debugcomando mágico que outras pessoas têm sugerido.

Acabei de descobrir o PixieDebugger . Mesmo pensando que ainda não tive tempo para testá-lo, realmente parece a maneira mais semelhante de depurar a maneira como usamos o ipython com o ipdb

Ele também tem uma guia "avaliar"

Um depurador nativo está sendo disponibilizado como uma extensão para o JupyterLab. Lançado há algumas semanas, isso pode ser instalado com a extensão relevante, assim como o kernel xeus-python (que vem notavelmente sem as mágicas conhecidas pelos usuários do ipykernel):

jupyter labextension install @jupyterlab/debugger
conda install xeus-python -c conda-forge

Isso permite uma experiência de depuração visual bem conhecida de outros IDEs.

Fonte: Um depurador visual para Jupyter