# Multiple assignment and evaluation order in Python

Posted on

Solving problem is about exposing yourself to as many situations as possible like Multiple assignment and evaluation order in Python and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.
In this post, my aim is to share an overview the topic about Multiple assignment and evaluation order in Python, which can be followed any time. Take easy to follow this discuss.

Multiple assignment and evaluation order in Python

What is the difference between the following Python expressions:

``````# First:
x,y = y,x+y
# Second:
x = y
y = x+y
``````

First gives different results than Second.

e.g.,

First:

``````>>> x = 1
>>> y = 2
>>> x,y = y,x+y
>>> x
2
>>> y
3
``````

Second:

``````>>> x = 1
>>> y = 2
>>> x = y
>>> y = x+y
>>> x
2
>>> y
4
``````

y is 3 in First and 4 in Second

In an assignment statement, the right-hand side is always evaluated fully before doing the actual setting of variables. So,

``````x, y = y, x + y
``````

evaluates `y` (let’s call the result `ham`), evaluates `x + y` (call that `spam`), then sets `x` to `ham` and `y` to `spam`. I.e., it’s like

``````ham = y
spam = x + y
x = ham
y = spam
``````

By contrast,

``````x = y
y = x + y
``````

sets `x` to `y`, then sets `y` to `x` (which `== y`) plus `y`, so it’s equivalent to

``````x = y
y = y + y
``````

It is explained in the docs in the section entitled “Evaluation order”:

… while evaluating an assignment, the right-hand side is evaluated
before the left-hand side.

The first expression:

1. Creates a temporary tuple with value `y,x+y`
2. Assigned in to another temporary tuple
3. Extract the tuple to variables `x` and `y`

The second statement is actually two expressions, without the tuple usage.

The surprise is, the first expression is actually:

``````temp=x
x=y
y=temp+y
``````

An observation regarding the left-hand side as well: the order of assignments is guaranteed to be the order of their appearance, in other words:

``````a, b = c, d
``````

is equivalent functionally to precisely (besides t creation):

``````t = (c, d)
a = t[0] # done before 'b' assignment
b = t[1] # done after 'a' assignment
``````

This matters in cases like object attribute assignment, e.g.:

``````class dummy:
def __init__(self): self.x = 0
a = dummy(); a_save = a
a.x, a = 5, dummy()
print(a_save.x, a.x) # prints "5 0" because above is equivalent to "a = dummy(); a_save = a; t = (5, dummy()); a.x = t[0]; a = t[1]"
a = dummy(); a_save = a
a, a.x = dummy(), 5
print(a_save.x, a.x) # prints "0 5" because above is equivalent to "a = dummy(); a_save = a; t = (dummy(), 5); a = t[0]; a.x = t[1]"
``````

This also implies that you can do things like object creation and access using one-liners, e.g.:

``````class dummy:
def __init__(self): self.x = 0
# Create a = dummy() and assign 5 to a.x
a, a.x = dummy(), 5
``````

In the second case, you assign `x+y` to `x`

In the first case, the second result (`x+y`) is assigned to `y`

This is why you obtain different results.

This happen because, in the statement

``````x,y = y,x+y
``````

all variables at the right member are evaluated and, then, are stored in the left members. So first proceed with right member, and second with the left member.

In the second statement

``````x = y
y = x + y
``````

yo first evaluated `y` and assign it to `x`; in that way, the sum of `x+y` is equivalent to a sum of `y+y` and not of `x+x` wich is the first case.

The first one is a tuple-like assignment:

``````x,y = y,x+y
``````

Where `x` is the first element of the tuple, and `y` is the second element, thus what you are doing is:

``````x = y
y = x+y
``````

Wheras the second is doing a straight assign:

``````x=y
x=x+y
``````

I’ve recently started using Python and this “feature” baffled me. Although there are many answers given, I’ll post my understanding anyway.

If I want to swap the values of two variables, in JavaScipt, I’d do the following:

``````var a = 0;
var b = 1;
var temp = a;
a = b;
b = temp;
``````

I’d need a third variable to temporarily hold one of the values. A very straightforward swap wouldn’t work, because both of the variables would end up with the same value.

``````var a = 0;
var b = 1;
a = b; // b = 1 => a = 1
b = a; // a = 1 => b = 1
``````

Imagine having two different (red and blue) buckets and having two different liquids (water and oil) in them, respectively. Now, try to swap the buckets/liquids (water in blue, and oil in red bucket). You can’t do it unless you have an extra bucket.

Python deals with this with a “cleaner” way/solution: Tuple Assignment.

``````a = 0
b = 1
print(a, b) # 0 1
# temp = a
# a = b
# b = temp
a, b = b, a # values are swapped
print(a, b) # 1 0
``````

I guess, this way Python is creating the “temp” variables automatically and we don’t have to worry about them.

Other answers have already explained how it works, but I want to add a really concrete example.

``````x = 1
y = 2
x, y = y, x+y
``````

In the last line, first the names are dereferenced like this:

``````x, y = 2, 1+2
``````

Then the expression is evaluated:

``````x, y = 2, 3
``````

Then the tuples are expanded and then the assignment happens, equivalent to:

``````x = 2; y = 3
``````