ipython, the interactive python upgrade
The python-specific part of jupyter, which can also run without jupyter. Long story.
The main thing I forget here is
Pretty display of objects
ipython display protocol
Check out the Rich display protocol which allows you to render objects as arbitrary graphics.
How to use this? The
display api docs
explain that you should basically implement methods such as
I made a thing called latex_fragment which leverages this to display arbitrary latex inline. This is how you do it.
def _figure_data(self, format): fig, ax = plt.subplots() ax.plot(self.data, 'o') ax.set_title(self._repr_latex_()) data = print_figure(fig, format) # We MUST close the figure, otherwise IPython's display machinery # will pick it up and send it as output, resulting in a double display plt.close(fig) return data # Here we define the special repr methods that provide the IPython display protocol # Note that for the two figures, we cache the figure data once computed. def _repr_png_(self): if self._png_data is None: self._png_data = self._figure_data('png') return self._png_data
For a non-graphical non-fancy terminal, you probably simply want nice formatting of dictionaries etc:
from pprint import pprint, pformat pprint(obj) # display it print(pformat(obj)) # get a nicely formatted representation
Wait, you want to write your own pretty-printer, with correct indentation? Use tiles.
Reloading edited code
Sometimes it's complicated to work out how to load some complicated dependency tree of stuff. There is an autoreload extension which in principle reloads everything that has changed.
%load_ext autoreload %autoreload 2
If you don't trust it do it manually.
You can even hack traditional
reload to be deep.
import builtins from IPython.lib import deepreload builtins.reload = deepreload.reload
That didn't work reliably for me. If you load them both at the same time, stuff gets weird. Don't do that.
Also, this is incompatible with
snakeviz. Errors ensue.
how to start the basic interactive debugger
Let's say there is a line in your code that fails:
In vanilla python if you want to debug the last exception (the post-mortem debugger) you do:
import pdb; pdb.pm()
and if you want to drop into a debugger from some bit of code, you write:
import pdb; pdb.set_trace()
or in python 3.7+
and if you want to use a fancier debugger (
ipdb is recommended):
import ipdb; ipdb.set_trace()
import ipdb; ipdb.pm()
This doesn't work in jupyter/ipython, which has some other fancy interaction loop going on.
Here's the manual way to drop into the debugger from code, according to noticed by Christoph Martin and David Hamann:
from IPython.core.debugger import Tracer; Tracer()() # < 5.1 from IPython.core.debugger import set_trace; set_trace() # >= v5.1
However, that's not how you are supposed to do it. Persons of quality supposedly invoke their debuggers via so-called magics, e.g. the %debug magic to set a breakpoint.
%debug [--breakpoint filename:line_number_for_breakpoint]
Without the argument it activates post-mortem mode.
Pish posh, who thinks in line-numbers?
set_trace wastes less time for humans per default.
And if you want to drop automatically into the post mortem debugger for every error:
%pdb on 1/0
Props to Josh Devlin for explaining this and some other handy tips, and Gaël Varoquaux.
Gaël recommended some extra debuggers:
- There are many other debuggers.
- That's too many debuggers
- Realistically I won't use any of them, because the inbuilt one is OK.
Useful debugger commands
Execute the (one-line) statement in the context of the current stack frame, even if it mirrors the name of a debugger command This is the most useful command, because the debugger parser is horrible and will always interpret anything it conceivably can as a debugger command instead of a python command, which is confusing and misleading. So preface everything with
!to be safe.
Print your location in current stack
Move the current frame count (default one) levels down/ in the stack trace (to a newer frame).
b(reak) [([filename:]lineno | function) [, condition]]
The one that is tedious to do manually. Without argument, list all breaks and their metadata.
tbreak [([filename:]lineno | function) [, condition]]
Temporary breakpoint, which is removed automatically when it is first hit.
cl(ear) [filename:lineno | bpnumber [bpnumber …]]
Clear specific or all breakpoints
disable [bpnumber [bpnumber …]]/
enable [bpnumber [bpnumber …]]
disableis the same as
clear, but you can re-
ignore bpnumber [count]
ignore a breakpoint a specified number of times
condition bpnumber [condition]
Set a new condition for the breakpoint
Specify a list of commands for breakpoint number
bpnumber. The commands themselves appear on the following lines. Type
endto terminate the command list.
Execute the next line, even if that is inside an invoked function.
Execute the next line in this function.
continue to line
lineno, or the next line with a highetr number than the current one
Continue execution until the current function returns.
Continue execution, only stop when a breakpoint is encountered.
Set the next line that will be executed. Only available in the bottom-most frame. It is not possible to jump into weird places like the middle of a for loop.
l(ist) [first[, last]]
List source code for the current file.
ll | longlist
List all source code for the current function or frame.
Print the argument list of the current function.
Evaluate the expression in the current context and print its value.
Like the p command, except the value of the expression is pretty-printed using the pprint module.
Print the type of the expression.
Try to get source code for the given object and display it.
Display the value of the expression if it changed, each time execution stops in the current frame.
Start an interactive interpreter (using the code module) whose global namespace contains all the (global and local) names found in the current scope.
alias [name [command]]/
Create an alias called name that executes command.
Pack up and go home
alias one needs another look, right? How even does it…
As an example, here are two useful aliases from the manual,
# Print instance variables (usage `pi classInst`) alias pi for k in %1.__dict__.keys(): print("%1.",k,"=",%1.__dict__[k]) # Print instance variables in self alias ps pi self
Python 3 has tracemalloc built in. this is a powerful python memory analyser, although bare-bones. Mike Lin walks you though it. Benoit Bernard explains various options that run on older pythons, including, most usefully IMO, obgraph which draws you an actual diagram of where the leaking things are. More full features, Pympler provide GUI-backed memory profiling, including the magically handy thing of tracking referrers using its refbrowser.
pyrasite injects code into running python processes, which enables more exotic debuggery, and realtime object mutation and stuff and of course, memory and performance profiling.
Maybe it's not crashing, but taking too long? You want a profiler.
Easy mode: built-in profiler
Profile functions using cProfile:
import cProfile as profile profile.runctx('print(predded.shape)', globals(), locals())
There are also memory allocation tools, although I've not used them and suspect they are no longer current.
Now visualise them using… uh… let me come back to that.
[…] lets you visualize what your Python program is spending time on without restarting the program or modifying the code in any way. Py-Spy is extremely low overhead: it is written in Rust for speed and doesn't run in the same process as the profiled Python program, nor does it interrupt the running program in any way. This means Py-Spy is safe to use against production Python code.[…]
This project aims to let you profile and debug any running Python program, even if the program is serving production traffic.[…]
Py-spy works by directly reading the memory of the python program using the
process_vm_readvsystem call on Linux, the
vm_readcall on OSX or the
ReadProcessMemorycall on Windows.
Figuring out the call stack of the Python program is done by looking at the global PyInterpreterState variable to get all the Python threads running in the interpreter, and then iterating over each PyFrameObject in each thread to get the call stack.
Native ipython can run profiler magically:
%%prun -D somefile.prof files = glob.glob('*.txt') for file in files: with open(file) as f: print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
snakeviz includes a handy magic to automatically save stats and launch the profiler. (Gotcha: you have to have the snakeviz cli already on the path when you launch ipython.)
%load_ext snakeviz %%snakeviz files = glob.glob('*.txt') for file in files: with open(file) as f: print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
This is incompatible with
autoreload and gives weird errors if
you run them both in the same session.
runsnakerun – the original, now expired.
snakeviz is a browser-based version that might be ok.
py-spy includes built-in flame graphs because it can't stop being fancy no matter how it tries
Too many bike sheds.
There are a lot of frameworks. The most common seem to be unittest, py.test and nose.
Jacon Kaplan-Moss likes pytest and he's good let's copy him. FWIW I'm no fan of nose; my experience of it was that I spent a lot of time debugging weird failures getting lost in its attempts to automagically help me. This might be because I didn't deeply understand what I was doing, but the other frameworks didn't require me to understand so deeply the complexities of their attempts to simplify my life.