I recently started using spacemacs, and have a newbie question about modifying the way run-python works.

When I execute run-python, a new buffer is opened in a different window. I'd like to change it so that it opens the newly created buffer in the current window.

Using find-function I found the source for run-python:

(defun run-python (&optional cmd dedicated show)
  "Run an inferior Python process.

Argument CMD defaults to `python-shell-calculate-command' return
value.  When called interactively with `prefix-arg', it allows
the user to edit such value and choose whether the interpreter
should be DEDICATED for the current buffer.  When numeric prefix
arg is other than 0 or 4 do not SHOW.

For a given buffer and same values of DEDICATED, if a process is
already running for it, it will do nothing.  This means that if
the current buffer is using a global process, the user is still
able to switch it to use a dedicated one.

Runs the hook `inferior-python-mode-hook' after
`comint-mode-hook' is run.  (Type \\[describe-mode] in the
process buffer for a list of commands.)"
   (if current-prefix-arg
        (read-shell-command "Run Python: " (python-shell-calculate-command))
        (y-or-n-p "Make dedicated process? ")
        (= (prefix-numeric-value current-prefix-arg) 4))
     (list (python-shell-calculate-command) nil t)))
    (or cmd (python-shell-calculate-command))
    (python-shell-get-process-name dedicated) show)))

and the source for python-shell-make-comint

(defun python-shell-make-comint (cmd proc-name &optional show internal)
  "Create a Python shell comint buffer.
CMD is the Python command to be executed and PROC-NAME is the
process name the comint buffer will get.  After the comint buffer
is created the `inferior-python-mode' is activated.  When
optional argument SHOW is non-nil the buffer is shown.  When
optional argument INTERNAL is non-nil this process is run on a
buffer with a name that starts with a space, following the Emacs
convention for temporary/internal buffers, and also makes sure
the user is not queried for confirmation when the process is
      (let* ((proc-buffer-name
              (format (if (not internal) "*%s*" " *%s*") proc-name)))
        (when (not (comint-check-proc proc-buffer-name))
          (let* ((cmdlist (split-string-and-unquote cmd))
                 (interpreter (car cmdlist))
                 (args (cdr cmdlist))
                 (buffer (apply #'make-comint-in-buffer proc-name proc-buffer-name
                                interpreter nil args))
                 (python-shell--parent-buffer (current-buffer))
                 (process (get-buffer-process buffer))
                 ;; Users can override the interpreter and args
                 ;; interactively when calling `run-python', let-binding
                 ;; these allows having the new right values in all
                 ;; setup code that is done in `inferior-python-mode',
                 ;; which is important, especially for prompt detection.
                 (python-shell--interpreter interpreter)
                  (mapconcat #'identity args " ")))
            (with-current-buffer buffer
            (when show (display-buffer buffer))
            (and internal (set-process-query-on-exit-flag process nil))))

Based on the following snippets of documentation taken from the definition of display-buffer

"Optional argument ACTION, if non-nil, should specify a buffer
display action of the form (FUNCTIONS . ALIST).  FUNCTIONS is
either an \"action function\" or a possibly empty list of action
functions.  ALIST is a possibly empty \"action alist\"."

"Action functions and the action they try to perform are:
 `display-buffer-same-window' -- Use the selected window."

I thought by changing the line (when show (display-buffer buffer)) to (when show (display-buffer buffer (cons '(display-buffer-same-window) '()))) I could get the behavior I wanted, but it didn't seem to have any effect.


  1. Is my understanding of how the code works incorrect? If so, how?
  2. Is modifying and saving the buffer sufficient to change the behavior of the run-python command?
  3. Is there a simpler way to do this?
  • For 2., the answer is "no", unless you kill and restart Emacs. To have the modified code take effect in the same session (i.e. without killing/restarting), you either need to reevaluate the function or load the .el file or byte-compile the .el file and load the .elc file. Emacs needs to have the new function in its memory.
    – NickD
    Apr 26, 2023 at 7:52

1 Answer 1


This should do it:

(add-to-list 'display-buffer-alist 
'("^\\*Python\\*$" . (display-buffer-same-window)))

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.