Python'da bir fonksiyonun iki argümanı nasıl aktarılır?

Python işlevine yapılan bir çağrıda iki bağımsız değişkeni nasıl değiştirebilirim?

pointBu iki argüman arasındaki boşluğu koyarsam :

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

ve sonra M-t( transpose-words), anladım:

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

Öte yandan CMt ( transpose-sexps) ile :

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

Ne istiyorum:

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

Bunu yapacak bir komut var mı?

Bu da uzun zamandır sahip olmak istediğim bir şey ve burada üzerinde çalışmak için biraz motivasyon buldum. Muhtemelen çok sağlam değil, ama ilk denemede denediğim vakaları kapsıyor gibi görünüyor:

(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))))

transpose-sexpsVirgüllerle ayrılmış şeyleri tanımladığınız ve aktardığınız veya düzenli olarak yaptığınız durumu arayan bir varyasyon kullanıyorum transpose-sexps. Ayrıca imleci ileri doğru sürüklemek yerine yerinde bırakır, ki bu biraz farklıdır ama ben şahsen seviyorum.

(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)))))

SMIE kullanan modlarda, transpose-sexpbu durumda doğru çalışmalıdır. Infix sembolü ("ayırıcı" olarak da bilinir) bir ,(veya a ;) değil, bir kelime (ör. and) Olduğunda yine de başarısız olurlar .

Yani, bence bunun için komut transpose-sexpve bu doğru çalışmadığında, bir hata olarak görüyorum (ancak zor ve / veya düzeltilmesi ve düşük önceliğe sahip olması gereken bir hata. t Nefesini tut). Bunu düzeltmenin yolu forward-sexp-function, "bir virgül gördükten sonra, tüm argümanın etrafından atladığımı" bilecek bir fonksiyona ayarlamaktır .