How to save a Python interactive session?

问题:

I find myself frequently using Python\'s interpreter to work with databases, files, etc -- basically a lot of manual formatting of semi-structured data. I don\'t properly save and clean up the useful bits as often as I would like. Is there a way to save my input into the shell (db connections, variable assignments, little for loops and bits of logic) -- some history of the interactive session? If I use something like script I get too much stdout noise. I don\'t really need to pickle all the objects -- though if there is a solution that does that, it would be OK. Ideally I would just be left with a script that ran as the one I created interactively, and I could just delete the bits I didn\'t need. Is there a package that does this, or a DIY approach?

UPDATE: I am really amazed at the quality and usefulness of these packages. For those with a similar itch:

• IPython -- should have been using this for ages, kind of what I had in mind
• reinteract -- very impressive, I want to learn more about visualization and this seems like it will shine there. Sort of a gtk/gnome desktop app that renders graphs inline. Imagine a hybrid shell + graphing calculator + mini eclipse. Source distribution here: http://www.reinteract.org/trac/wiki/GettingIt . Built fine on Ubuntu, integrates into gnome desktop, Windows and Mac installers too.
• bpython -- extremely cool, lots of nice features, autocomplete(!), rewind, one keystroke save to file, indentation, well done. Python source distribution, pulled a couple of dependencies from sourceforge.

I am converted, these really fill a need between interpreter and editor.

回答1:

IPython is extremely useful if you like using interactive sessions. For example for your use-case there is the %save magic command, you just input %save my_useful_session 10-20 23 to save input lines 10 to 20 and 23 to my_useful_session.py (to help with this, every line is prefixed by its number).

Furthermore, the documentation states:

This function uses the same syntax as %history for input ranges, then saves the lines to the filename you specify.

This allows for example, to reference older sessions, such as

%save current_session ~0/
%save previous_session ~1/

Look at the videos on the presentation page to get a quick overview of the features.

回答2:

http://www.andrewhjon.es/save-interactive-python-session-history

