Ejecutando código Python en Vim

Estoy escribiendo código Python usando Vim, y cada vez que quiero ejecutar mi código, escribo esto dentro de Vim:

:w !python

Esto se vuelve frustrante, así que estaba buscando un método más rápido para ejecutar código Python dentro de Vim. ¿Ejecutar scripts de Python desde una terminal, tal vez? Estoy usando Linux.

¿Qué tal agregar un archivo autocmda su ~/.vimrc-file, crear un mapeo:

autocmd FileType python map <buffer> <F9> :w<CR>:exec '!python3' shellescape(@%, 1)<CR>
autocmd FileType python imap <buffer> <F9> <esc>:w<CR>:exec '!python3' shellescape(@%, 1)<CR>

entonces puede presionar <F9>para ejecutar el búfer actual conpython

Explicación:

• autocmd: comando que Vim ejecutará automáticamente {event}(aquí: si abre un archivo python)
• [i]map: crea un atajo de teclado <F9>en modo insertar / normal
• <buffer>: Si hay varios búferes / archivos abiertos: solo use el activo
• <esc>: salir del modo de inserción
• :w<CR>: guarda su archivo
• !: ejecuta el siguiente comando en tu shell (prueba :!ls)
• %: se reemplaza por el nombre de archivo de su búfer activo. Pero dado que puede contener cosas como espacios en blanco y otras cosas "malas", es mejor practicar no escribir :python %, sino usar:
• shellescape: escapar de los caracteres especiales. Los 1medios con una barra invertida

TL; DR: La primera línea funcionará en modo normal y, una vez que la presione <F9>, primero guardará su archivo y luego ejecutará el archivo con python. El segundo hace lo mismo, pero primero deja el modo de inserción

Simplemente vaya al modo normal presionando <esc>y escriba:

! clear; python %

Explicación paso a paso:

! le permite ejecutar un comando de terminal

clear Vaciará la pantalla de su terminal

; finaliza el primer comando, lo que le permite introducir un segundo comando

pythonusará Python para ejecutar su script (podría ser reemplazado por, rubypor ejemplo)

%concate el nombre del archivo actual, pasándolo como parámetro al pythoncomando

Tengo esto en mi archivo .vimrc:

imap <F5> <Esc>:w<CR>:!clear;python %<CR>

Cuando termino de editar un script de Python, simplemente presiono <F5>. El script se guarda y luego se ejecuta en una pantalla en blanco.

Prefiero la salida de Python redirigida a una nueva ventana de Vim (y si esa ventana se deja abierta, actualice su contenido la próxima vez que ejecute código Python con esta función):

" Bind F5 to save file if modified and execute python script in a buffer.
nnoremap <silent> <F5> :call SaveAndExecutePython()<CR>
vnoremap <silent> <F5> :<C-u>call SaveAndExecutePython()<CR>

function! SaveAndExecutePython()
    " SOURCE [reusable window]: https://github.com/fatih/vim-go/blob/master/autoload/go/ui.vim

    " save and reload current file
    silent execute "update | edit"

    " get file path of current file
    let s:current_buffer_file_path = expand("%")

    let s:output_buffer_name = "Python"
    let s:output_buffer_filetype = "output"

    " reuse existing buffer window if it exists otherwise create a new one
    if !exists("s:buf_nr") || !bufexists(s:buf_nr)
        silent execute 'botright new ' . s:output_buffer_name
        let s:buf_nr = bufnr('%')
    elseif bufwinnr(s:buf_nr) == -1
        silent execute 'botright new'
        silent execute s:buf_nr . 'buffer'
    elseif bufwinnr(s:buf_nr) != bufwinnr('%')
        silent execute bufwinnr(s:buf_nr) . 'wincmd w'
    endif

    silent execute "setlocal filetype=" . s:output_buffer_filetype
    setlocal bufhidden=delete
    setlocal buftype=nofile
    setlocal noswapfile
    setlocal nobuflisted
    setlocal winfixheight
    setlocal cursorline " make it easy to distinguish
    setlocal nonumber
    setlocal norelativenumber
    setlocal showbreak=""

    " clear the buffer
    setlocal noreadonly
    setlocal modifiable
    %delete _

    " add the console output
    silent execute ".!python " . shellescape(s:current_buffer_file_path, 1)

    " resize window to content length
    " Note: This is annoying because if you print a lot of lines then your code buffer is forced to a height of one line every time you run this function.
    "       However without this line the buffer starts off as a default size and if you resize the buffer then it keeps that custom size after repeated runs of this function.
    "       But if you close the output buffer then it returns to using the default size when its recreated
    "execute 'resize' . line('$')

    " make the buffer non modifiable
    setlocal readonly
    setlocal nomodifiable
endfunction

Sobre la base de las respuestas anteriores, si desea ver el código mientras mira su salida, puede encontrar útil el comando :ter( :terminal).

autocmd Filetype python nnoremap <buffer> <F5> :w<CR>:ter python2 "%"<CR>
autocmd Filetype python nnoremap <buffer> <F6> :w<CR>:vert ter python3 "%"<CR>

El uso verten la segunda línea ejecuta el código en división vertical en lugar de horizontal.

Lo negativo de esto es que si no cierra la ventana dividida donde se ejecutó el código, tendrá muchas divisiones después de múltiples ejecuciones (lo que no sucede en Python IDLE original donde se reutiliza la misma ventana de salida).

(Guardo estas líneas adentro /home/user/.vimrc)

Tenga en cuenta que puede repetir el último comando utilizado con @:, por lo que eso es todo lo que necesita repetir son esos dos caracteres.

