第 1 章 IPython：超越Python
Python 有很多开发环境可供选择，我也常常被问起在工作中使用哪一种开发环境。我的答案有时会让人惊讶：我偏爱的开发环境是 IPython（http://ipython.org/）加上一个文本编辑器（Emacs 或 Atom，具体视心情而定）。IPython（interactive Python 的简称，即交互式 Python）由 Fernando Perez 作为一个增强的 Python 解释器于 2001 年启动，并由此发展为一个项目。用 Perez 的原话来说，该项目致力于提供“科学计算的全生命周期开发工具”。如果将 Python 看作数据科学任务的引擎，那么 IPython 就是一个交互式控制面板。
除了作为 Python 的一个交互式接口，IPython 还提供了一些有用的 Python 语法附加功能，本书就将介绍其中最有用的一些。另外，IPython 被紧密地连接在 Jupyter 项目（http://jupyter.org）中。该项目提供一个基于浏览器的 Notebook，它可以开发、协作、分享甚至发布数据科学结果。IPython Notebook 其实只是通用 Jupyter Notebook 结构的特例，而 Jupyter Notebook 不仅支持 Python，还包括用于 Julia、R 和其他编程语言的 Notebook。 Jupyter Notebook 的格式与你此刻正在阅读的页面看起来其实没什么两样——本书的全部稿件就是用一组 IPython Notebook 写成的。
IPython 就是用 Python 进行有效的交互式科学计算和数据密集型计算。本章首先介绍 IPython 对数据科学非常有用的功能，尤其关注它在语法上超越了 Python 的特性。接下来将深入介绍一些更有用的“魔法命令”，这些命令可以为与创建和使用数据科学代码相关的常规任务提高速度。最后将介绍 IPython Notebook 的一些特性，这些特性对于理解数据和分享结果非常有用。
1.1 shell还是Notebook
本章将介绍两种使用 IPython 的方式：IPython shell 和 IPython Notebook。本章大部分内容与两种方式都有关，并且示例会根据方便程度在两者中切换。在少数情况下仅会介绍一种工具，届时我会清楚地说明。在开始之前，先简单介绍一下如何启动 IPython shell 和 IPython Notebook。
1.1.1 启动IPython shell
这一章和本书大部分内容一样，光靠眼睛看是学不会的。建议你通读一遍，并且用我们介绍的工具和语法动手实践一遍，毕竟通过实践形成的肌肉记忆远比简单阅读一遍持久得多。你可以在命令行中输入 ipython 启动 IPython 解释器。如果你安装了 Anaconda 或 EPD 的 Python 发行版，系统中将会有一个特别的启动器（详情请参见 1.2 节）。
当你完成以上步骤后，将看到如下的提示：
IPython 4.0.1 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.
In [1]:
这时就可以进行接下来的步骤了。
1.1.2 启动Jupyter Notebook
Jupyter Notebook 是 IPython shell 基于浏览器的图形界面，提供了一系列丰富的动态展示功能。Jupyter Notebook 不仅可以执行 Python/IPython 语句，还允许用户添加格式化文本、静态和动态的可视化图像、数学公式、JavaScript 插件，等等。不仅如此，这些 Notebook 文档还能以共享方式存储，以便其他人可以打开这些 Notebook，并且在他们自己的系统中执行这些 Notebook 代码。
尽管 IPython Notebook 是通过你的 Web 浏览器窗口进行查看和编辑的，但是它必须与一个正在运行的 Python 进程连接才能执行代码。想要启动这个进程（也被称作“核”，kernel），需要在你系统的命令行中输入以下命令：
$ jupyter notebook
这个命令会启动一个本地的 Web 服务器，可以在你的浏览器中看到页面内容。同时，它会立刻生成日志，显示它正在做什么。这个日志大概如下所示：
$ jupyter notebook
[NotebookApp] Serving notebooks from local directory: /Users/jakevdp/...
[NotebookApp] 0 active kernels
[NotebookApp] The IPython Notebook is running at: http://localhost:8888/
[NotebookApp] Use Control-C to stop this server and shut down all kernels...
一旦以上命令执行，你的默认浏览器将会自动打开，并且自动导航到 localhost 网址（实际地址会依据你的系统而定）。如果浏览器没有自动打开，你可以自己打开一个窗口，并且手动打开这个网址（在这个示例中是 http://localhost:8888）。
1.2 IPython的帮助和文档
如果你没有阅读本章的其他节，那么请一定阅读本节。我觉得本节中讨论的工具对我的日常工作流程的贡献是最大的。
当一个技术型思维的人要帮助他的朋友、家人或同事解决计算机方面的问题时，大多数时候，重要的不是知道答案，而是知道如何快速找到答案。在数据科学领域也一样，通过搜索在线文档、邮件列表、Stack Overflow 等网络资源都可以获得丰富的信息，即使（尤其是）你曾经搜索过这个主题。要想成为一名高效的数据科学实践者，重要的不是记住针对每个场景应该使用的工具或命令，而是学习如何有效地找到未知信息，无论是通过搜索引擎还是其他方式。
IPython 和 Jupyter 最大的用处之一就是能缩短用户与帮助文档和搜索间的距离，帮助用户高效完成工作。虽然网络搜索在解答复杂问题时非常有用，但是仅仅使用 IPython 就能找到大量的信息了。以下是仅通过几次按键，IPython 就可以帮你解答的一些问题。
- 我如何调用这个函数？这个函数有哪些参数和选项？
- 这个 Python 对象的源代码是怎样的？
- 我导入的包中有什么？这个对象有哪些属性和方法？
接下来将介绍如何通过 IPython 工具来快速获取这些信息。符号 ? 用于浏览文档，符号 ?? 用于浏览源代码，而 Tab 键可以用于自动补全。
1.2.1 用符号?获取文档
Python 语言和其数据科学生态系统是应用户需求而创建的，而用户的很大一部分需求就是获取文档。每一个 Python 对象都有一个字符串的引用，该字符串即 docstring。大多数情况下，该字符串包含对象的简要介绍和使用方法。Python 内置的 help() 函数可以获取这些信息，并且能打印输出结果。例如，如果要查看内置的 len 函数的文档，可以按照以下步骤操作：
In [1]: help(len)
Help on built-in function len in module builtins:
len(...)
len(object) -> integer
Return the number of items of a sequence or mapping.
根据不同的解释器，这条信息可能会展示为内嵌文本，或者出现在单独的弹出窗口中。
获取关于一个对象的帮助非常常见，也非常有用，所以 IPython 引入了 ? 符号作为获取这个文档和其他相关信息的缩写：
In [2]: len?
Type: builtin_function_or_method
String form: <built-in function len>
Namespace: Python builtin
Docstring:
len(object) -> integer
Return the number of items of a sequence or mapping.
这种表示方式几乎适用于一切，包括对象方法：
In [3]: L = [1, 2, 3]
In [4]: L.insert?
Type: builtin_function_or_method
String form: <built-in method insert of list object at 0x1024b8ea8>
Docstring: L.insert(index, object) -- insert object before index
甚至对于对象本身以及相关类型的文档也适用：
In [5]: L?
Type: list
String form: [1, 2, 3]
Length: 3
Docstring:
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
重要的是，这种方法也适用于你自己创建的函数或者其他对象！下面定义一个带有 docstring 的小函数：
In [6]: def square(a):
....: """Return the square of a."""
....: return a ** 2
....:
请注意，为了给函数创建一个 docstring，仅仅在第一行放置了一个字符串字面量。由于 docstring 通常是多行的，因此按照惯例，用 Python 的三个引号表示多行字符串。
接下来用 ? 符号来找到这个 docstring：
In [7]: square?
Type: function
String form: <function square at 0x103713cb0>
Definition: square(a)
Docstring: Return the square of a.
你应该养成在你写的代码中添加这样的内嵌文档的习惯，这样就可以通过 docstring 快速获取文档。
1.2.2 通过符号??获取源代码
由于 Python 非常易读，所以你可以通过阅读你感兴趣的对象的源代码得到更高层次的理解。IPython 提供了获取源代码的快捷方式（使用两个问号 ??）：
In [8]: square??
Type: function
String form: <function square at 0x103713cb0>
Definition: square(a)
Source:
def square(a):
"Return the square of a"
return a ** 2
对于这样的简单函数，两个问号就可以帮助你深入理解隐含在表面之下的实现细节。
如果你经常使用 ?? 后缀，就会发现它有时不能显示源代码。这是因为你查询的对象并不是用 Python 实现的，而是用 C 语言或其他编译扩展语言实现的。在这种情况下，?? 后缀将等同于 ? 后缀。你将会在很多 Python 内置对象和类型中发现这样的情况，例如上面示例中提到的 len 函数：
In [9]: len??
Type: builtin_function_or_method
String form: <built-in function len>
Namespace: Python builtin
Docstring:
len(object) -> integer
Return the number of items of a sequence or mapping.
? 和 ?? 提供了一个强大又快速的接口，可以查找任何 Python 函数或模块的用途信息。
1.2.3 用Tab补全的方式探索模块
IPython 另一个有用的接口是用 Tab 键自动补全和探索对象、模块及命名空间的内容。在接下来的示例中，我们将用 <TAB> 来表示 Tab 键。
对象内容的Tab自动补全
每一个 Python 对象都包含各种属性和方法。和此前讨论的
help函数类似，Python 有一个内置的dir函数，可以返回一个属性和方法的列表。但是 Tab 自动补全接口在实际的应用过程中更简便。要想看到对象所有可用属性的列表，可以输入这个对象的名称，再加上一个句点（.）和 Tab 键：In [10]: L.<TAB> L.append L.copy L.extend L.insert L.remove L.sort L.clear L.count L.index L.pop L.reverse为了进一步缩小整个列表，可以输入属性或方法名称的第一个或前几个字符，然后 Tab 键将会查找匹配的属性或方法：
In [10]: L.c<TAB> L.clear L.copy L.count In [10]: L.co<TAB> L.copy L.count如果只有一个选项，按下 Tab 键将会把名称自动补全。例如，下面示例中的内容将会马上被
L.count替换：In [10]: L.cou<TAB>尽管 Python 没有严格区分公共 / 外部属性和私有 / 内部属性，但是按照惯例，前面带有下划线表示私有属性或方法。为了清楚起见，这个列表中默认省略了这些私有方法和特殊方法。不过，你可以通过明确地输入一条下划线来把这些私有的属性或方法列出来：
In [10]: L._<TAB> L.__add__ L.__gt__ L.__reduce__ L.__class__ L.__hash__ L.__reduce_ex__为了简洁起见，这里只展示了输出的前两行，大部分是 Python 特殊的双下划线方法（昵称叫作“dunder 方法”）。
导入时的Tab自动补全
Tab 自动补全在从包中导入对象时也非常有用。下面用这种方法来查找
itertools包中以co开头的所有可导入的对象：In [10]: from itertools import co<TAB> combinations compress combinations_with_replacement count同样，你也可以用 Tab 自动补全来查看你系统中所有可导入的包（这将因你的 Python 会话中有哪些第三方脚本和模块可见而不同）：
In [10]: import <TAB> Display all 399 possibilities? (y or n) Crypto dis py_compile Cython distutils pyclbr ... ... ... difflib pwd zmq In [10]: import h<TAB> hashlib hmac http heapq html husl（为了简洁起见，并没有打印我的系统中所有可导入的 399 个包和模块。）
超越Tab自动补全：通配符匹配
当你知道所寻找的对象或属性的第一个或者前几个字符时，Tab 自动补全将非常有用。但是当你想匹配中间或者末尾的几个字符时，它就束手无策了。对于这样的场景，IPython 提供了用
*符号来实现的通配符匹配方法。例如，可以用它列举出命名空间中以
Warning结尾的所有对象：In [10]: *Warning? BytesWarning RuntimeWarning DeprecationWarning SyntaxWarning FutureWarning UnicodeWarning ImportWarning UserWarning PendingDeprecationWarning Warning ResourceWarning请注意，这里的
*符号匹配任意字符串，包括空字符串。同理，假设我们在寻找一个字符串方法，它的名称中包含
find，则可以这样做：In [10]: str.*find*? str.find str.rfind在实际应用过程中，我发现，当我接触一个新的包或者是重新认识一个已经熟悉的包时，这种灵活的通配符查找方法对于找到其中一个特定的命令非常有用。
1.3 IPython shell中的快捷键
如果你常用计算机，你可能在工作流程中使用过快捷键。最熟悉的可能是 Cmd + C 和 Cmd + V（或者是 Ctrl + C 和 Ctrl + V），它们在很多程序和系统中用于复制和粘贴。高级用户会将快捷键用得更加深入和广泛，流行的文本编辑器（如 Emacs、Vim 等）通过复杂的按键组合为用户提供了很多快捷操作。
IPython 并没有上述编辑器那么强大，但是它也提供了一些快捷方式，能帮你在录入命令的时候快速导航。但事实上，这些快捷方式并不是 IPython 本身提供的，而是通过 IPython 对 GNU Readline 库的依赖关系实现的。因此，接下来介绍的一些快捷方式可能会因你系统配置的不同而不同。此外，一些快捷方式也可以在基于浏览器的 Notebook 中起作用，但是本节将主要讨论 IPython shell 中的快捷方式。
一旦你用惯了这些快捷方式，就能快速执行一些命令，而不用将手从“home”键上移开。如果你是一名 Emacs 用户，或者有 Linux shell 的使用经验，你会对接下来的内容非常熟悉。我们会将这些快捷键分为几类：导航快捷键、文本输入快捷键、命令历史快捷键和其他快捷键。
1.3.1 导航快捷键
利用左箭头和右箭头在一行中向前或向后移动是非常常见的，不过还有其他一些选项也可以让你不用把手从“home”键上挪开。
快捷键 |
动作 |
|---|---|
Ctrl + a |
将光标移到本行的开始处 |
Ctrl + e |
将光标移到本行的结尾处 |
Ctrl + b（或左箭头键） |
将光标回退一个字符 |
Ctrl + f（或右箭头键） |
将光标前进一个字符 |
1.3.2 文本输入快捷键
每个人都知道用 Backspace 键可以删除前一个字符，但手指要移动一定的距离才能够到这个按键，并且它一次只能删除一个字符。IPython 中有一些可以删除你输入的部分文本的快捷键，其中立马能派上用场的就是删除整行文本的快捷键。一旦你开始用 Ctrl + b 和 Ctrl + d 组合，而不是用 Backspace 按键删除前一个字符，就再也离不开这些快捷键了。
快捷键 |
动作 |
|---|---|
Backspace 键 |
删除前一个字符 |
Ctrl + d |
删除后一个字符 |
Ctrl + k |
从光标开始剪切至行的末尾 |
Ctrl + u |
从行的开头剪切至光标 |
Ctrl + y |
yank（即粘贴）之前剪切的文本 |
Ctrl + t |
transpose（即交换）前两个字符 |
1.3.3 命令历史快捷键
可能本书讨论的最有效的快捷方式是 IPython 提供的导航命令历史的快捷方式。这个命令历史超越了你当前的 IPython 会话——你所有的命令历史都会存储在一个 IPython 配置文件路径下的 SQLite 数据库中。获取这些命令最直接的方式就是用上下箭头遍历历史，但是仍然还有些别的选项。
快捷键 |
动作 |
|---|---|
Ctrl + p（或向上箭头） |
获取前一个历史命令 |
Ctrl + n（或向下箭头） |
获取后一个历史命令 |
Ctrl + r |
对历史命令的反向搜索 |
反向搜索特别有用。在前一节中，我们定义了一个叫作 square 的函数。让我们从一个新的 IPython shell 中反向搜索 Python 历史，重新找到这个函数的定义。当你在 IPython 终端按下 Ctrl + r 键时，将看到如下提示：
In [1]:
(reverse-i-search)`':
如果你在该提示后开始输入字符，IPython 将自动填充时间最近的命令。如果有的话，将会匹配到如下字符：
In [1]:
(reverse-i-search)`sqa': square??
你可以随时添加更多的字符来重新定义搜索，或者再一次按下 Ctrl + r 键来寻找另外一个匹配该查询的命令。如果你在前一节中照做了的话，按下 Ctrl + r 键两次将可以看到：
In [1]:
(reverse-i-search)`sqa': def square(a):
"""Return the square of a"""
return a ** 2
找到你在寻找的命令后，按下 Return 键将会终止查找。然后就可以利用查找到的命令，继续我们的会话：
In [1]: def square(a):
"""Return the square of a"""
return a ** 2
In [2]: square(2)
Out[2]: 4
请注意，你也可以用 Ctrl + p / Ctrl + n 或者上下方向键查找历史，但是仅仅是匹配每行的前几个字符。也就是说，如果你输入 def 然后按下 Ctrl + p，则会在你的命令历史中找到以 def 开头的最近的命令（如果有的话）。
1.3.4 其他快捷键
还有一些不能归纳在之前几个类别中的快捷键，但是它们也非常有用。
快捷键 |
动作 |
|---|---|
Ctrl + l |
清除终端屏幕的内容 |
Ctrl + c |
中断当前的 Python 命令 |
Ctrl + d |
退出 IPython 会话 |
如果你无意间开启了一个运行时间非常长的程序，Ctrl + c 快捷键就能派上大用场。
这里讨论的一些快捷键可能乍看上去有些麻烦，但是经过实践你很快就会习惯它们。一旦你形成了这种肌肉记忆，甚至会希望将这些快捷方式应用到其他场景中。
1.4 IPython魔法命令
前两节介绍了 IPython 如何让你以更有效且可交互的方式使用和探索 Python。本节将介绍一些 IPython 在普通 Python 语法基础之上的增强功能。这些功能被称作 IPython 魔法命令，并且都以 % 符号作为前缀。这些魔法命令设计用于简洁地解决标准数据分析中的各种常见问题。魔法命令有两种形式：行魔法（line magic）和单元魔法（cell magic）。行魔法以单个 % 字符作为前缀，作用于单行输入；单元魔法以两个 %% 作为前缀，作用于多行输入。下面将展示和讨论一些简单的例子，本章后面会更详细地讨论一些有用的魔法命令。
1.4.1 粘贴代码块：%paste和%cpaste
当你使用 IPython 解释器时，有件事经常让你头疼，那就是粘贴多行代码块可能会导致不可预料的错误，尤其是其中包含缩进和解释符号时。一个常见的情况是，你在一个网站中找到了一些示例代码，并想将它们粘贴到你的解释器中，例如下面这个简单函数：
>>> def donothing(x):
... return x
虽然这些代码和 Python 解释器中的显示是一样的，但是如果你将它直接复制并粘贴到 IPython 中，就会出现错误：
In [2]: >>> def donothing(x):
...: ... return x
...:
File "<ipython-input-20-5a66c8964687>", line 2
... return x
^
SyntaxError: invalid syntax
在直接粘贴的过程中，解释器被额外的提示符号搞晕了。但是不要害怕，IPython 的 %paste 魔法函数可以解决这个包含符号的多行输入问题：
In [3]: %paste
>>> def donothing(x):
... return x
## -- End pasted text --
%paste 命令同时输入并执行该代码，所以你可以看到这个函数现在被应用了：
In [4]: donothing(10)
Out[4]: 10
另外一个作用类似的命令是 %cpaste。该命令打开一个交互式多行输入提示，你可以在这个提示下粘贴并执行一个或多个代码块：
In [5]: %cpaste
Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
:>>> def donothing(x):
:... return x
:--
这些命令和我们将会看到的其他魔法命令一样，实现了在标准的 Python 解释器中很难或是不可能实现的功能。
1.4.2 执行外部代码：%run
当你开发更复杂的代码时，可能会发现自己在使用 IPython 进行交互式探索的同时，还需要使用文本编辑器存储你希望重用的代码。在 IPython 会话中运行之前的代码非常方便，不用在另一个新窗口中运行这些程序代码。这个功能可以通过 %run 魔法命令来实现。
假设你创建了一个 myscript.py 文件，该文件包含以下内容：
#-------------------------------------
# file: myscript.py
def square(x):
"""求平方"""
return x ** 2
for N in range(1, 4):
print(N, "squared is", square(N))
你可以在像下面这样在 IPython 会话中运行该程序：
In [6]: %run myscript.py
1 squared is 1
2 squared is 4
3 squared is 9
请注意，当你运行了这段代码之后，该代码中包含的所有函数都可以在 IPython 会话中使用：
In [7]: square(5)
Out[7]: 25
IPython 提供了几种方式来调整代码如何执行。你可以在 IPython 解释器中输入 %run? 查看帮助文档。
1.4.3 计算代码运行时间：%timeit
另一个非常有用的魔法函数是 %timeit，它会自动计算接下来一行的 Python 语句的执行时间。例如，我们可能想了解列表综合的性能：
In [8]: %timeit L = [n ** 2 for n in range(1000)]
1000 loops, best of 3: 325 μs per loop
%timeit 的好处是，它会自动多次执行简短的命令，以获得更稳定的结果。对于多行语句，可以加入第二个 % 符号将其转变成单元魔法，以处理多行输入。例如，下面是 for 循环的同等结构：
In [9]: %%timeit
...: L = []
...: for n in range(1000):
...: L.append(n ** 2)
...:
1000 loops, best of 3: 373 μs per loop
从以上结果可以立刻看出，列表综合比同等的 for 循环结构快约 10%。我们将在 1.9 节中进一步探索 %timeit 和其他对代码进行计时和分析的方法。
1.4.4 魔法函数的帮助：?、%magic和%lsmagic
和普通的 Python 函数一样，IPython 魔法函数也有文档字符串，并且可以通过标准的方式获取这些有用的文档注释。例如，为了读到 %timeit 魔法函数的文档注释，可以简单地输入以下命令：
In [10]: %timeit?
其他函数的文档注释也可以通过类似方法获得。为了获得可用魔法函数的通用描述以及一些示例，可以输入以下命令：
In [11]: %magic
为了快速而简单地获得所有可用魔法函数的列表，可以输入以下命令：
In [12]: %lsmagic
最后我还想提醒你，更直接的方式是按照你的意愿定义你自己的魔法函数。这里不会具体介绍，但是如果你感兴趣，可以参考 1.10 节列出的参考资料。
1.5 输入和输出历史
我们在前面看到，IPython shell 允许用上下方向键或 Ctrl + p / Ctrl + n 快捷键获取历史命令。另外，IPython 在 shell 和 Notebook 中都提供了几种获取历史命令的输出方式，以及这些命令本身的字符串形式。本节将会具体介绍。
1.5.1 IPython的输入和输出对象
到目前为止，我想你应该特别熟悉 IPython 用到的 In[1]:/Out[1]: 形式的提示了。但实际上，它们并不仅仅是好看的装饰形式，还给出了在当前会话中如何获取输入和输出历史的线索。假设你用以下形式启动了一个会话：
In [1]: import math
In [2]: math.sin(2)
Out[2]: 0.9092974268256817
In [3]: math.cos(2)
Out[3]: -0.4161468365471424
我们导入了一个内置的 math 程序包，然后计算 2 的正弦函数值和余弦函数值。这些输入和输出在 shell 中带有 In/Out 标签，但是不仅如此——IPython 实际上创建了叫作 In 和 Out 的 Python 变量，这些变量自动更新以反映命令历史：
In [4]: print(In)
['', 'import math', 'math.sin(2)', 'math.cos(2)', 'print(In)']
In [5]: Out
Out[5]: {2: 0.9092974268256817, 3: -0.4161468365471424}
In 对象是一个列表，按照顺序记录所有的命令（列表中的第一项是一个占位符，以便 In[1] 可以表示第一条命令）：
In [6]: print(In[1])
import math
Out 对象不是一个列表，而是一个字典。它将输入数字映射到相应的输出（如果有的话）：
In [7]: print(Out[2])
0.9092974268256817
请注意，不是所有操作都有输出，例如 import 语句和 print 语句就不影响输出。对于后者你可能会感到有点意外，但是仔细想想，print 是一个函数，它的返回值是 None，这样就能说通了。总的来说，任何返回值是 None 的命令都不会加到 Out 变量中。
如果想利用之前的结果，理解以上内容将大有用处。例如，利用之前的计算结果检查 sin(2) ** 2 和 cos(2) ** 2 的和，结果如下：
In [8]: Out[2] ** 2 + Out[3] ** 2
Out[8]: 1.0
输出结果是 1.0，符合勾股定理。在这个例子中，可能不需要利用之前的结果，但是如果你执行一个非常复杂的计算并且希望重复利用运算结果，那么该方法就会非常有用。
1.5.2 下划线快捷键和以前的输出
标准的 Python shell 仅仅包括一个用于获取以前的输出的简单快捷键。变量 _（单下划线）用于更新以前的输出，而这种方式在 IPython 中也适用：
In [9]: print(_)
1.0
但是 IPython 更进了一步——你可以用两条下划线获得倒数第二个历史输出，用三条下划线获得倒数第三个历史输出（跳过任何没有输出的命令）：
In [10]: print(__)
-0.4161468365471424
In [11]: print(___)
0.9092974268256817
IPython 的这一功能就此停止：超过三条下划线开始变得比较难计数，并且在这种情况下通过行号来指定输出更方便。
这里还要提到另外一个快捷键——Out[X] 的简写形式是 _X（即一条下划线加行号）：
In [12]: Out[2]
Out[12]: 0.9092974268256817
In [13]: _2
Out[13]: 0.9092974268256817
1.5.3 禁止输出
有时你可能希望禁止一条语句的输出（在第 4 章将介绍的画图命令中最常见）。或者你执行的命令生成了一个你并不希望存储到输出历史中的结果，这样当其他引用被删除时，该空间可以被释放。要禁止一个命令的输出，最简单的方式就是在行末尾处添加一个分号：
In [14]: math.sin(2) + math.cos(2);
请注意，这个结果被默默地计算了，并且输出结果既不会显示在屏幕上，也不会存储在 Out 路径下：
In [15]: 14 in Out
Out[15]: False
1.5.4 相关的魔法命令
如果想一次性获取此前所有的输入历史，%history 魔法命令会非常有用。在下面的示例中可以看到如何打印前 4 条输入命令：
In [16]: %history -n 1-4
1: import math
2: math.sin(2)
3: math.cos(2)
4: print(In)
按照惯例，可以输入 %history? 来查看更多相关信息以及可用选项的详细描述。其他类似的魔法命令还有 %rerun（该命令将重新执行部分历史命令）和 %save（该命令将部分历史命令保存到一个文件中）。如果想获取更多相关信息，建议你使用 ? 帮助功能（详情请参见 1.2 节）。
1.6 IPython和shell命令
当与标准 Python 解释器交互时，你将面临一个令人沮丧的场景——你需要在多个 Python 工具和系统命令行工具窗口间来回切换。而 IPython 可以跨越这个鸿沟，并且提供了在 IPython 终端直接执行 shell 命令的语法。这一神奇的功能是使用感叹号实现的：一行中任何在 ! 之后的内容将不会通过 Python 内核运行，而是通过系统命令行运行。
以下内容假定你在用一个类 Unix 系统，如 Linux 或者 Mac OS X。下文中的一些示例如果在 Windows 系统中运行将会失败，因为 Windows 系统默认使用的是与类 Unix 系统不同的 shell。（微软已于 2016 年宣布在 Windows 系统中可以运行原生的 Bash shell，所以在不久后这就不是个问题了！）如果不熟悉 shell 命令，建议你查看 Software Carpentry Foundation 的 shell 教程（http://swcarpentry.github.io/shell-novice/）。
1.6.1 shell快速入门
关于如何使用 shell / 终端 / 命令行的完整介绍不在本章的讨论范围内，但是我们为没有任何相关经验的初学者提供了一份快速入门指南。shell 是一种通过文本与计算机交互的方式。自 20 世纪 80 年代中期，微软和苹果发布其第一版（现在已经非常普遍）图形操作系统以来，大多数计算机用户已经熟悉了通过菜单点击和拖拽移动等方式与操作系统进行交互。但是，操作系统早在这些图形用户界面出现之前就存在，并且早期主要通过输入文本来控制：用户在提示符后输入一个命令，计算机将按照命令执行任务。这些早期的提示系统是 shell 和终端的前身，并且大多数活跃的数据科学家至今仍然用它们与计算机交互。
有些不熟悉 shell 的人可能会问，明明通过简单地点击图标和菜单就可以完成很多任务，为什么要把它复杂化？ shell 用户可能想用另一个问题来回答：明明在命令行简单地输入就能完成任务，为什么还要点击图标和菜单？这听起来可能像一个典型的技术偏好僵局，但显然，shell 对于高级任务能提供更多的控制操作。但是，我们也不得不承认 shell 的学习曲线会使很多普通计算机用户望而却步。
例如，以下是一个用户在 Linux / OS X 系统中探索、创建和修改文件和路径的 shell 会话的示例（osx：~ $ 是提示符，在 $ 符号后的所有内容是输入的命令；在 # 之后的文本是一个描述，并不是实际输入的内容）：
osx:~ $ echo "hello world" # echo类似于Python的打印函数
hello world
osx:~ $ pwd # pwd=打印工作路径
/home/jake # 这就是我们所在的路径
osx:~ $ ls # ls=列出当前路径的内容
notebooks projects
osx:~ $ cd projects/ # cd=改变路径
osx:projects $ pwd
/home/jake/projects
osx:projects $ ls
datasci_book mpld3 myproject.txt
osx:projects $ mkdir myproject # mkdir=创建新的路径
osx:projects $ cd myproject/
osx:myproject $ mv ../myproject.txt ./ # mv=移动文件。这里将
# 文件myproject.txt从上一级
# 路径(../)移动到当前路径(./)
osx:myproject $ ls
myproject.txt
请注意，以上示例仅仅是通过输入命令而不是通过点击图标和菜单来执行熟悉操作（对路径结构的导航、创建路径、移动文件等）的一种紧凑方式。在这个例子中，仅仅通过几个简单的命令（pwd、ls、cd、mkdir 和 cp）就可以完成大多数常见的文件操作。当你执行一些高级任务时，shell 方法将变得非常有用。
1.6.2 IPython中的shell命令
你可以通过将 ! 符号作为前缀在 IPython 中执行任何命令行命令。例如，ls、pwd 和 echo 命令可以按照以下方式运行：
In [1]: !ls
myproject.txt
In [2]: !pwd
/home/jake/projects/myproject
In [3]: !echo "printing from the shell"
printing from the shell
1.6.3 在shell中传入或传出值
shell 命令不仅可以从 IPython 中调用，还可以和 IPython 命名空间进行交互。例如，你可以通过一个赋值操纵符将任何 shell 命令的输出保存到一个 Python 列表：
In [4]: contents = !ls
In [5]: print(contents)
['myproject.txt']
In [6]: directory = !pwd
In [7]: print(directory)
['/Users/jakevdp/notebooks/tmp/myproject']
请注意，这些结果并不以列表的形式返回，而是以 IPython 中定义的一个特殊 shell 返回类型的形式返回：
In [8]: type(directory)
IPython.utils.text.SList
这看上去和 Python 列表很像，并且可以像列表一样操作。但是这种类型还有其他功能，例如 grep 和 fields 方法以及 s、n 和 p 属性，允许你轻松地搜索、过滤和显示结果。你可以用 IPython 内置的帮助来查看更多的详细信息。
另一个方向的交互，即将 Python 变量传入 shell，可以通过 {varname} 语法实现：
In [9]: message = "hello from Python"
In [10]: !echo {message}
hello from Python
变量名包含在大括号内，在 shell 命令中用实际的变量替代。
1.7 与shell相关的魔法命令
操作 IPython shell 一段时间后，你可能会注意到你不能通过 !cd 来导航文件系统：
In [11]: !pwd
/home/jake/projects/myproject
In [12]: !cd ..
In [13]: !pwd
/home/jake/projects/myproject
原因是 Notebook 中的 shell 命令是在一个临时的分支 shell 中执行的。如果你希望以一种更持久的方式更改工作路径，可以使用 %cd 魔法命令：
In [14]: %cd ..
/home/jake/projects
事实上，默认情况下你甚至可以不用 % 符号实现该功能：
In [15]: cd myproject
/home/jake/projects/myproject
这种方式被称作自动魔法（automagic）函数，可以通过 %automagic 魔法函数进行翻转。
除了 %cd，其他可用的类似 shell 的魔法函数还有 %cat、%cp、%env、%ls、%man、%mkdir、%more、%mv、%pwd、%rm 和 %rmdir。如果 automagic 被打开，以上任何一个魔法命令都可以省略 % 符号，这使得你可以将 IPython 提示符当作普通 shell 一样使用：
In [16]: mkdir tmp
In [17]: ls
myproject.txt tmp/
In [18]: cp myproject.txt tmp/
In [19]: ls tmp
myproject.txt
In [20]: rm -r tmp
这种在和 Python 会话相同的窗口中访问 shell 的方式，意味着你在编辑 Python 代码时，可以减少在 Python 解释器和 shell 之间来回切换的次数。
1.8 错误和调试
代码开发和数据分析经常需要一些试错，而 IPython 包含了一系列提高这一流程效率的工具。这一节将先简要介绍一些控制 Python 异常报告的选项，然后探索调试代码中错误的工具。
1.8.1 控制异常：%xmode
大多数时候，当一个 Python 脚本未执行通过时，会抛出一个异常。当解释器捕获到这些异常中的一个时，可以在轨迹追溯（traceback）中找到引起这个错误的原因。利用 %xmode 魔法函数，IPython 允许你在异常发生时控制打印信息的数量。以下面的代码为例：
In[1]: def func1(a, b):
return a / b
def func2(x):
a = x
b = x - 1
return func1(a, b)
In[2]: func2(1)
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-2-b2e110f6fc8f^gt; in <module>()
----> 1 func2(1)
<ipython-input-1-d849e34d61fb> in func2(x)
5 a = x
6 b = x - 1
----> 7 return func1(a, b)
<ipython-input-1-d849e34d61fb> in func1(a, b)
1 def func1(a, b):
----> 2 return a / b
3
4 def func2(x):
5 a = x
ZeroDivisionError: division by zero
调用 func2 函数导致一个错误，阅读打印的轨迹可以清楚地看见发生了什么。默认情况下，这个轨迹信息包括几行，显示了导致错误的每个步骤的上下文。利用 %xmode 魔法函数（简称异常模式），可以改变打印的信息。
%xmode 有一个输入参数，即模式。模式有 3 个可选项：Plain、Context 和 Verbose。默认情况下是 Context，该模式的输出结果我们已经见过。Plain 更紧凑，给出的信息更少：
In[3]: %xmode Plain
Exception reporting mode: Plain
In[4]: func2(1)
------------------------------------------------------------
Traceback (most recent call last):
File "<ipython-input-4-b2e110f6fc8f>", line 1, in <module>
func2(1)
File "<ipython-input-1-d849e34d61fb>", line 7, in func2
return func1(a, b)
File "<ipython-input-1-d849e34d61fb>", line 2, in func1
return a / b
ZeroDivisionError: division by zero
Verbose 模式加入了一些额外的信息，包括任何被调用的函数的参数：
In[5]: %xmode Verbose
Exception reporting mode: Verbose
In[6]: func2(1)
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-6-b2e110f6fc8f> in <module>()
----> 1 func2(1)
global func2 = <function func2 at 0x103729320>
<ipython-input-1-d849e34d61fb> in func2(x=1)
5 a = x
6 b = x - 1
----> 7 return func1(a, b)
global func1 = <function func1 at 0x1037294d0>
a = 1
b = 0
<ipython-input-1-d849e34d61fb> in func1(a=1, b=0)
1 def func1(a, b):
----> 2 return a / b
a = 1
b = 0
3
4 def func2(x):
5 a = x
ZeroDivisionError: division by zero
这些额外的信息可以帮助你发现为什么会出现异常。那么为什么不在所有场景中都使用 Verbose 模式呢？这是因为如果代码变得更复杂，这种方式的轨迹追溯会变得非常长。根据不同情境，有时默认模式的简要描述更容易处理。
1.8.2 调试：当阅读轨迹追溯不足以解决问题时
标准的 Python 交互式调试工具是 pdb，它是 Python 的调试器。这个调试器允许用户逐行运行代码，以便查看可能导致错误的原因。IPython 增强版本的调试器是 ipdb，它是 IPython 专用的调试器。
启动和运行这两个调试器的方式有很多，这里不会一一介绍。你可以通过在线文档了解关于它们的更多信息。
IPython 中最方便的调试界面可能就是 %debug 魔法命令了。如果你在捕获异常后调用该调试器，它会在异常点自动打开一个交互式调试提示符。ipdb 提示符让你可以探索栈空间的当前状态，探索可用变量，甚至运行 Python 命令！
来看看最近的异常，然后执行一些简单的任务——打印 a 和 b 的值，然后输入 quit 来结束调试会话：
In[7]: %debug
> <ipython-input-1-d849e34d61fb>(2)func1()
1 def func1(a, b):
----> 2 return a / b
3
ipdb> print(a)
1
ipdb> print(b)
0
ipdb> quit
这个交互式调试器的功能不止如此，我们甚至可以设置单步入栈和出栈来查看各变量的值：
In[8]: %debug
> <ipython-input-1-d849e34d61fb>(2)func1()
1 def func1(a, b):
----> 2 return a / b
3
ipdb> up
> <ipython-input-1-d849e34d61fb>(7)func2()
5 a = x
6 b = x - 1
----> 7 return func1(a, b)
ipdb> print(x)
1
ipdb> up
> <ipython-input-6-b2e110f6fc8f>(1)<module>()
----> 1 func2(1)
ipdb> down
> <ipython-input-1-d849e34d61fb>(7)func2()
5 a = x
6 b = x - 1
----> 7 return func1(a, b)
ipdb> quit
这让你可以快速找到导致错误的原因，并且知道是哪一个函数调用导致了错误。
如果你希望在发生任何异常时都自动启动调试器，可以用 %pdb 魔法函数来启动这个自动过程：
In[9]: %xmode Plain
%pdb on
func2(1)
Exception reporting mode: Plain
Automatic pdb calling has been turned ON
Traceback (most recent call last):
File "<ipython-input-9-569a67d2d312>", line 3, in <module>
func2(1)
File "<ipython-input-1-d849e34d61fb>", line 7, in func2
return func1(a, b)
File "<ipython-input-1-d849e34d61fb>", line 2, in func1
return a / b
ZeroDivisionError: division by zero
> <ipython-input-1-d849e34d61fb>(2)func1()
1 def func1(a, b):
----> 2 return a / b
3
ipdb> print(b)
0
ipdb> quit
最后，如果你有一个脚本，并且希望以交互式模式运行，则可以用 %run -d 命令来运行，并利用 next 命令单步向下交互地运行代码。
部分调试命令
这里仅仅列举了一部分可用的交互式调试命令。下表中包含了一些常用且有用的命令及其描述。
命令 |
描述 |
|---|---|
|
显示文件的当前路径 |
|
显示命令列表，或查找特定命令的帮助信息 |
|
退出调试器和程序 |
|
退出调试器，继续运行程序 |
|
跳到程序的下一步 |
|
重复前一个命令 |
|
打印变量 |
|
步入子进程 |
|
从子进程跳出 |
在调试器中使用 help 命令，或者查看 ipdb 的在线文档（https://github.com/gotcha/ipdb）获取更多的相关信息。
1.9 代码的分析和计时
在开发代码和创建数据处理管道的过程中，经常需要在各种实现方式之间取舍，但在开发算法的早期就考虑这些事情会适得其反。正如高德纳的名言所说：“大约 97% 的时间，我们应该忘记微小的效率差别；过早优化是一切罪恶的根源。”
不过，一旦代码运行起来，提高代码的运行效率总是有用的。有时候查看给定命令或一组命令的的运行时间非常有用，有时候深入多行进程并确定一系列复杂操作的效率瓶颈也非常有用。IPython 提供了很多执行这些代码计时和分析的操作函数。我们将讨论以下 IPython 魔法命令。
%time
对单个语句的执行时间进行计时。
%timeit
对单个语句的重复执行进行计时，以获得更高的准确度。
%prun
利用分析器运行代码。
%lprun
利用逐行分析器运行代码。
%memit
测量单个语句的内存使用。
%mprun
通过逐行的内存分析器运行代码。
最后 4 条魔法命令并不是与 IPython 捆绑的，你需要安装 line_profiler 和 memory_profiler 扩展。我们将在接下来的部分介绍这些扩展。
1.9.1 代码段计时：%timeit和%time
1.4 节对魔法函数进行了简单的介绍，我们了解了 %timeit 行魔法和 %%timeit 单元魔法，其中 %%timeit 可以让代码段重复运行来计算代码的运行时间：
In[1]: %timeit sum(range(100))
100000 loops, best of 3: 1.54 μs per loop
请注意，因为这个操作很快，所以 %timeit 自动让代码段重复运行很多次。对于较慢的命令，%timeit 将自动调整并减少重复执行的次数：
In[2]: %%timeit
total = 0
for i in range(1000):
for j in range(1000):
total += i * (-1) ** j
1 loops, best of 3: 407 ms per loop
有时候重复一个操作并不是最佳选择。例如，如果有一个列表需要排序，我们可能会被重复操作误导。对一个预先排好序的列表进行排序，比对一个无序的列表进行排序要快，所以重复运行将使结果出现偏差：
In[3]: import random
L = [random.random() for i in range(100000)]
%timeit L.sort()
100 loops, best of 3: 1.9 ms per loop
对于这种情况，%time 魔法函数可能是更好的选择。对于运行时间较长的命令来说，如果较短的系统延迟不太可能影响结果，那么 %time 魔法函数也是一个不错的选择。下面对一个无序列表排序和一个已排序列表排序分别计时：
In[4]: import random
L = [random.random() for i in range(100000)]
print("sorting an unsorted list:")
%time L.sort()
sorting an unsorted list:
CPU times: user 40.6 ms, sys: 896 μs, total: 41.5 ms
Wall time: 41.5 ms
In[5]: print("sorting an already sorted list:")
%time L.sort()
sorting an already sorted list:
CPU times: user 8.18 ms, sys: 10 μs, total: 8.19 ms
Wall time: 8.24 ms
可以看出，虽然对已排序的列表进行排序比对未排序的列表进行排序快很多，但是即使同样对已排序的列表进行排序，用 %time 计时也比用 %timeit 计时花费的时间要长。这是由于 %timeit 在底层做了一些很聪明的事情来阻止系统调用对计时过程的干扰。例如，%timeit 会阻止清理未利用的 Python 对象（即垃圾回收），该过程可能影响计时。因此，%timeit 通常比 %time 更快得到结果。
和 %timeit 一样，%time 魔法命令也可以通过双百分号语法实现多行代码的计时：
In[6]: %%time
total = 0
for i in range(1000):
for j in range(1000):
total += i * (-1) ** j
CPU times: user 504 ms, sys: 979 μs, total: 505 ms
Wall time: 505 ms
关于 %time 和 %timeit 的更多信息以及它们可用的参数选项，可以通过 IPython 的帮助功能（如在 IPython 提示符中输入 %time?）获取。
1.9.2 分析整个脚本：%prun
一个程序是由很多单个语句组成的，有时候对整个脚本计时比对单个语句计时更重要。 Python 包含一个内置的代码分析器（你可以在 Python 文档中了解更多相关信息），但是 IPython 提供了一种更方便的方式来使用这个分析器，即通过魔法函数 %prun 实现。
在以下例子中，我们将定义一个简单的函数，该函数会完成一些计算：
In[7]: def sum_of_lists(N):
total = 0
for i in range(5):
L = [j ^ (j >> i) for j in range(N)]
total += sum(L)
return total
现在用 %prun 和一个函数调用来看分析结果：
In[8]: %prun sum_of_lists(1000000)
在 Notebook 中，输出结果打印在页面中，如下所示：
14 function calls in 0.714 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
5 0.599 0.120 0.599 0.120 <ipython-input-19>:4(<listcomp>)
5 0.064 0.013 0.064 0.013 {built-in method sum}
1 0.036 0.036 0.699 0.699 <ipython-input-19>:1(sum_of_lists)
1 0.014 0.014 0.714 0.714 <string>:1(<module>)
1 0.000 0.000 0.714 0.714 {built-in method exec}
结果是一个表格，该表格按照每个函数调用的总时间，显示了哪里的执行时间最长。在这个例子中，大部分执行时间用在 sum_of_lists 的列表综合中。通过观察这个数据，我们可以开始考虑通过调整哪里来提升算法的性能。
关于 %prun 的更多信息以及它们可用的参数选项，可以通过 IPython 的帮助功能（在 IPython 提示符中输入 %prun?）获取。
1.9.3 用%lprun进行逐行分析
用 %prun 对代码中的每个函数进行分析非常有用，但有时逐行代码分析报告更方便。该功能并没有内置于 Python 或 IPython，但是可以通过安装 line_profiler 包来实现。首先利用 Python 的包管理工具 pip 安装 line_profiler 包：
$ pip install line_profiler
接下来可以用 IPython 导入 line_profiler 包提供的 IPython 扩展：
In[9]: %load_ext line_profiler
现在 %lprun 命令就可以对所有函数进行逐行分析了。在下面的例子中，我们需要明确指出要分析哪些函数：
In[10]: %lprun -f sum_of_lists sum_of_lists(5000)
和前面的性能分析过程一样，Notebook 会在页面上返回结果，如下所示：
Timer unit: 1e-06 s
Total time: 0.009382 s
File: <ipython-input-19-fa2be176cc3e>
Function: sum_of_lists at line 1
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1 def sum_of_lists(N):
2 1 2 2.0 0.0 total = 0
3 6 8 1.3 0.1 for i in range(5):
4 5 9001 1800.2 95.9 L = [j ^ (j >> i) ...
5 5 371 74.2 4.0 total += sum(L)
6 1 0 0.0 0.0 return total
最上面的信息给出了阅读这些结果的关键：报告中的运行时间单位是微秒，我们可以看到程序中哪些地方最耗时。可以通过这些信息修改代码，使其更高效地实现我们的目的。
更多关于 %lprun 的信息以及相关的参数选项，可以通过 IPython 的帮助功能（在 IPython 提示符中输入 %lprun?）获取。
1.9.4 用%memit和%mprun进行内存分析
另一种分析是分析一个操作所用的内存量，这可以通过 IPython 的另一个扩展来评估，即 memory_profiler。和 line_profiler 一样，首先用 pip 安装这个扩展：
$ pip install memory_profiler
然后用 IPython 导入该扩展：
In[12]: %load_ext memory_profiler
内存分析扩展包括两个有用的魔法函数：%memit 魔法函数（它提供的内存消耗计算功能类似于 %timeit）和 %mprun 魔法函数（它提供的内存消耗计算功能类似于 %lprun）。%memit 函数用起来很简单：
In[13]: %memit sum_of_lists(1000000)
peak memory: 100.08 MiB, increment: 61.36 MiB
可以看到，这个函数大概消耗了 100MB 的内存。
对于逐行代码的内存消耗描述，可以用 %mprun 魔法函数。但不幸的是，这个魔法函数仅仅对独立模块内部的函数有效，而对于 Notebook 本身不起作用。所以首先用 %%file 魔法函数创建一个简单的模块，将该模块命名为 mprun_demo.py。它包含 sum_of_lists 函数，该函数中包含一次加法，能使内存分析结果更清晰：
In[14]: %%file mprun_demo.py
def sum_of_lists(N):
total = 0
for i in range(5):
L = [j ^ (j >> i) for j in range(N)]
total += sum(L)
del L # remove reference to L
return total
Overwriting mprun_demo.py
现在可以重新导入函数，并运行逐行内存分析器：
In[15]: from mprun_demo import sum_of_lists
%mprun -f sum_of_lists sum_of_lists(1000000)
页面中打印的结果概述了该函数的内存消耗情况，如下所示：
Filename: ./mprun_demo.py
Line # Mem usage Increment Line Contents
================================================
4 71.9 MiB 0.0 MiB L = [j ^ (j >> i) for j in range(N)]
Filename: ./mprun_demo.py
Line # Mem usage Increment Line Contents
================================================
1 39.0 MiB 0.0 MiB def sum_of_lists(N):
2 39.0 MiB 0.0 MiB total = 0
3 46.5 MiB 7.5 MiB for i in range(5):
4 71.9 MiB 25.4 MiB L = [j ^ (j >> i) for j in range(N)]
5 71.9 MiB 0.0 MiB total += sum(L)
6 46.5 MiB -25.4 MiB del L # remove reference to L
7 39.1 MiB -7.4 MiB return total
Increment 列告诉我们每行代码对总内存预算的影响：创建和删除列表 L 时用掉了 25MB 的内存。这是除了 Python 解释器本身外最消耗内存资源的部分。
关于 %menit 和 %mprun 的更多信息以及相关的参数选项，可以通过 IPython 的帮助功能（在 IPython 提示符中输入 %memit?）获取。
1.10 IPython参考资料
这一章仅仅粗浅地介绍了如何利用 IPython 完成数据科学任务，你可以在其他图书和互联网上找到更多信息。下面列举了其中一些可能对你有帮助的资源。
1.10.1 网络资源
IPython 网站（http://ipython.org）
IPython 网站链接到各种相关文档、示例、教程以及很多其他资源。
nbviewer 网站（http://nbviewer.ipython.org/）
该网站展示了网络上任何可用的 IPython Notebook 的静态翻译。该网站的首页展示了一些示例 Notebook，通过这些示例你可以看到其他人用 IPython 做了什么。
有趣的 IPython Notebook 集合（http://github.com/ipython/ipython/wiki/A-gallery-of-interesting-IPython-Notebooks/）
这是由 nbviewer 运行的最全的 Notebook 列表（并且该列表还在不断增长），展示了通过 IPython 可以进行多深、多广的数值分析。它还包括短小的示例、全套课程教程以及 Notebook 格式的图书。
视频教程
通过搜索互联网，你可以找到很多 IPython 的视频教程。强烈建议你搜索 Fernando Perez 和 Brian Granger 在 PyCon、SciPy 和 PyData 会议中的视频，他们二位是 IPython 和 Jupyter 的主要创建者和维护者。
1.10.2 相关图书
《利用 Python 进行数据分析》
Wes McKinney 的这本书用一章介绍了如何像数据科学家那样使用 IPython。尽管其中的很多内容与上面介绍的内容有所重复，但多一个视角总不是坏事。
Learning IPython for Interactive Computing and Data Visualization（http://bit.ly/2eLCBB7）
Cyrille Rossant 的这本薄书对如何用 IPython 进行数据分析作了很好的介绍。
IPython Interactive Computing and Visualization Cookbook（http://bit.ly/2fCEtNE）
这本也是 Cyrille Rossant 的著作。它篇幅更长，并且深入介绍了将 IPython 用于数据科学的方法。这本书不仅仅是关于 IPython 的，还涉及了数据科学中更深、更广的主题。
最后要提醒你的是，你可以自己寻求帮助。如果你能充分且经常使用 IPython 的 ? 式帮助功能（详情请参见 1.2 节），会对你大有帮助。当你学习本书或别处介绍的示例时，可以用这个功能来熟悉 IPython 提供的所有工具。
