Thread by @treyhunner

What's "assignment" in #Python?

This might seem like a simple concept, but there are some gotchas in the way assignment works in Python.

Fundamentally "assignment" describes the action of binding a name to a value.

You can assign a variable (a.k.a. name) to a value (a.k.a. object) with an "assignment statement".

That uses an = sign, like this:

>>> x = []

That assigns the name x to an empty list.

If "x" already exists, an = sign will re-assign it to a new value:

.>>> x = 4
>>> x
4

Python programmers often talk about names "binding" to objects or variables "pointing" to objects.

In Python, variables point to (or "refer to") values. Variables don't *contain* objects, but just say "look over there for the object". 👀

Beware of code like this:

x = []
y = x

Why beware? Well, two variables can point to the same object.

The second line here points "y" to the same object that "x" is pointing to:

>>> x = []
>>> y = x

Mutating the object will appear to change both variables:

>>> y.append(4)
>>> x
[4]

😦

The distinction between mutation and assignment is important in Python.

Assignment changes which object a variable points to.

Mutation changes the object itself.

And function calls assign (without copying), which can confuse as well.

More on this 👇

pym.dev/pointers

That's not the only surprise when it comes to assignment in Python though.

When we talk about assigning variables and assignments, we're often referring to assignment statements (a line with an = sign on it).

But that's not the only way to assign a variable in Python! 😕

For loops also assign to variables in each iteration of their loop.

Watch "x" get reassigned here:

>>> x = 0
>>> for x in range(3):
... print(x)
...
0
1
2
>>> x
2

The last iteration of the loop assigned it to 2!

There are assignments hiding all over...

Function definitions assign a variable (the function name) to a new function object:

>>> x
2
>>> def x(): pass
...
>>> x
<function x at 0x7fbb8a10a560>

Class definitions assign variables to a new class object:

>>> class x: pass
...
>>> x
<class '__main__.x'>

Even import statements perform assignments.

>>> import json
>>> json
<module 'json' from '/usr/lib/python3.11/json/__init__.py'>

The "from" syntax performs many assignments:

>>> from math import e, tau
>>> e
2.718281828459045
>>> tau
6.283185307179586

Another surprise: assignment statements can sometimes mutate! 🤔

Specifically, augmented assignment statements (a.k.a. in-place assignments) such as += and *= will typically mutate the object being assigned if it's mutable.

>>> x = y = []
>>> x += [1, 2]
>>> y
[1, 2]

One more big fact about assignment in Python:

Assignment changes LOCAL variables only*

>>> x = 0
>>> def f():
... x = 4
...
>>> f()
>>> x
0

If there's a global variable of the same name, it will be "shadowed" but left unchanged.

pym.dev/local-and-glob…

Pedants may say "but wait, you CAN assign to global and nonlocal variables in Python by using special statements".

That's right, but you usually shouldn't. It's rarely a good idea and often an indication that your code could benefit from well-placed return statements or a class.

I'll leave a bigger discussion of namespaces and scope for another day... but I'd like to close this thread by linking to over a dozen screencasts on @PythonMorsels on assignment, mutation, and scope.

1. pym.dev/screencasts/va…
2. pym.dev/screencasts/as…

Many are free 💓🐍

I forgot the #TerminologyTuesday hashtag! 😮

Still wishing for a an "edit" button on Twitter 😅