IPython文档：交互式Python shell和并行计算

需积分: 7 140 浏览量更新于2024-07-18 收藏 611KB PDF 举报

"Python 查询IP" IPython是一个基于Python的交互式shell和开发环境，提供了丰富的功能和工具来支持交互式计算和开发。以下是IPython的主要知识点：概述 IPython是一个交互式的Python shell，可以提供更加灵活和高效的开发体验。它支持交互式计算、并行计算、数据分析和可视化等功能。安装 IPython可以通过pip安装，安装命令为`pip install ipython`。在安装IPython之前，需要安装Python和一些基本的依赖项。交互式 shell IPython提供了一个交互式shell，支持交互式计算和开发。用户可以在shell中输入Python代码，并实时查看结果。并行计算 IPython支持并行计算，可以使用多个核心或多台计算机来执行计算任务。IPython提供了多种并行计算接口，包括多引擎接口和任务接口。配置和自定义 IPython提供了丰富的配置和自定义选项，用户可以根据需要自定义IPython的行为和外观。开发 IPython是一个开源项目，欢迎开发者参与贡献和开发。IPython提供了详细的开发文档和指南，帮助开发者快速上手。 License 和版权 IPython遵守BSD许可证，允许自由使用和分发。IPython Development Team负责维护和开发IPython。历史 IPython诞生于2001年，最初由 Fernando Pérez创建。今天，IPython已经发展成为一个成熟的项目，拥有庞大的用户和开发者社区。 FAQ IPython提供了详细的FAQ文档，回答了用户常见的问题，包括安装、使用和开发等方面的问题。 IPython的应用 IPython广泛应用于科学计算、数据分析、机器学习和人工智能等领域。IPython提供了丰富的工具和库，帮助用户快速开发和部署应用程序。

IPython Documentation, Release 0.9

most effective use of it for everyday Python development, highlighting things you might miss in the rest of

the manual (which is getting long). We’ll give references to parts in the manual which provide more detail

when appropriate.

The following article by Jeremy Jones provides an introductory tutorial about IPython:

http://www.onlamp.com/pub/a/python/2005/01/27/ipython.html

3.1.1 Highlights

Tab completion

TAB-completion, especially for attributes, is a convenient way to explore the structure of any object you’re

dealing with. Simply type object_name.<TAB> and a list of the object’s attributes will be printed (see the

readline section for more). Tab completion also works on ﬁle and directory names, which combined with

IPython’s alias system allows you to do from within IPython many of the things you normally would need

the system shell for.

Explore your objects

Typing object_name? will print all sorts of details about any object, including docstrings, function deﬁni-

tion lines (for call arguments) and constructor details for classes. The magic commands %pdoc, %pdef,

%psource and %pﬁle will respectively print the docstring, function deﬁnition line, full source code and the

complete ﬁle for any object (when they can be found). If automagic is on (it is by default), you don’t need

to type the ‘%’ explicitly. See

this section for more.

The %run magic command

The %run magic command allows you to run any python script and load all of its data directly into the

interactive namespace. Since the ﬁle is re-read from disk each time, changes you make to it are reﬂected

immediately (in contrast to the behavior of import). I rarely use import for code I am testing, relying on

%run instead. See this section for more on this and other magic commands, or type the name of any magic

command and ? to get details on it. See also this section for a recursive reload command. %run also has

special ﬂags for timing the execution of your scripts (-t) and for executing them under the control of either

Python’s pdb debugger (-d) or proﬁler (-p). With all of these, %run can be used as the main tool for efﬁcient

interactive development of code which you write in your editor of choice.

Debug a Python script

Use the Python debugger, pdb. The %pdb command allows you to toggle on and off the automatic invocation

of an IPython-enhanced pdb debugger (with coloring, tab completion and more) at any uncaught exception.

The advantage of this is that pdb starts inside the function where the exception occurred, with all data still

available. You can print variables, see code, execute statements and even walk up and down the call stack to

track down the true source of the problem (which often is many layers in the stack above where the exception

gets triggered). Running programs with %run and pdb active can be an efﬁcient to develop and debug code,

in many cases eliminating the need for print statements or external debugging tools. I often simply put a 1/0

in a place where I want to take a look so that pdb gets called, quickly view whatever variables I need to or

12 Contents

IPython Documentation, Release 0.9

test various pieces of code and then remove the 1/0. Note also that ‘%run -d’ activates pdb and automatically

sets initial breakpoints for you to step through your code, watch variables, etc. The output caching section

has more details.

Use the output cache

All output results are automatically stored in a global dictionary named Out and variables named _1, _2, etc.

alias them. For example, the result of input line 4 is available either as Out[4] or as _4. Additionally, three

variables named _, __ and ___ are always kept updated with the for the last three results. This allows you to

recall any previous result and further use it for new calculations. See the output caching section for more.

Suppress output

Put a ‘;’ at the end of a line to suppress the printing of output. This is useful when doing calculations which

generate long output you are not interested in seeing. The _* variables and the Out[] list do get updated with

the contents of the output, even if it is not printed. You can thus still access the generated results this way

for further processing.

Input cache

A similar system exists for caching input. All input is stored in a global list called In , so you can re-execute

lines 22 through 28 plus line 34 by typing ‘exec In[22:29]+In[34]’ (using Python slicing notation). If you

need to execute the same set of lines often, you can assign them to a macro with the %macro function. See

here for more.

Use your input history

The %hist command can show you all previous input, without line numbers if desired (option -n) so you can

directly copy and paste code either back in IPython or in a text editor. You can also save all your history by

