Como salvar uma sessão interativa Python?

Encontro-me frequentemente usando o intérprete do Python para trabalhar com bancos de dados, arquivos, etc. - basicamente muita formatação manual de dados semiestruturados. Não guardo e limpo adequadamente os bits úteis quantas vezes quiser. Existe uma maneira de salvar minha entrada no shell (conexões db, atribuições de variáveis, pouco para loops e bits de lógica) - algum histórico da sessão interativa? Se eu usar algo como script, recebo muito ruído stdout. Eu realmente não preciso selecionar todos os objetos - embora, se houver uma solução que faça isso, seria bom. Idealmente, eu ficaria com um script executado como o que eu criei interativamente, e eu poderia excluir os bits de que não precisava. Existe um pacote que faça isso ou uma abordagem de bricolage?

ATUALIZAÇÃO : Estou realmente impressionado com a qualidade e utilidade desses pacotes. Para aqueles com coceira semelhante:

• IPython - deveria estar usando isso há muito tempo, tipo o que eu tinha em mente
• reinteract - muito impressionante, quero aprender mais sobre visualização e isso parece que vai brilhar lá. Uma espécie de aplicativo de desktop gtk / gnome que renderiza gráficos em linha. Imagine uma concha híbrida + calculadora gráfica + mini eclipse. Distribuição da fonte aqui: http://www.reinteract.org/trac/wiki/GettingIt . Construído perfeitamente no Ubuntu, integra-se ao desktop gnome, instaladores de Windows e Mac também.
• bpython - extremamente legal, com muitos recursos interessantes, preenchimento automático (!), rebobinagem, um toque de tecla salvo no arquivo, recuo, bom trabalho. A distribuição de código-fonte do Python retirou algumas dependências do sourceforge.

Eu sou convertido, isso realmente preenche uma necessidade entre intérprete e editor.

O IPython é extremamente útil se você gosta de usar sessões interativas. Por exemplo, para o seu caso de uso, existe o %savecomando mágico , basta digitar %save my_useful_session 10-20 23para salvar as linhas de entrada 10 a 20 e 23 amy_useful_session.py (para ajudar nisso, cada linha é prefixada por seu número).

Além disso, a documentação declara:

Essa função usa a mesma sintaxe que o % histórico para os intervalos de entrada e salva as linhas no nome do arquivo especificado.

Isso permite, por exemplo, referenciar sessões mais antigas, como

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

Veja os vídeos na página de apresentação para obter uma visão geral rápida dos recursos.

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

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

Existe uma maneira de fazer isso. Armazene o arquivo em ~/.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

e defina a variável de ambiente PYTHONSTARTUPno seu shell (por exemplo, em ~/.bashrc):

export PYTHONSTARTUP=$HOME/.pystartup

Você também pode adicionar isso para obter o preenchimento automático gratuitamente:

readline.parse_and_bind('tab: complete')

Observe que isso funcionará apenas em sistemas * nix. Como o readline está disponível apenas na plataforma Unix.

Se você estiver usando o IPython, poderá salvar em um arquivo todos os seus comandos anteriores usando a função mágica % history com o parâmetro -f , pe:

%history -f /tmp/history.py

Após instalar o Ipython e abrir uma sessão Ipython, executando o comando:

ipython

na linha de comando, basta executar o seguinte comando 'magic' do Ipython para registrar automaticamente toda a sessão do Ipython:

%logstart

Isso criará um arquivo .py com um nome exclusivo e armazenará sua sessão para uso posterior como uma sessão Ipython interativa ou para uso no (s) script (s) de sua escolha.

Além disso, reinteract fornece uma interface semelhante a um notebook para uma sessão Python.

Além do IPython, um utilitário semelhante bpython possui o recurso "salvar o código digitado em um arquivo"

Eu tive que lutar para encontrar uma resposta, eu era muito novo no ambiente iPython.

Isso vai funcionar

Se a sua sessão do iPython estiver assim

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})

Você deseja salvar linhas de 1 a 135 e, na mesma sessão ipython, use este comando

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

Isso salvará todas as suas instruções python no arquivo test.py no diretório atual (onde você iniciou o ipython).

Há% de mágica no histórico para imprimir e salvar o histórico de entrada (e opcionalmente a saída).

Para armazenar sua sessão atual em um arquivo chamado my_history.py:

>>> %hist -f my_history.py

Histórico O IPython armazena os comandos que você digita e os resultados que ele produz. Você pode facilmente passar por comandos anteriores com as teclas de seta para cima e seta para baixo ou acessar seu histórico de maneiras mais sofisticadas.

Você pode usar a função mágica% history para examinar entradas e saídas passadas. O histórico de entrada das sessões anteriores é salvo em um banco de dados e o IPython pode ser configurado para salvar o histórico de saída.

