I'm trying to run Python code for testing and debugging using Emacs. How should I debug and run code in *.py files ? I tried using the M-x compile commands . Using M-x compile, I get a compilation buffer that crashes (It says Python is compiling, but then nothing happens).
If you are using emacs24 this should be the default (in emacs23 you need python.el, not python-mode.el):
In a python buffer:
C-c C-z : open a python shell
C-c C-c : run the content of the buffer in the opened python shell
C-c C-r : run the selected region in the python shell
default python shell is "python", if you need to use ipython you can use this conf in your .emacs
(setq
python-shell-interpreter "ipython"
python-shell-interpreter-args "--colors=Linux --profile=default"
python-shell-prompt-regexp "In \\[[0-9]+\\]: "
python-shell-prompt-output-regexp "Out\\[[0-9]+\\]: "
python-shell-completion-setup-code
"from IPython.core.completerlib import module_completion"
python-shell-completion-module-string-code
"';'.join(module_completion('''%s'''))\n"
python-shell-completion-string-code
"';'.join(get_ipython().Completer.all_completions('''%s'''))\n")
provided that you have ipython installed in your system of course :)
ipython>=5 has a auto-complete feature which breaks the emacs sub-shell, you can fix this by changing this line
python-shell-interpreter-args "--colors=Linux --profile=default"
and add --simple-prompt.
It will allow you to see ipython correctly but for some reason I did not get yet the auto-completion in emacs is not as effective as it used to be.
How do you run Python code using Emacs?
I'm running Emacs 26, vanilla dev version (self compiled from source cloned from Savannah).
(Note that in emacs docs, we usually see, for example, Ctrl-c denoted as C-c)
In Python mode (which I usually enter by using C-x C-f to "find" a (possibly new) file ending in .py), you can start a Python shell with and then execute your buffer's
if __name__ == '__main__': with:
C-c C-p (which executes run-python to create a shell with Inferior Python major mode, Shell-Compile minor mode)
C-u C-c C-c (which executes python-shell-send-buffer with a prefix argument)
We require the prefix argument to send the if __name__ == '__main__': block to the inferior Python shell.
We can see all of the Ctrl-c commands with Ctrl-c ?
C-c C-c python-shell-send-buffer
C-c C-d python-describe-at-point
C-c C-f python-eldoc-at-point
C-c C-j imenu
C-c C-l python-shell-send-file
C-c C-p run-python
C-c C-r python-shell-send-region
C-c C-s python-shell-send-string
C-c C-t Prefix Command
C-c C-v python-check
C-c C-z python-shell-switch-to-shell
C-c < python-indent-shift-left
C-c > python-indent-shift-right
C-c C-t c python-skeleton-class
C-c C-t d python-skeleton-def
C-c C-t f python-skeleton-for
C-c C-t i python-skeleton-if
C-c C-t m python-skeleton-import
C-c C-t t python-skeleton-try
C-c C-t w python-skeleton-while
Inspecting the help for python-shell-send-buffer (by clicking it), we see:
python-shell-send-buffer is an interactive compiled Lisp function in
‘python.el’.
(python-shell-send-buffer &optional SEND-MAIN MSG)
Send the entire buffer to inferior Python process.
When optional argument SEND-MAIN is non-nil, allow execution of
code inside blocks delimited by "if __name__== '__main__':".
When called interactively SEND-MAIN defaults to nil, unless it’s
called with prefix argument. When optional argument MSG is
non-nil, forces display of a user-friendly message if there’s no
process running; defaults to t when called interactively.
According to the docs C-u is a prefix argument - and seems to be the most generic one.
A workaround that lets us avoid using the prefix argument C-u is using parentheses:
if (__name__ == '__main__'):
main()
instead of the usual:
if __name__ == '__main__':
main()
and then C-c C-c by itself executes the main function.
In my opinion, M-! and M-& are underrated. Often you just want to start the current script you are working on, no need to complicate things.
Of course, you can use M-x compile, as long as you don't have to provide interactive input. If you do have to provide interactive input, M-x shell is your friend.
If you want to run stuff with one button press, check out F3 and F4 to record a keyboard macro and replay it (the macro can also be bound to a key, e.g. F5).
In each of these cases, there is no "magic" taking place. Emacs does not know how to "compile" or "run" python scripts. You have to provide/overwrite a sensible command line invocation, like:
Compile Command: ipython <yourscriptname>.py
The python subshell is cool where a REPL development style makes sense, but at least on Windows matplotlib, tkinter and other libraries that have to deal with the Windows Message Loop tend to block/hang upon displaying GUI elements.
Once you open your python file in Emacs, you will need to start the python process with:
M-x run-python or C-c C-p, which creates an inferior python shell buffer. This buffer will be created by a horizontal split, and the active buffer will be the one containing the python file.
Then you can do C-c C-c, which will send the current python buffer to the inferior python shell below. This is where you will see the output of your python file.
To switch to and from your python file buffer and the inferior python shell buffer, you can do C-x o.
If you accidentally close one of the buffers, you can switch between buffers with C-x C-<left_arrow> and C-x C-<right_arrow> and perform operations on the python buffer like the ones mentioned by Aaron Hall.
NOTE:
Running GNU Emacs 26.2 without any extensions.
Did not define if (__name__ == '__main__'): block
Related
Long story short: pythonw.exe does nothing, python.exe accepts nothing (which one should I use?)
test.py:
print "a"
CMD window:
C:\path>pythonw.exe test.py
<BLANK LINE>
C:\path>
C:\path>python.exe test.py
File "C:\path\test.py", line 7
print "a"
^
SyntaxError: invalid syntax
C:\path>
Please tell me what I'm doing terrible wrong.
To summarize and complement the existing answers:
python.exe is a console (terminal) application for launching CLI-type scripts (console applications).
Unless run from an existing console window, python.exe opens a new console window.
Standard streams sys.stdin, sys.stdout and sys.stderr are connected to the console window.
Execution is synchronous when launched from a cmd.exe or PowerShell console window: See eryksun's 1st comment below.
If a new console window was created, it stays open until the script terminates.
When invoked from an existing console window, the prompt is blocked until the script terminates.
pythonw.exe is a GUI app for launching GUI/no-UI-at-all scripts.
NO console window is opened.
Execution is asynchronous:
When invoked from a console window, the script is merely launched and the prompt returns right away, whether the script is still running or not.
Standard streams sys.stdin, sys.stdout and sys.stderr are NOT available.
Caution: Unless you take extra steps, this has potentially unexpected side effects:
Unhandled exceptions cause the script to abort silently.
In Python 2.x, simply trying to use print() can cause that to happen (in 3.x, print() simply has no effect).
To prevent that from within your script, and to learn more, see this answer of mine.
Ad-hoc, you can use output redirection:Thanks, #handle.
pythonw.exe yourScript.pyw 1>stdout.txt 2>stderr.txt
(from PowerShell:
cmd /c pythonw.exe yourScript.pyw 1>stdout.txt 2>stderr.txt) to capture stdout and stderr output in files.
If you're confident that use of print() is the only reason your script fails silently with pythonw.exe, and you're not interested in stdout output, use #handle's command from the comments:
pythonw.exe yourScript.pyw 1>NUL 2>&1
Caveat: This output redirection technique does not work when invoking *.pyw scripts directly (as opposed to by passing the script file path to pythonw.exe). See eryksun's 2nd comment and its follow-ups below.
You can control which of the executables runs your script by default - such as when opened from Explorer - by choosing the right filename extension:
*.py files are by default associated (invoked) with python.exe
*.pyw files are by default associated (invoked) with pythonw.exe
If you don't want a terminal window to pop up when you run your program, use pythonw.exe;
Otherwise, use python.exe
Regarding the syntax error: print is now a function in 3.x
So use instead:
print("a")
See here: http://docs.python.org/using/windows.html
pythonw.exe "This suppresses the terminal window on startup."
If you're going to call a python script from some other process (say, from the command line), use pythonw.exe. Otherwise, your user will continuously see a cmd window launching the python process. It'll still run your script just the same, but it won't intrude on the user experience.
An example might be sending an email; python.exe will pop up a CLI window, send the email, then close the window. It'll appear as a quick flash, and can be considered somewhat annoying. pythonw.exe avoids this, but still sends the email.
I was struggling to get this to work for a while. Once you change the extension to .pyw, make sure that you open properties of the file and direct the "open with" path to pythonw.exe.
In my experience the pythonw.exe is faster at least with using pygame.
I'm new to Emacs and I'm trying to set up my python environment. So far I've learned that using "python-mode.el" in a python buffer C-c C-c loads the contents of the current buffer into an interactive python shell, apparently using what which python yields. In my case that is python 3.3.3. But since I need to get a python 2.7 shell, I'm trying to get Emacs to spawn such a shell on C-c C-c. Unfortunatly I can't figure out, how to do this. Setting py-shell-name to what which python2.7 yields (i.e. /usr/bin/python2.7) does not work. How can get Emacs to do this, or how can I trace back what Emacs executes when I hit C-c C-c?
python-mode.el, execute a python buffer using python2:
M-x py-execute-buffer-python2
or put this in .emacs file:
(custom-set-variables
'(py-force-py-shell-name-p t)
'(py-shell-name "python2"))
python-mode.el checks py-force-py-shell-name-p variable when executing py-execute-buffer(bound to C-c C-c key), and if this variable is set to true("t"), then use python interpreter name saved in py-shell-name.
Alternatively, this customization can be done in M-x customize, Programming>Languages>Python Mode, search there for "Py Force Py Shell" and "Py Shell Name" lines.
It will add this customization code to your .emacs file.
Emacs help(describe function):
C-h f py-execute-buffer TAB
You can send selected region in a python buffer to any interpreter:
C-u 3 M-x py-execute-region
Emacs will prompt every time for a python interpreter name you want to use.
The prefix numerical argument may be any number except 1 or 4, otherwise it will use a default interpreter without prompt.
To execute a buffer in different python interpreters you can select whole buffer by C-x h and then use this prefixed command.
I don't use python, but from the source to python-mode, I think you should look into customizing the variable python-python-command - It seems to default to the first path command matching "python"; perhaps you can supply it with a custom path?
When I run C-c C-c on a .py file, Aquamacs returns
Output file descriptor of python3 is closed
On the other hand, the Python shell works just fine.
How can I fix it such that I can run Python files?
It seems Aquamacs' default Python interpreter is pyhton.el and not python-mode.el .
Installing python-mode.el from here will do the trick.
Say I open a terminal emulator in Emacs with M-x ansi-term. This opens a buffer in Emacs with the shell of my choice. Say I then run ipython from this shell. Can I send code to this ipython session from another buffer with Python code in Emacs? If so how?
I have a minor mode for this purpose (except it is not IPython-specific and I mostly use it for shell scripts): isend-mode.
Here is how you would use it:
Open an ansi-term buffer:
M-xansi-termRET/usr/bin/ipythonRET
Open the buffer with the code you want to execute, and associate it to the interpreter buffer:
M-xisend-associateRET*ansi-term*RET
Hit C-RET in the python buffer to send the current line to the interpreter in the ansi-term buffer.
(defun send-buffer-to-ipython ()
"Send current buffer to the running ipython process."
(interactive)
(let* ((ipython-buffer "*ansi-term*") ; the buffer name of your running terminal
(proc (get-buffer-process ipython-buffer)))
(unless proc
(error "no process found"))
(save-buffer)
(process-send-string proc
(format "execfile(\"%s\")\n" (buffer-file-name)))
(pop-to-buffer ipython-buffer) ; show ipython and select it
;; (display-buffer ipython-buffer) ; show ipython but don't select it
))
Then bind command send-buffer-to-ipython to any key you like. I bind it to C-c C-c
(define-key python-mode-map [?\C-c ?\C-c] 'send-buffer-to-ipython)
with python-mode.el
M-x customize-variable RET py-shell-name RET ansi-term
M-x ansi-term RET ipython RET
C-c C-c from Python-buffer than executes in IPython shell
Caveat: a shebang precedes default py-shell-name
https://launchpad.net/python-mode/trunk/6.0.12/+download/python-mode.el-6.0.12.tar.gz
How do I debug python programs in emacs? I'm using python-mode.el
I've found references suggesting:
import pdb; pdb.set_trace();
but I'm not sure how to use it.
Type M-x cd to change directory to the location of the program you wish to debug.
Type M-x pdb. You'll be prompted with Run pdb (like this): pdb. Enter the name of the program (e.g. test.py).
At the (Pdb) prompt, type help to learn about how to use pdb.
Alternatively, you can put
import pdb
pdb.set_trace()
right inside your program (e.g. test.py). Now type M-x shell to get a shell prompt. When you run your program, you'll be dumped into pdb at the point where pdb.set_trace() is executed.
For me, I needed to replace the default "pdb" with
python -m pdb myscript.py
The realgud package (available from MELPA) supports PDB (among a gazillion other debuggers), and has a host of neat features that Emac's PDB doesn't have.
The one I like best is the shortkeys mode. Once you start debugging a program, you can press n, s, c etc. right in the source window, instead of having to type these commands in the PDB buffer. It also supports Visual-Studio style keybindings with function keys (f10, f11, f5, etc).
After installing RealGUD, you need to run M-x load-feature realgud to load it, and you can start pdb with M-x realgud:pdb.