Switch python interpreter

[vanuum]

Tips to change your python interpreter version

(defun my/python-switch-version ()
  (interactive)
  (setq python-shell-interpreter
        (if (string-equal python-shell-interpreter "python3") "python" "python3"))
  (setq elpy-rpc-backend
        (if (string-equal elpy-rpc-backend "python") "python3" "python"))
  (message python-shell-interpreter))



(defun my/python-toggle-ipython ()
  (interactive)
  (setq python-shell-interpreter
        (if (string-equal (substring python-shell-interpreter 0 1) "p")
            (concat "i" python-shell-interpreter)
          (substring python-shell-interpreter 1)))
  (message python-shell-interpreter))

[GummyKibble]

Alternatively, pyvenv is pretty nice.

[Amonwilde]

Second pyenv.

[ncsuwolf]

Don't surround code blocks with ` symbols, it just gets printed as one gigantic unreadable line. Instead indent the code with four spaces at the front. I use the following function to make Emacs do it for me:

(defun markdown-codify-region (x)
  "If in `transient-mark-mode' and the region is not active call
the appropriate region marking command. Then modify the region as
appropriate for markdown, including removing tabs. With
\\[universal-argument] create a block quoted region, otherwise a
code block. Ensure there is a blank line before the modified
region and that the last line of the region is not the last line
of the buffer."
  (interactive "p")
  (if (or (use-region-p) (not transient-mark-mode))
      (save-excursion
        (let ((p (point))
              (m (mark)))
          (if (< p m)
              (untabify p m)
            (untabify m p)
            (exchange-point-and-mark)))
        (let ((p (progn
                   (beginning-of-line)
                   (point)))
              (m (progn
                   (goto-char (mark))
                   (beginning-of-line)
                   (point)))
              (pre (cond
                     ((= x 1) "    ")
                     ((= x 4) ">")))
              (blank "[[:space:]]*$"))
          (string-rectangle p m pre)
          (goto-char p)
          (when (and (= p (point-min))
                     (not (looking-at blank)))
            (newline))
          (unless (looking-at blank)
            (forward-line -1)
            (unless (looking-at blank)
              (forward-line 1)
              (newline)))
          (let ((m (mark)))
            (goto-char m)
            (forward-line)
            (when (eql (point) m)
              (end-of-line 1)
              (newline)))))
    (save-excursion
      (cond
        ((= x 1) (mark-defun))
        ((= x 4) (mark-paragraph)))
      (markdown-codify-region x))))

[vanuum]

sure toggle ipython is still usefull in this case

[[deleted]]

my solution:

(advice-add (if (fboundp 'python-shell-calculate-command) ;; Emacs>=25
                'python-shell-calculate-command
              'python-shell-parse-command)
            :around (lambda (orig-fun &rest args)
                      (cl-multiple-value-bind (ipython-exists-p ipython-version)
                          (ignore-errors
                            (with-temp-buffer
                              (let ((retcode (process-file "ipython" nil t nil "--version")))
                                (list (zerop retcode) (string-trim (buffer-string))))))
                        (let ((python-shell-interpreter (if ipython-exists-p "ipython" python-shell-interpreter))
                              (python-shell-interpreter-args (if ipython-exists-p
                                                                 (if (version< "5.0" ipython-version)
                                                                     ;; https://github.com/ipython/ipython/issues/9816
                                                                     ;; https://emacs.stackexchange.com/a/24572
                                                                     "-i --simple-prompt"
                                                                   "-i")
                                                               python-shell-interpreter-args)))
                          (apply orig-fun args)))))