Várias outras funções mágicas podem usar seu histórico de entrada, incluindo% edit,% reexecução,% recall,% macro,% save e% pastebin. Você pode usar um formato padrão para se referir às linhas:

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

Isso levará as linhas 3 e 18 a 20 da sessão atual e as linhas 1-5 da sessão anterior.

Ver% histórico? para o Docstring e mais exemplos.

Além disso, certifique-se de explorar os recursos do % store magic para persistência leve de variáveis ​​no IPython.

Armazena variáveis, aliases e macros no banco de dados do IPython.

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}

Para armazenar automaticamente variáveis ​​armazenadas na inicialização, especifique c.StoreMagic.autorestore = Trueem ipython_config.py.

Apenas colocando outra sugestão na tigela: Spyder

Possui registro de histórico e explorador de variáveis . Se você trabalhou com o MatLab, verá as semelhanças.

No que diz respeito ao Linux, pode-se usar o scriptcomando para gravar a sessão inteira. É parte do util-linuxpacote, portanto deve estar na maioria dos sistemas Linux. Você pode criar um apelido ou função que chamará script -c pythone que será salva em um typescriptarquivo. Por exemplo, aqui está uma reimpressão de um desses arquivos.

$ 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

A pequena desvantagem aqui é que ele scriptregistra tudo, até os feeds de linha, sempre que você toca backspaces, etc. Portanto, você pode usar colpara limpar a saída (veja este post no Unix e Linux Stackexchange ).

O %historycomando é incrível, mas infelizmente não permitirá que você salve coisas que foram% coladas na pasta. Para fazer isso, acho que você tem que fazer %logstart no começo (embora eu não tenha confirmado que isso funciona).

O que eu gosto de fazer é

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

que salvará a saída, os números de linha e '>>>' antes de cada entrada (opções o, ne ep). Veja os documentos para% histórico aqui .

existe outra opção --- pyslice. nas "demonstrações e ferramentas do wxpython 2.8 docs", há um programa de código aberto chamado "pyslices".

você pode usá-lo como um editor e também suporta o uso como um console ---- executando cada linha como um intérprete interativo com eco imediato.

é claro, todos os blocos de códigos e resultados de cada bloco serão gravados em um arquivo txt automaticamente.

os resultados são registrados logo atrás do bloco de código correspondente. muito conveniente.

Se você usa bpython , todo o seu histórico de comandos é salvo por padrão ~/.pythonhist.

Para salvar os comandos para reutilização posterior, você pode copiá-los para um arquivo de script python:

$ cp ~/.pythonhist mycommands.py

Em seguida, edite esse arquivo para limpá-lo e coloque-o no caminho do Python (pacotes de sites do ambiente global ou virtual, diretório atual, menções em * .pth ou outra forma).

Para incluir os comandos no seu shell, basta importá-los do arquivo salvo:

>>> from mycommands import *

Alguns comentários estavam perguntando como salvar todas as entradas do IPython de uma só vez. Para% save magic no IPython, você pode salvar todos os comandos programaticamente conforme mostrado abaixo, para evitar a mensagem de prompt e também para especificar os números de entrada. currentLine = len (In) -1% save -f my_session 1- $ currentLine

A -fopção é usada para forçar a substituição de arquivos e len(IN)-1mostra o prompt de entrada atual no IPython, permitindo salvar a sessão inteira programaticamente.

Para aqueles que usam spacemacs, e com o ipythonque vem python-layer, salvar mágica cria uma grande quantidade de resultados indesejados, devido ao comando constante de preenchimento automático que trabalha em segundo plano, como:

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)

Para evitar isso, salve o buffer do ipython como você normalmente salva: spc f s

Gostaria de sugerir outra maneira de manter a sessão python através do tmux no linux. você executa o tmux, conecte-se à sessão que você abriu (se não estiver conectado depois de abri-lo diretamente). execute python e faça o que estiver fazendo nele. depois desanexe da sessão. desanexar de uma sessão tmux não fecha a sessão. a sessão permanece aberta.

Prós deste método: você pode conectar-se a esta sessão a partir de qualquer outro dispositivo

contras deste método: esse método não renuncia aos recursos usados ​​pela sessão python aberta até que você realmente exista o interpretador python.

Para salvar entrada e saída no XUbuntu :

1. No XWindows, execute o iPython no aplicativo de terminal Xfce
2. clique Terminalna barra de menu superior e procure save contentsno menu suspenso

Acho que isso salva a entrada e a saída, desde a abertura do terminal. Isso não é específico do ipython e funcionaria com sessões ssh ou outras tarefas executadas a partir da janela do terminal.