# shell – How to save a Python interactive session?

## The Question :

426 people think this question is useful

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?

420 people think this answer is useful

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.

174 people think this answer is useful

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

import readline



96 people think this answer is useful

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 rlcompleter

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

def save_history(historyPath=historyPath):

if os.path.exists(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. ## The Answer 4 76 people think this answer is useful 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  ## The Answer 5 21 people think this answer is useful 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. ## The Answer 6 14 people think this answer is useful Also, reinteract gives you a notebook-like interface to a Python session. ## The Answer 7 11 people think this answer is useful In addition to IPython, a similar utility bpython has a “save the code you’ve entered to a file” feature ## The Answer 8 9 people think this answer is useful 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). ## The Answer 9 3 people think this answer is useful 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. ## The Answer 10 3 people think this answer is useful 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. ## The Answer 11 3 people think this answer is useful 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. ## The Answer 12 2 people think this answer is useful 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
>>> 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) .

1 people think this answer is useful

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.

1 people think this answer is useful

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 *  ## The Answer 15 0 people think this answer is useful 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.

0 people think this answer is useful

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

0 people think this answer is useful

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.

0 people think this answer is useful

To save input and output on XUbuntu:

1. In XWindows, run iPython from the Xfce terminal app
2. click Terminal in the top menu bar and look for save contents in the dropdown

I find this saves the input and output, going all the way back to when I opened the terminal. This is not ipython specific, and would work with ssh sessions or other tasks run from the terminal window.

0 people think this answer is useful

In IPython, I first use

In [2]: %hist



to view my past code. I select the chunk I want to save and then paste it into file my_file.py using the %%file magic (short for %%writefile)

In [3]: %%file my_file.py
...: # paste code here
...:
...:



hitting return two times in the end.

To append to file use the option -a: %%file -a my_file.py.

If needed, I can list, edit, etc. the file in the underlying command line using the exclamation mark

In [5]: !ls -l my_file.py
In [6]: !vi my_file.py



-1 people think this answer is useful

You can use built-in function open: I use it in all of my programs in which I need to store some history (Including Calculator, etc.) for example:

#gk-test.py or anything else would do
try: # use the try loop only if you haven't created the history file outside program