从emacs运行交互式python脚本

Question

I am a fairly proficient vim user, but friends of mine told me so much good stuff about emacs that I decided to give it a try -- especially after finding about the aptly-named evil mode...

Anyways, I am currently working on a python script that requires user input (a subclass of cmd.Cmd). In vim, if I wanted to try it, I could simply do :!python % and then could interact with my script, until it quits. In emacs, I tried M-! python script.py M-! python script.py , which would indeed run the script in a separate buffer, but then RETURNs seems not to be sent back to the script, but are caught by the emacs buffer instead. I also tried to have a look at python-mode's Cc Cc , but this runs the script in some temporary directory, whereas I just want to run it in (pwd) .

So, is there any canonical way of doing that?

Answer 1

I don't know about canonical , but if I needed to interact with a script I'd do M - x shell RET and run the script from there.

There's also M - x terminal-emulator for more serious terminal emulation, not just shell stuff.

Answer 2

I like to use the Emacs "compile" command to test/run my python scripts. M - X compile RET will pull up the default "make -k" but if you delete that and put in the command line for your script (including options), subsequent "compiles" will provide the new "compile" command automatically. All the output from your script will appear in the compile buffer. (As opposed to the shell, this provides a nice clean buffer each time it is invoked. Good for searching and such. If you forget to save your script before your run, compile will ask you if you would like to save the file.)

You will lose your the command line when you restart Emacs. But you can get Emacs to set the compile-command for the buffer holding your script by putting at the bottom of the python script this sort of code (actually a python comment):

 # Trigger emacs to run this script using the "compile" command
 # ;;; Local Variables: ***
 # ;;; compile-command: "my_cool_script.py --complicated_option some_filename.txt" ***
 # ;;; end: ***

This is handy for scripts with complicated invocations. Note: The python comment character '#' protects this from the python interpreter while Emacs knows to set these variables because it looks at the bottom of every file when it opens them.

I'd love to be able to jump to 'compile errors' in my python script the way the compile command does when you use it for compiling C code but I'm too lazy to create the Emacs regular expression to make this work. Perhaps that would make another great question for stack overflow!

Answer 3

I currently use these hook to define my compilation commands:

(defun convert-filename-to-executable (file)
  (if (eq system-type 'windows-nt)
      (concat (file-name-sans-extension file) ".exe")
    ;; linux
    (concat "./" (file-name-sans-extension file))))


(add-hook 'c++-mode-hook
          (lambda ()
            (unless (file-exists-p "Makefile")
              (set (make-local-variable 'compile-command)
                   (let* ((file (file-name-nondirectory buffer-    file-name))
                      (executable (convert-filename-to-executable file)))
                 (concat "g++ -g -Wall -o "
                         (file-name-sans-extension file)
                         " "
                         file
                         " && "
                         executable))))))

(add-hook 'c-mode-hook
      (lambda ()
        (unless (file-exists-p "Makefile")
          (set (make-local-variable 'compile-command)
               (let* ((file (file-name-nondirectory buffer-file-name))
                      (executable (convert-filename-to-executable file)))
                 (concat "gcc -g -ansi -Wall -Wpedantic -Wextra -Wc++-compat -Wconversion -o "
                         (file-name-sans-extension file)
                         " "
                         file
                         " && "
                         executable))))))    
(add-hook 'python-mode-hook
          (lambda ()
              (set (make-local-variable 'compile-command)
                   (concat "python " buffer-file-name))))

(add-hook 'perl-mode-hook
          (lambda ()
              (set (make-local-variable 'compile-command)
                   (concat "python " buffer-file-name))))

Together with this lambda set to call the compile function interactively:

(global-set-key (kbd "<f4>") (lambda () (interactive) (setq current-prefix-arg '(4)) (call-interactively 'compile)))

One button to rule them all!

If you press F4 (in my case, you can set the key yourself in the lambda for global-set-key ), then a file opened in C++ or C mode will be compiled and a file in python or perl mode will be run (interactively)

Answer 4

The I think ansi-term has the most faithful emulation of a terminal. But I don't see a way to pass arguments to the process. You can of course just launch it from a shell inside the ansi-term buffer.

But I think the best thing to do is to not use python-send-buffer , but instead to use a new function which does it "right", that is by sending the path to the current file instead of making a temp file. There are some slight differences of course in that you have to save the current file first, but the following should at least get you on the right track.

(defun python-send-file ()
  (interactive)
  (save-buffer)
  (python-send-string (concat "execfile('" (buffer-file-name) "')")))

;; This overwrites the `python-send-buffer' binding so you may want to pick another key
(eval-after-load "python" 
  (define-key python-mode-map "\C-c\C-c" 'python-send-file))

I checked and this allows you to interact. To get tabs you have a few options.

• Cq TAB will always give you a literal tab

• You can rebind tab to be a literal tab in inferior-python-mode-map :

   (define-key inferior-python-mode-map "\\Ci" 'self-insert-command) 

• I'm sure there are others that I can't think of

Answer 5

If you use Cc Cc a buffer is created (look for inferior-python). Try changing to that buffer*, every time you hit Cc Cc the result is shown there, you need to see that buffer to get the results. Use Cx 2 so you can see both buffers at the same time. Also try Cc Cz (switch to shell).

*I use Ibuffer to manage buffers, is very good. (btw, this http://tuhdo.github.io/index.html is an excelent place to learn some emacs)

EDIT: Have you tried Cc Cp ?

Answer 6

Yet another option:

Using Cc Cc works nicely with fgallina's python.el -- pwd will be the location of the buffer's file.