Variables in Python: Summary

Found out that I need to use help(dir) a lot more than I currently do. This is my take away from the lesson.

Glad the course has been useful :D

And yes, I think you mean that using both help() and dir() can really be very helpful for learning more about the objects that you’re working with!

Great lecture. Thanks!

One thing that made me a bit confused concerning the challenge example. It seems you get different results depending on how you assign the values to the variables. Check the following run:

In [38]: e = 258

In [39]: f = 258

In [40]: id(e)
Out[40]: 1806617088784

In [41]: id(f)
Out[41]: 1806617092816

In [42]: if e is not f:
    ...:     print('They are not the same')
    ...: else:
    ...:     print('They are the same')
    ...:
They are not the same

In [43]: g, h = 258, 258

In [44]: if g is not h:
    ...:     print('They are not the same')
    ...: else:
    ...:     print('They are the same')
    ...:
They are the same

In [45]: id(g)
Out[45]: 1806613750640

In [46]: id(h)
Out[46]: 1806613750640

@AndersC that’s a great observation! Indeed, Python handles situations differently whether you use two separate assignment statements, or a simultaneous assignment statement. In the latter case, it’ll apply some optimizations.

You can use the dis module to dig deeper and find out how Python handles them under the hood. It allows you to see the bytecode instructions that Python generates for a function:

>>> import dis

>>> def separate_assignments():
...     e = 258
...     f = 258
...     return e is f
...

>>> dis.dis(separate_assignments)
  1           0 RESUME                   0

  2           2 LOAD_CONST               1 (258)
              4 STORE_FAST               0 (e)

  3           6 LOAD_CONST               1 (258)
              8 STORE_FAST               1 (f)

  4          10 LOAD_FAST                0 (e)
             12 LOAD_FAST                1 (f)
             14 IS_OP                    0
             16 RETURN_VALUE

The exact meaning of all the instructions isn’t that relevant, but still, here’s what a couple of them mean:

• LOAD_CONST 1 (258): The value 258 is loaded as a constant twice—once for each assignment to e and f.

• STORE_FAST 0 (e) and STORE_FAST 1 (f): These instructions store the loaded constant into the local variables e and f.

• IS_OP 0: This checks whether e and f refer to the same object in memory.

Here, Python loads the constant 258 twice, meaning that e and f could potentially be stored in different memory locations if Python doesn’t optimize the memory usage, leading to e is f being False.

Now, when you try the other approach you get different bytecode instructions:

>>> def simultaneous_assignment():
...     g, h = 258, 258
...     return g is h
...

>>> dis.dis(simultaneous_assignment)
  1           0 RESUME                   0

  2           2 LOAD_CONST               1 ((258, 258))
              4 UNPACK_SEQUENCE          2
              8 STORE_FAST               0 (g)
             10 STORE_FAST               1 (h)

  3          12 LOAD_FAST                0 (g)
             14 LOAD_FAST                1 (h)
             16 IS_OP                    0
             18 RETURN_VALUE

As you can see, the bytecode instructions are different than before.

• LOAD_CONST 1 ((258, 258)): This line shows that Python is loading a tuple containing the two instances of 258 as a constant. Python has created a tuple ((258, 258)) and loaded it as a single constant.

• UNPACK_SEQUENCE 2: This instruction unpacks the tuple into two separate elements. It effectively splits the tuple (258, 258) into its two components.

With this setup, Python optimizes the assignment by packing the values (258, 258) into a single tuple and then unpacking them into the variables g and h. This is efficient because Python recognizes that the same value (258) is being assigned twice and therefore optimizes by reusing the object where possible.

Because of this optimization, both g and h likely refer to the same object in memory.

Thanks for the explanation! It makes sense.

It seems like strings are cached as well in Python. If I assign a=”cat” and b=”cat”, I get True for a is b. I expected that a separate object would be created for each assignment. Interestingly, if you embed a space in your string like a=”cat dog” and b=”cat dog”, Python does create separate objects ie. a is b is False.

@rweintr good find! Python indeed does something similar with small common strings. It’s called string interning. Python does that automatically with strings that may reasonably appear more often in a program, e.g. short strings or strings that may be used as identifiers.

You can also explicitly intern a string, if you think that this (minor) performance boost may be relevant:

>>> import sys
>>> a = sys.intern("cat dog")
>>> b = sys.intern("cat dog")
>>> a is b
True

Very interesting tutorial, When I thought there possibly might nothing else to learn about variables :)

takeaways for me:

• Small integer caching
• Keyword search
• Interesting points from other user’s comments

Thanks alot

Good refresher - but… why are there a lot of topics in the quiz that haven’t been covered in the course at all? Call/instance attributes, type annotations - very confusing

@Oliver Fink Thanks for the feedback! The quiz was likely borrowed from the written tutorial that this video course is based on, so while there’s some overlap in topics, not everything covered in the quiz appears in the video lessons themselves.

If you’d like to explore those additional concepts, then you can check out the full written tutorial: Variables in Python: Usage and Best Practices.