import readline
readline.write_history_file(\'/home/ahj/history\')

回答3:

There is a way to do it. Store the file in ~/.pystartup...

# Add auto-completion and a stored history file of commands to your Python
# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is
# bound to the Esc key by default (you can change it - see readline docs).
#
# Store the file in ~/.pystartup, and set an environment variable to point
# to it:  \"export PYTHONSTARTUP=/home/user/.pystartup\" in bash.
#
# Note that PYTHONSTARTUP does *not* expand \"~\", so you have to put in the
# full path to your home directory.

import atexit
import os
import readline
import rlcompleter

historyPath = os.path.expanduser(\"~/.pyhistory\")

def save_history(historyPath=historyPath):
    import readline
    readline.write_history_file(historyPath)

if os.path.exists(historyPath):
    readline.read_history_file(historyPath)

atexit.register(save_history)
del os, atexit, readline, rlcompleter, save_history, historyPath

and then set the environment variable PYTHONSTARTUP in your shell (e.g. in ~/.bashrc):

export PYTHONSTARTUP=$HOME/.pystartup

You can also add this to get autocomplete for free:

readline.parse_and_bind(\'tab: complete\')

Please note that this will only work on *nix systems. As readline is only available in Unix platform.

回答4:

If you are using IPython you can save to a file all your previous commands using the magic function %history with the -f parameter, p.e:

%history -f /tmp/history.py

回答5:

After installing Ipython, and opening an Ipython session by running the command:

ipython

from your command line, just run the following Ipython \'magic\' command to automatically log your entire Ipython session:

%logstart

This will create a uniquely named .py file and store your session for later use as an interactive Ipython session or for use in the script(s) of your choosing.

回答6:

Also, reinteract gives you a notebook-like interface to a Python session.

回答7:

In addition to IPython, a similar utility bpython has a \"save the code you\'ve entered to a file\" feature

回答8:

I had to struggle to find an answer, I was very new to iPython environment.

This will work

If your iPython session looks like this

In [1] : import numpy as np
....
In [135]: counter=collections.Counter(mapusercluster[3])
In [136]: counter
Out[136]: Counter({2: 700, 0: 351, 1: 233})

You want to save lines from 1 till 135 then on the same ipython session use this command

In [137]: %save test.py 1-135

This will save all your python statements in test.py file in your current directory ( where you initiated the ipython).

回答9:

There is %history magic for printing and saving the input history (and optionally the output).

To store your current session to a file named my_history.py:

>>> %hist -f my_history.py

History IPython stores both the commands you enter, and the results it produces. You can easily go through previous commands with the up- and down-arrow keys, or access your history in more sophisticated ways.

You can use the %history magic function to examine past input and output. Input history from previous sessions is saved in a database, and IPython can be configured to save output history.

Several other magic functions can use your input history, including %edit, %rerun, %recall, %macro, %save and %pastebin. You can use a standard format to refer to lines:

%pastebin 3 18-20 ~1/1-5

This will take line 3 and lines 18 to 20 from the current session, and lines 1-5 from the previous session.

See %history? for the Docstring and more examples.

Also, be sure to explore the capabilities of %store magic for lightweight persistence of variables in IPython.

Stores variables, aliases and macros in IPython’s database.

d = {\'a\': 1, \'b\': 2}
%store d  # stores the variable
del d

%store -r d  # Refresh the variable from IPython\'s database.
>>> d
{\'a\': 1, \'b\': 2}

To autorestore stored variables on startup, specifyc.StoreMagic.autorestore = True in ipython_config.py.

回答10:

Just putting another suggesting in the bowl: Spyder

It has History log and Variable explorer. If you have worked with MatLab, then you\'ll see the similarities.

回答11:

As far as Linux goes, one can use script command to record the whole session. It is part of util-linux package so should be on most Linux systems . You can create and alias or function that will call script -c python and that will be saved to a typescript file. For instance, here\'s a reprint of one such file.

$ cat typescript                                                                                                      
Script started on Sat 14 May 2016 08:30:08 AM MDT
Python 2.7.6 (default, Jun 22 2015, 17:58:13) 
[GCC 4.8.2] on linux2
Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.
>>> print \'Hello Pythonic World\'
Hello Pythonic World
>>> 

Script done on Sat 14 May 2016 08:30:42 AM MDT

Small disadvantage here is that the script records everything , even line-feeds, whenever you hit backspaces , etc. So you may want to use col to clean up the output (see this post on Unix&Linux Stackexchange) .

回答12:

there is another option --- pyslice. in the \"wxpython 2.8 docs demos and tools\", there is a open source program named \"pyslices\".

you can use it like a editor, and it also support using like a console ---- executing each line like a interactive interpreter with immediate echo.

of course, all the blocks of codes and results of each block will be recorded into a txt file automatically.

the results are logged just behind the corresponding block of code. very convenient.

回答13:

The %history command is awesome, but unfortunately it won\'t let you save things that were %paste \'d into the sesh. To do that I think you have to do %logstart at the beginning (although I haven\'t confirmed this works).

What I like to do is

%history -o -n -p -f filename.txt

which will save the output, line numbers, and \'>>>\' before each input (o, n, and p options). See the docs for %history here.

回答14:

Some comments were asking how to save all of the IPython inputs at once. For %save magic in IPython, you can save all of the commands programmatically as shown below, to avoid the prompt message and also to avoid specifying the input numbers. currentLine = len(In)-1 %save -f my_session 1-$currentLine

The -f option is used for forcing file replacement and the len(IN)-1 shows the current input prompt in IPython, allowing you to save the whole session programmatically.

回答15:

For those using spacemacs, and ipython that comes with python-layer, save magic creates a lot of unwanted output, because of the constant auto-completion command working in the backround such as:

len(all_suffixes)
\';\'.join(__PYTHON_EL_get_completions(\'\'\'len\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all_substa\'\'\'))
len(all_substantives_w_suffixes)
\';\'.join(__PYTHON_EL_get_completions(\'\'\'len\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all_\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all_w\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all_wo\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all_wor\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all_word\'\'\'))
\';\'.join(__PYTHON_EL_get_completions(\'\'\'all_words\'\'\'))
len(all_words_w_logograms)
len(all_verbs)

To avoid this just save the ipython buffer like you normally save any other: spc f s

回答16:

If you use bpython, all your command history is by default saved to ~/.pythonhist.

To save the commands for later reusage you can copy them to a python script file:

$ cp ~/.pythonhist mycommands.py

Then edit that file to clean it up and put it under Python path (global or virtual environment\'s site-packages, current directory, mentioning in *.pth, or some other way).

To include the commands into your shell, just import them from the saved file:

>>> from mycommands import *

回答17:

I\'d like to suggest another way to maintain python session through tmux on linux. you run tmux, attach your self to the session you opened (if not attached after opening it directly). execute python and do whatever you are doing on it. then detach from session. detaching from a tmux session does not close the session. the session remains open.

pros of this method: you can attach to this session from any other device (in case you can ssh your pc)

cons of this method: this method does not relinquish the resources used by the opened python session until you actually exist the python interpreter.