IPython provides tools for interactive and parallel computing that are widely used in scientific computing, but can benefit any Python developer.
We will show how to use IPython in different ways, as: an interactive shell, an embedded shell, a graphical console, a network-aware VM in GUIs, a web-based notebook with code, graphics and rich HTML, and a high-level framework for parallel computing.
All materials for this tutorial can be found on our github repository
IPython started in 2001 simply as a better interactive Python shell. Over the last decade it has grown into a powerful set of interlocking tools that maximize developer productivity in Python while working interactively.
Today, IPython consists of a kernel that executes the user code and provides many features for introspection and namespace manipulation, and tools to control this kernel either in-process or out-of-process thanks to a well-specified communications protocol implemented over ZeroMQ. This architecture allows the core features to be accessed via a variety of clients, each providing unique functionality tuned to a specific use case:
An interactive, terminal-based shell with capabilities beyond the default Python interactive interpreter (this is the classic application opened by the
ipython command that most users are familiar with).
A Qt console that provides the look and feel of a terminal, but adds support for inline figures, graphical calltips, a persistent session that can survive crashes of the kernel process, and more. A user-based review of some of these features can be found here.
A web-based notebook that can execute code and also contain rich text and figures, mathematical equations and arbitrary HTML. This notebook presents a document-like view with cells where code is executed but that can be edited in-place, reordered, mixed with explanatory text and figures, etc. The notebook provides an interactive experience that combines live code and results with literate documentation and the rich media that modern browsers can display:
In this hands-on, in-depth tutorial, we will briefly describe IPython's architecture and will then show how to use the above tools for a highly productive workflow in Python.
An outline of the tutorial follows:
Core IPython: interactive use at the terminal and Qt console
- IPython basics: the magic command system, shell aliases, full shell access, the history system, variable caching, object introspection tools.
- Development workflow: combining the interpreter session with python files via the
- Effective use of IPython at the command-line for typical development tasks: timing, profiling, debugging.
Parallelism with IPython - basic architecture: the concept of an "interactive IPython cluster" - direct execution of code across engines in a cluster - dynamic load-balancing of tasks - IPython engines in the cloud (illustrated with Amazon EC2 instances).
At the end of this tutorial, attendees will have an understanding of the overall design of IPython not only as a (better) python shell, but as a suite of applications they can use and combine in multiple ways in the course of their development work with Python. They will learn:
For full details about IPython including documentation, previous presentations and videos of talks, please see the project website.
Update: See updated tutorial preparation instructions at IPython in-depth: high-productivity interactive and parallel python