turning on logging via %logstart; these logs can later be either reloaded as IPython sessions or used as code

for your programs.

Deﬁne your own system aliases

Even though IPython gives you access to your system shell via the ! preﬁx, it is convenient to have aliases

to the system commands you use most often. This allows you to work seamlessly from inside IPython with

the same commands you are used to in your system shell. IPython comes with some pre-deﬁned aliases and

a complete system for changing directories, both via a stack (see %pushd, %popd and %dhist) and via direct

%cd. The latter keeps a history of visited directories and allows you to go to any previously visited one.

Call system shell commands

Use Python to manipulate the results of system commands. The ‘!!’ special syntax, and the %sc and %sx

magic commands allow you to capture system output into Python variables.

Contents 13

IPython Documentation, Release 0.9

Use Python variables when calling the shell

Expand python variables when calling the shell (either via ‘!’ and ‘!!’ or via aliases) by prepending a $ in

front of them. You can also expand complete python expressions. See our shell section for more details.

Use proﬁles

Use proﬁles to maintain different conﬁgurations (modules to load, function deﬁnitions, option settings) for

particular tasks. You can then have customized versions of IPython for speciﬁc purposes. This section has

more details.

Embed IPython in your programs

A few lines of code are enough to load a complete IPython inside your own programs, giving you the ability

to work with your data interactively after automatic processing has been completed. See here for more.

Use the Python proﬁler

When dealing with performance issues, the %run command with a -p option allows you to run complete

programs under the control of the Python proﬁler. The %prun command does a similar job for single Python

expressions (like function calls).

Use IPython to present interactive demos

Use the IPython.demo.Demo class to load any Python script as an interactive demo. With a minimal amount

of simple markup, you can control the execution of the script, stopping as needed. See here for more.

Run doctests

Run your doctests from within IPython for development and debugging. The special %doctest_mode com-

mand toggles a mode where the prompt, output and exceptions display matches as closely as possible that

of the default Python interpreter. In addition, this mode allows you to directly paste in code that contains

leading ‘>>>’ prompts, even if they have extra leading whitespace (as is common in doctest ﬁles). This com-

bined with the ‘%history -tn’ call to see your translated history (with these extra prompts removed and no

line numbers) allows for an easy doctest workﬂow, where you can go from doctest to interactive execution

to pasting into valid Python code as needed.

3.1.2 Source code handling tips

IPython is a line-oriented program, without full control of the terminal. Therefore, it doesn’t support true

multiline editing. However, it has a number of useful tools to help you in dealing effectively with more

complex editing.

The %edit command gives a reasonable approximation of multiline editing, by invoking your favorite editor

on the spot. IPython will execute the code you type in there as if it were typed interactively. Type %edit?

for the full details on the edit command.

14 Contents

IPython Documentation, Release 0.9

If you have typed various commands during a session, which you’d like to reuse, IPython provides you with

a number of tools. Start by using %hist to see your input history, so you can see the line numbers of all

input. Let us say that you’d like to reuse lines 10 through 20, plus lines 24 and 28. All the commands below

can operate on these with the syntax:

%command 10-20 24 28

where the command given can be:

• %macro <macroname>: this stores the lines into a variable which, when called at the prompt, re-

executes the input. Macros can be edited later using ‘%edit macroname’, and they can be stored

persistently across sessions with ‘%store macroname’ (the storage system is per-proﬁle). The com-

bination of quick macros, persistent storage and editing, allows you to easily reﬁne quick-and-dirty

interactive input into permanent utilities, always available both in IPython and as ﬁles for general

reuse.

• %edit: this will open a text editor with those lines pre-loaded for further modiﬁcation. It will then

execute the resulting ﬁle’s contents as if you had typed it at the prompt.

• %save <ﬁlename>: this saves the lines directly to a named ﬁle on disk.

While %macro saves input lines into memory for interactive re-execution, sometimes you’d like to save your

input directly to a ﬁle. The %save magic does this: its input sytnax is the same as %macro, but it saves your

input directly to a Python ﬁle. Note that the %logstart command also saves input, but it logs all input to disk

(though you can temporarily suspend it and reactivate it with %logoff/%logon); %save allows you to select

which lines of input you need to save.

3.1.3 Lightweight ‘version control’

When you call %edit with no arguments, IPython opens an empty editor with a temporary ﬁle, and it returns

the contents of your editing session as a string variable. Thanks to IPython’s output caching mechanism,

this is automatically stored:

In [1]: %edit

IPython will make a temporary file named: /tmp/ipython_edit_yR-HCN.py

Editing... done. Executing edited code...

hello - this is a temporary file

Out[1]: "print ’hello - this is a temporary file’\n"

Now, if you call ‘%edit -p’, IPython tries to open an editor with the same data as the last time you used

%edit. So if you haven’t used %edit in the meantime, this same contents will reopen; however, it will be

done in a new ﬁle. This means that if you make changes and you later want to ﬁnd an old version, you

can always retrieve it by using its output number, via ‘%edit _NN’, where NN is the number of the output

prompt.

Continuing with the example above, this should illustrate this idea:

Contents 15

剩余152页未读，继续阅读

JinYi

粉丝: 37
资源: 9

IPython文档：交互式Python shell和并行计算

python 查询 IP

基于python实现查询ip地址来源

查询IP地址

Python查询IP地址归属完整代码

micro python 查询ip

python查询ip接口

python 查询ip归属地 ip138

用Python查询IP归属地

写python查询IP地址归属地

无接口用python查询IP的归属地

最新资源