Not that it matters, but the result of this is a = b, and b = b

In [1]: def f():
   ...:     a = 1
   ...:     b = 2
   ...:     
   ...:     tmp = a
   ...:     a = b
   ...:     b = a
   ...: 

In [2]: def g():
   ...:     a = 1
   ...:     b = 2
   ...:     
   ...:     a, b = b, a
   ...: 

In [3]: %timeit f()
1000000 loops, best of 3: 568 ns per loop

In [4]: %timeit g()
1000000 loops, best of 3: 546 ns per loop

In [5]: %timeit f()
1000000 loops, best of 3: 591 ns per loop

In [6]: %timeit g()
1000000 loops, best of 3: 543 ns per loop

In [7]: %timeit f()
1000000 loops, best of 3: 588 ns per loop

In [8]: %timeit g()
1000000 loops, best of 3: 515 ns per loop

The reason is obvious when looking at the opcodes generated by the compiler (which is an optimization of the general system using tuple pack/unpack):

In [10]: dis.dis(f)
  2           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  3           6 LOAD_CONST               2 (2)
              9 STORE_FAST               1 (b)

  5          12 LOAD_FAST                0 (a)
             15 STORE_FAST               2 (tmp)

  6          18 LOAD_FAST                1 (b)
             21 STORE_FAST               0 (a)

  7          24 LOAD_FAST                0 (a)
             27 STORE_FAST               1 (b)
             30 LOAD_CONST               0 (None)
             33 RETURN_VALUE

In [11]: dis.dis(g)
  2           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  3           6 LOAD_CONST               2 (2)
              9 STORE_FAST               1 (b)

  5          12 LOAD_FAST                1 (b)
             15 LOAD_FAST                0 (a)
             18 ROT_TWO             
             19 STORE_FAST               0 (a)
             22 STORE_FAST               1 (b)
             25 LOAD_CONST               0 (None)
             28 RETURN_VALUE

The unoptimized case:

In [12]: def h():
   ....:     a, b, c, d = d, c, b, a
   ....: 

In [13]: dis.dis(h)
  2           0 LOAD_FAST                0 (d)
              3 LOAD_FAST                1 (c)
              6 LOAD_FAST                2 (b)
              9 LOAD_FAST                3 (a)
             12 BUILD_TUPLE              4
             15 UNPACK_SEQUENCE          4
             18 STORE_FAST               3 (a)
             21 STORE_FAST               2 (b)
             24 STORE_FAST               1 (c)
             27 STORE_FAST               0 (d)
             30 LOAD_CONST               0 (None)
             33 RETURN_VALUE

This isn’t to say that tuple unpacking isn’t useful — if you’ve already got a tuple and you want to assign its items to variables it is a very convenient language feature.

In a rather similar way, Python lets you compare more than two values at once, e.g. 1 < x < 100. Most other programming languages would require you to split that into multiple comparisons combined with boolean operators.