Exécuter du code Python dans Vim

J'écris du code Python en utilisant Vim, et chaque fois que je veux exécuter mon code, je tape ceci dans Vim:

:w !python

Cela devient frustrant, alors je cherchais une méthode plus rapide pour exécuter du code Python dans Vim. Exécuter des scripts Python à partir d'un terminal peut-être? J'utilise Linux.

Que diriez-vous d'ajouter un autocmdà votre ~/.vimrc-file, en créant un mappage:

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>

alors vous pouvez appuyer sur <F9>pour exécuter le tampon actuel avecpython

Explication:

• autocmd: commande sur laquelle Vim s'exécutera automatiquement {event}(ici: si vous ouvrez un fichier python)
• [i]map: crée un raccourci clavier <F9>en mode insertion / normal
• <buffer>: Si plusieurs tampons / fichiers sont ouverts: utilisez simplement celui actif
• <esc>: quitter le mode insertion
• :w<CR>: enregistre votre fichier
• !: exécute la commande suivante dans votre shell (essayez :!ls)
• %: est remplacé par le nom de fichier de votre tampon actif. Mais comme il peut contenir des éléments comme des espaces et d'autres "mauvais" trucs, il vaut mieux ne pas écrire :python %, mais utiliser:
• shellescape: échapper aux caractères spéciaux. Les 1moyens avec une barre oblique inverse

TL; DR: La première ligne fonctionnera en mode normal et une fois que vous appuyez <F9>dessus, vous enregistrez d'abord votre fichier, puis exécutez le fichier avec python. Le second fait la même chose, mais laisse d'abord le mode insertion

Passez simplement en mode normal en appuyant sur <esc>et tapez:

! clear; python %

Explication étape par étape:

! vous permet d'exécuter une commande de terminal

clear va vider l'écran de votre terminal

; termine la première commande, vous permettant d'introduire une deuxième commande

pythonutilisera python pour exécuter votre script (il pourrait être remplacé par rubypar exemple)

%concate le nom de fichier actuel, en le passant en paramètre à la pythoncommande

J'ai ceci dans mon fichier .vimrc:

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

Lorsque j'ai fini de modifier un script Python, j'appuie simplement sur <F5>. Le script est enregistré puis exécuté dans un écran vide.

Je préfère la sortie Python redirigée vers une nouvelle fenêtre Vim (et si cette fenêtre est laissée ouverte, mettez à jour son contenu la prochaine fois que vous exécuterez du code Python avec cette fonction):

" 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

En vous basant sur les réponses précédentes, si vous aimez voir le code tout en regardant sa sortie, vous pourriez trouver la commande :ter( :terminal) utile.

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

En utilisant vert de la deuxième ligne exécute le code en division verticale au lieu d'horizontale.

