Wie transponiere ich zwei Argumente einer Funktion in Python?

Wie kann ich zwei Argumente in einem Aufruf einer Python-Funktion austauschen?

Wenn ich pointden Abstand zwischen diesen beiden Argumenten einstelle:

self.assertEqual(json.loads(some.data), json_data)

und dann M-t( transpose-words) bekomme ich:

self.assertEqual(json.loads(some.json), data_data)

Andererseits bekomme transpose-sexpsich mit CMt ( ):

self.assertEqual(json.loadsjson_data, (some.data))

Was ich will ist:

self.assertEqual(json_data, json.loads(some.data))

Gibt es einen Befehl, der das macht?

Auch das wollte ich schon lange haben, und hier habe ich eine gewisse Motivation gefunden, daran zu arbeiten. Es ist wahrscheinlich nicht sehr robust, aber beim ersten Versuch scheint es die Fälle abzudecken, die ich versucht habe:

(defun my/calculate-stops ()
  (save-excursion
    (let ((start
           (condition-case e
               (while t (backward-sexp))
             (error (point))))
          stops)
      (push start stops)
      (condition-case e
          (while t
            (forward-sexp)
            (when (looking-at "\\s-*,")
              (push (point) stops)))
        (error (push (point) stops)))
      (nreverse stops))))

(defun my/transpose-args ()
  (interactive)
  (when (looking-at "\\s-") (backward-sexp))
  (cl-loop with p = (point)
           with previous = nil
           for stop on (my/calculate-stops)
           for i upfrom 0
           when (<= p (car stop)) do
           (when previous
             (let* ((end (cadr stop))
                    (whole (buffer-substring previous end))
                    middle last)
               (delete-region previous end)
               (goto-char previous)
               (setf middle (if (> i 1) (- (car stop) previous)
                              (string-match "[^, \\t]" whole 
                                            (- (car stop) previous)))
                     last (if (> i 1) (substring whole 0 middle)
                            (concat (substring whole (- (car stop) previous) middle)
                                    (substring whole 0 (- (car stop) previous)))))
               (insert (substring whole middle) last)))
           (cl-return)
           end do (setf previous (car stop))))

Ich verwende eine Variation davon transpose-sexps, die nach dem Fall sucht, den Sie beschreiben, und transponiere Dinge, die durch Kommas getrennt sind, oder nur reguläre Dinge transpose-sexps. Außerdem bleibt der Cursor an Ort und Stelle, anstatt ihn nach vorne zu ziehen, was etwas anders ist, aber ich persönlich mag.

(defun my-transpose-sexps ()
  "If point is after certain chars transpose chunks around that.
Otherwise transpose sexps."
  (interactive "*")
  (if (not (looking-back "[,]\\s-*" (point-at-bol)))
      (progn (transpose-sexps 1) (forward-sexp -1))
    (let ((beg (point)) end rhs lhs)
      (while (and (not (eobp))
                  (not (looking-at "\\s-*\\([,]\\|\\s)\\)")))
        (forward-sexp 1))
      (setq rhs (buffer-substring beg (point)))
      (delete-region beg (point))
      (re-search-backward "[,]\\s-*" nil t)
      (setq beg (point))
      (while (and (not (bobp))
                  (not (looking-back "\\([,]\\|\\s(\\)\\s-*" (point-at-bol))))
        (forward-sexp -1))
      (setq lhs (buffer-substring beg (point)))
      (delete-region beg (point))
      (insert rhs)
      (re-search-forward "[,]\\s-*" nil t)
      (save-excursion
        (insert lhs)))))

In Modi, die SMIE verwenden, transpose-sexpsollte dies für diesen Fall korrekt funktionieren. Sie schlagen immer noch fehl, wenn das Infix-Symbol (auch als "Trennzeichen" bezeichnet) kein ,(oder ein ;), sondern ein Wort (z and. B. ) ist.

Ich bin der Meinung, dass der Befehl dafür lautet transpose-sexpund wenn dies nicht richtig funktioniert, betrachte ich ihn als Fehler (aber einen Fehler, der schwierig sein kann und / oder Zeit braucht, um ihn zu beheben und eine niedrige Priorität zu haben, also nicht ' nicht den Atem anhalten). Die Möglichkeit, dies zu beheben, besteht darin forward-sexp-function, eine Funktion festzulegen, die weiß, dass "nachdem ich ein Komma gesehen habe, springe ich einfach um das gesamte Argument herum".