Uruchamianie kodu Pythona w Vimie

Po prostu przejdź do trybu normalnego, naciskając <esc> i wpisz:

! clear; python %

Wyjaśnienie krok po kroku:

! pozwala na uruchomienie polecenia terminal

clear opróżni ekran terminala

; kończy pierwszą komendę, pozwalając na wprowadzenie drugiej komendy

python użyje Pythona do uruchomienia skryptu (można go zastąpić ruby na przykład)

% concats the current nazwę pliku, przekazując go jako parametr do python Komenda

Mam to w swoim .plik vimrc:

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

Kiedy skończę edytować skrypt Pythona, po prostu naciskam <F5>. Skrypt jest zapisywany, a następnie wykonywany na pustym ekranie.

Preferuję wyjście Pythona przekierowane do nowego okna Vima (i jeśli to okno zostanie otwarte, zaktualizuj jego zawartość następnym razem, gdy wykonasz Kod Pythona z tą funkcją):

" 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

Bazując na poprzednich odpowiedziach, jeśli chcesz zobaczyć kod, patrząc na jego wyjście, możesz znaleźć :ter (:terminal) polecenie użyteczne.

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

Użycie vert w drugiej linii uruchamia kod w pionie zamiast w poziomie.

Minusem jest to, że jeśli nie zamkniesz okna dzielonego, w którym działał kod, będziesz miał wiele podziałów po wielu uruchomieniach (co nie dzieje się w oryginalnym Pythonie bezczynności, gdzie to samo okno wyjściowe jest ponownie używane).

(trzymam te lines inside /home/user/.vimrc)

Pamiętaj, że możesz powtórzyć ostatnio użyte polecenie z @:, więc wystarczy, że powtórzysz te dwa znaki.

Lub możesz zapisać łańcuch w !python w jednym z rejestrów (na przykład "a), a następnie nacisnąć :<C-R>a<CR>, aby wstawić zawartość rejestru a do linii poleceń i uruchomić go.

Lub możesz zrobić to, co ja i mapować <leader>z na :!python %<CR>, aby uruchomić bieżący plik.

Plugin: jupyter-vim

Więc możesz wysyłać linie (<leader>E), selekcję wizualną (<leader>e) do running jupyter-client (zamiennik ipython)

Wolę oddzielić edytor i interpreter (każdy w swojej powłoce). Wyobraź sobie, że wysyłasz złe polecenie odczytu danych wejściowych ...

Jeśli nie chcesz za każdym razem wyświetlać ":exec python file.py", Użyj tego:

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

Do użytku ogólnego (Uruchom python / haskell / ruby / C++... od Vima opartego na filetype), jest ładny plugin o nazwie vim-quickrun . Domyślnie obsługuje wiele języków programowania. Jest również łatwo konfigurowalny, więc w razie potrzeby można zdefiniować preferowane zachowania dla dowolnego typu plików. Repozytorium github nie ma wyszukanego readme, ale jest dobrze udokumentowane za pomocą pliku doc.

Zaakceptowana odpowiedź działa dla mnie (na Linuksie), ale chciałem, aby ta komenda również zapisała bufor przed uruchomieniem, więc lekko ją zmodyfikowałem:

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

:w <bar> zapisuje bufor, a następnie uruchamia w nim kod.

Pomyśl o używaniu shebang line, więc będziesz mógł go używać z dowolnym językiem, nie tylko Pythonem.

Dodanie:

Dodaj to do pierwszej linijki skryptu:

#!/usr/bin/env python3

Lub to, jeśli używasz Pythona 2:

#!/usr/bin/env python2

Vim keymap:

Dodaj to do swojego ~/.vimrc:

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

Utwórz plik wykonywalny:

Wpisz Vim:

:!chmod +x %

Lub w terminal:

chmod +x script_name.py

Explanation:

Gdy F7 zostanie naciśnięte w trybie normalnym, Vim spróbuje wykonać bieżący plik jako skrypt bash. Wtedy interpreter bash zobaczy linię shebang i zrozumie, że ten plik powinien zostać przekazany do Pythona (lub dowolnego innego programu, jeśli zajdzie taka potrzeba).

Będziesz także mógł uruchomić skrypt z terminala używając jego nazwy:

./script_name.py

Zamiast w ten sposób (to też zadziała):

python3 script_name.py

Używam

:! [filename.py]; python %

That ' s what works for me

Prostą metodą byłoby wpisanie : w trybie normalnym, a następnie naciśnięcie klawisza strzałki w górę na klawiaturze i naciśnięcie klawisza Enter. Spowoduje to powtórzenie ostatnich wpisanych poleceń w Vimie.

Jeśli chcesz szybko przejść z powrotem przez polecenia :w, fajną rzeczą jest wpisanie :w, a następnie naciśnięcie strzałki w górę. Będzie przełączać się tylko przez polecenia zaczynające się od w.

Mam to na sobie .vimrc:

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

Który zapisuje bieżący bufor i wykonuje kod z naciśnięciem tylko Esc + F9

Możesz użyć skywind3000 / asyncrun.vim również. Jest to podobne do tego, co wymienił @FocusedWolf.

Możesz rozszerzyć dla dowolnego języka z 1 klawiszami używając polecenia augroup, na przykład:

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

To .vimrc mapping needs Conque Shell , but it replicates Geany (and other x editors') behavior:

• naciśnij klawisz, aby wykonać
• wykonuje w gnome-terminal
• czeka na potwierdzenie wyjścia

• Okno zamyka się automatycznie przy wyjściu

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

Umieść kursor gdzieś w kodzie. Kliknij prawym przyciskiem myszy i wybierz jedną z opcji "Wybierz", aby podświetlić swój kod. Następnie naciśnij Ctrl : i zobaczysz nowy znak zachęty' '

s='My name'
print (s) 

Po tym, jak wyciągnęłam wszystkie włosy, w końcu się udało!

Zamiast umieszczać polecenie mapping w .vimrc, Umieść mapowanie w pliku ~/.vim/ftplugin/python.vim (Windows $HOME\vimfiles\ftplugin\python.vim). Jeśli nie masz tego pliku lub katalogów, po prostu je stwórz. W ten sposób klucz jest mapowany tylko wtedy, gdy otworzysz plik .py lub dowolny plik z filetype=python, ponieważ będziesz uruchamiał to polecenie tylko na skryptach Pythona.

Dla rzeczywistego mapowania, Lubię móc edytować w Vimie podczas uruchamiania skryptu. Wychodząc z odpowiedzi @cazyas, w moim ftplugin\python.vim (Windows):

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

Spowoduje uruchomienie bieżącego skryptu Pythona w tle. Dla Linuksa po prostu zmień to na to:

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>

1. przejdź do katalogu domowego. cd
Otwórz swoje .plik vimrc z vim. vim .vimrc
2. Dodaj następny kod do pliku. nmap <F4> <Esc>:w<CR>:!clear;python %<CR>
3. zapisz to i zakończ. ZZ

Następnym razem, gdy chcesz uruchomić kod, po prostu naciśnij F4 w "trybie normalnym". Jeśli chcesz uruchomić kod w "trybie wstawiania", zamień nmap na imap.