Le point négatif est que si vous ne fermez pas la fenêtre fractionnée où le code a été exécuté, vous aurez beaucoup de fractionnements après plusieurs exécutions (ce qui ne se produit pas dans Python IDLE d'origine où la même fenêtre de sortie est réutilisée).

(Je garde ces lignes à l'intérieur /home/user/.vimrc)

Gardez à l'esprit que vous pouvez répéter la dernière commande utilisée avec @:, donc c'est tout ce que vous devez répéter sont ces deux caractères.

Ou vous pouvez enregistrer la chaîne w !pythondans l'un des registres (comme "apar exemple), puis appuyez sur :<C-R>a<CR>pour insérer le contenu du registrea dans la ligne de commande et l'exécuter.

Ou vous pouvez faire ce que je fais et carte <leader>zpour :!python %<CR>exécuter le fichier en cours.

Si vous ne voulez pas voir " :exec python file.py" imprimé à chaque fois, utilisez ceci:

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

Cela n'a pas non plus gâché ma barre d'état Powerline / Vim-Airlines.

Module d'extension : jupyter-vim

Vous pouvez donc envoyer des lignes ( <leader>E), une sélection visuelle ( <leader>e) à un courant jupyter-client(le remplacement de ipython)

Je préfère séparer l'éditeur et l'interpréteur (chacun dans sa coquille). Imaginez que vous envoyez une mauvaise commande de lecture d'entrée ...

Pour une utilisation générique (exécutez python / haskell / ruby ​​/ C ++ ... à partir de vim basé sur le filetype), il existe un joli plugin appelé vim-quickrun . Il prend en charge de nombreux langages de programmation par défaut. Il est également facilement configurable, donc on peut définir des comportements préférés pour n'importe quel type de fichier si nécessaire. Le repo github n'a pas de fichier readme sophistiqué, mais il est bien documenté avec le fichier doc.

La réponse acceptée fonctionne pour moi (sous Linux), mais je voulais que cette commande enregistre également le tampon avant de l'exécuter, alors je l'ai légèrement modifiée:

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

Le :w <bar>sauvegarde le tampon PUIS exécute le code qu'il contient.

Une méthode simple serait de taper :en mode normal, puis appuyez sur la touche fléchée vers le haut du clavier et appuyez sur Entrée. Cela répétera les dernières commandes tapées sur VIM.

Si vous voulez revenir rapidement à travers vos :wcommandes, une chose intéressante est de taper :wpuis d'appuyer sur la flèche vers le haut. Il ne parcourra que les commandes commençant par w.

J'ai ceci sur mon .vimrc:

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

qui sauvegarde le tampon courant et exécute le code en appuyant uniquement sur Esc + F9

Vous pouvez également utiliser skywind3000 / asyncrun.vim . C'est similaire à ce que @FocusedWolf a répertorié.

Vous pouvez étendre pour n'importe quelle langue avec 1 combinaison de touches avec la commande augroup, par exemple:

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

Pensez à utiliser la ligne shebang, vous pourrez donc l'utiliser avec toujours n'importe quel langage, pas seulement Python.

Ajout de shebang:

Ajoutez ceci à la première ligne de votre script:

#!/usr/bin/env python3

ou ceci, si vous utilisez Python 2:

#!/usr/bin/env python2

Keymap Vim:

Ajoutez ceci à votre ~/.vimrc:

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

Rendre le fichier exécutable:

Tapez Vim:

:!chmod +x %

ou dans le terminal:

chmod +x script_name.py

Explication:

Lorsque F7 est pressé en mode normal, Vim essaiera d'exécuter le fichier courant en tant que script bash. Ensuite, l'interpréteur bash verra la ligne shebang et comprendra que ce fichier doit être passé à Python (ou à tout autre programme si nécessaire).

Vous pourrez également exécuter votre script à partir du terminal en utilisant son nom:

./script_name.py

au lieu de cette façon (cela fonctionnera aussi):

python3 script_name.py

Ce mappage .vimrc nécessite Conque Shell , mais il réplique le comportement de Geany (et d'autres éditeurs X):

• Appuyez sur une touche pour exécuter
• S'exécute dans gnome-terminal
• Attend la confirmation pour quitter

• La fenêtre se ferme automatiquement à la sortie

  :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; \" "')

Placez votre curseur quelque part dans le code. Faites un clic droit et choisissez l'un des choix "Sélectionner" pour mettre en évidence votre code. Appuyez ensuite sur Ctrl: et vous verrez la nouvelle invite '<,>'

Maintenant, tapez! Python et voyez si cela fonctionne.

Je passe juste des jours à essayer de résoudre le même problème !!! J'ai utilisé le codage:

s='My name'
print (s) 

Après avoir tiré tous mes cheveux, j'ai enfin réussi!

Au lieu de mettre le mappage de commande dans votre .vimrc, placez le mappage dans votre ~/.vim/ftplugin/python.vimfichier (Windows $HOME\vimfiles\ftplugin\python.vim). Si vous n'avez pas ce fichier ou ces répertoires, créez-les simplement. De cette façon, la clé n'est mappée que lorsque vous ouvrez un .pyfichier ou tout autre fichier avec filetype=python, car vous n'exécuterez cette commande que sur des scripts Python.

Pour le mappage proprement dit, j'aime pouvoir éditer dans Vim pendant que le script s'exécute. En partant de la réponse de @cazyas, j'ai ce qui suit dans mon ftplugin\python.vim(Windows):

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

Cela exécutera le script Python actuel en arrière-plan. Pour Linux, changez-le simplement en ceci:

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>