O puede guardar la cadena w !pythonen uno de los registros (como "apor ejemplo) y luego presionar :<C-R>a<CR>para insertar el contenido del registro aen la línea de comandos y ejecutarlo.

O bien, puede hacer lo que hago y mapa <leader>zde :!python %<CR>ejecutar el archivo actual.

Si no desea ver " :exec python file.py" impreso cada vez, use esto:

nnoremap <F9> :echo system('python2 "' . expand('%') . '"')<cr>
nnoremap <F10> :echo system('python3 "' . expand('%') . '"')<cr>

Tampoco estropeó mi barra de estado de línea eléctrica / vim-aerolínea.

Complemento : jupyter-vim

Entonces puede enviar líneas ( <leader>E), selección visual ( <leader>e) a una ejecución jupyter-client(el reemplazo de ipython)

Prefiero separar editor e intérprete (cada uno en su caparazón). Imagina que envías un comando de lectura de entrada incorrecta ...

Para uso genérico (ejecute python / haskell / ruby ​​/ C ++ ... desde vim basado en filetype), hay un buen complemento llamado vim-quickrun . Admite muchos lenguajes de programación de forma predeterminada. También es fácilmente configurable, por lo que se pueden definir comportamientos preferidos para cualquier tipo de archivo si es necesario. El repositorio de github no tiene un archivo Léame elegante, pero está bien documentado con el archivo doc.

La respuesta aceptada funciona para mí (en Linux), pero quería que este comando también guardara el búfer antes de ejecutarlo, así que lo modifiqué ligeramente:

nnoremap <buffer> <F9> :w <bar> :exec '!python' shellescape(@%, 1)<cr>

El :w <bar>guarda el búfer ENTONCES ejecuta el código en él.

Un método simple sería escribir :en modo normal y luego presionar la tecla de flecha hacia arriba en el teclado y presionar Enter. Esto repetirá los últimos comandos escritos en VIM.

Si desea retroceder rápidamente a través de sus :wcomandos, lo bueno es escribir:w y luego presionar la flecha hacia arriba. Solo recorrerá los comandos que comiencen con w.

Tengo esto en mi .vimrc:

"map <F9> :w<CR>:!python %<CR>"

que guarda el búfer actual y ejecuta el código presionando solo Esc + F9

También puede utilizar skywind3000 / asyncrun.vim . Es similar a lo que ha enumerado @FocusedWolf.

Puede extender para cualquier idioma con 1 combinación de teclas con el comando augroup, por ejemplo:

augroup rungroup
    autocmd!
    autocmd BufRead,BufNewFile *.go nnoremap <F5> :exec '!go run' shellescape(@%, 1)<cr>
    autocmd BufRead,BufNewFile *.py nnoremap <F5> :exec '!python' shellescape(@%, 1)<cr>
augroup END

Piense en usar shebang line, por lo que podrá usarlo con cualquier lenguaje, no solo Python.

Añadiendo shebang:

Agregue esto a la primera línea de su script:

#!/usr/bin/env python3

o esto, si está usando Python 2:

#!/usr/bin/env python2

Mapa de teclas de Vim:

Agregue esto a su ~/.vimrc:

nmap <F7> :w<cr>:!clear;"%:p"<cr>

Hacer ejecutable el archivo:

Escriba Vim:

:!chmod +x %

o en terminal:

chmod +x script_name.py

Explicación:

Cuando se presiona F7 en modo normal, Vim intentará ejecutar el archivo actual como script bash. Luego, el intérprete de bash verá la línea shebang y comprenderá que este archivo debe pasarse a Python (o cualquier otro programa si es necesario).

También podrá ejecutar su script desde la terminal usando su nombre:

./script_name.py

en lugar de de esta manera (eso también funcionará):

python3 script_name.py

Este mapeo .vimrc necesita Conque Shell , pero replica el comportamiento de Geany (y otros editores X):

• Presione una tecla para ejecutar
• Ejecuta en gnome-terminal
• Espera confirmación para salir

• La ventana se cierra automáticamente al salir

  :let dummy = conque_term#subprocess('gnome-terminal -e "bash -c \"python ' . expand("%") . '; answer=\\\"z\\\"; while [ $answer != \\\"q\\\" ]; do printf \\\"\nexited with code $?, press (q) to quit: \\\"; read -n 1 answer; done; \" "')

Pon tu cursor en el código en alguna parte. Haga clic derecho y elija una de las opciones "Seleccionar" para resaltar su código. Luego presione Ctrl: y verá el nuevo mensaje '<,>'

Ahora escriba! Python y vea si funciona.

¡¡¡Solo paso días tratando de resolver el mismo problema !!! Usé la codificación:

s='My name'
print (s) 

Después de que me arranqué todo el cabello, ¡finalmente lo hice bien!

En lugar de poner el mapeo de comandos en su .vimrc, ponga el mapeo en su ~/.vim/ftplugin/python.vimarchivo (Windows $HOME\vimfiles\ftplugin\python.vim). Si no tiene este archivo o directorios, simplemente hágalos. De esta manera, la clave solo se asigna cuando abre un .pyarchivo o cualquier archivo con filetype=python, ya que solo ejecutará este comando en scripts de Python.

Para el mapeo real, me gusta poder editar en Vim mientras se ejecuta el script. Saliendo de la respuesta de @cazyas, tengo lo siguiente en mi ftplugin\python.vim(Windows):

noremap <F5> <Esc>:w<CR>:!START /B python %<CR>

Esto ejecutará el script Python actual en segundo plano. Para Linux, simplemente cámbielo a esto:

noremap <F5> <Esc>:w<CR>:!python % &<CR>

" run current python file to new buffer
function! RunPython()
    let s:current_file = expand("%")
    enew|silent execute ".!python " . shellescape(s:current_file, 1)
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
    setlocal nobuflisted
endfunction
autocmd FileType python nnoremap <Leader>c :call RunPython()<CR>