Variables in Python: Summary

Good overview. Reinforced a couple of things for me.

Enjoyed it and good explanation on how Python handles variable objects. DO see some variation from course between Windows and Linux versions.

This stuff is really helpful… thank you!

Was unaware of small integer caching … thx!

Glad that you’ve enjoyed it and happy if it’s been helpful :)

Martin B, totally enjoyed learning new stuffs from your course.

The snake is… ever watchful!

Nice intro on small integer caching. Hoping that I understood it right, all those integers are automatically instantiated as objects and remain so for the entire session, never to be garbage-collected?

Seeing it another way, is Python “encouraging” us to use those numbers throughout the program (e.g. if I need to refer to the figure of 10000, then try to use 10 throughout the code, then adjust the final figure by x 1000? Or is that not a concern?

Thank you,

This is a great question and I don’t have a great answer for it myself. I can tell you that for any program you are likely to write at the beginning of your programming journey (and probably way into it as well, tbh) it doesn’t matter.

I’m sure that there are applications that need to really edge out speed and memory usage in order to perform, especially when handling huge amounts of data. However, it is likely that if speed and memory-lookup performance is that important for your app, your company might use a different programming language altogether, since that is not Python’s main area of strength.

There’s an interesting answer on StackOverflow with a ton of links that can lead you onwards, if you want to learn more about this topic. It doesn’t specifically go into Python, but you might still find something enlightening in there. Hope that helps a little and keep on investigating! :D

Thank you, Martin! Yes that is exactly what I was thinking of: memory usage and speed. You’re right, Python is considered a slower language than its counterparts like C++. Will check the link you posted. :)

Hello my name is Jay , new to coding an really enjoy the course , lesson was detail an clear . Will continue to study an learn more .

Thanks, helps a lot!

Of what constitutes an “object” in terms of variables. Apparently small integers from -5 through 256 are a special class of objects.

Hi @avalidzy. Small integers are normal objects like any other object is an object in Python. The “special” thing about them is only that Python doesn’t create a new instance of an object (= a new object) each time you reference an integer in that range. Instead it refers to that integer object that already exists. It’s a performance thing, but doesn’t make small integer objects special in any way. Hope that makes sense!

Thanks for clarifying the nature of a python object! ;)

Thanks for this video. It was helpful. Onto the next video.

Could you show how to set a data type at input like a = 39 {int8}?

Hi @jeffgorzen. Python is a dynamically typed language, which means you don’t declare the data type of variables when you declare them. The interpreter figures it out at runtime.

You can read more about some more recently introduced ways of adding type checking functionality in the Python Type Checking article.

Thank you, Martin, for the good and clear lessons.

Really enjoyed the course, thanks!

Great reference about variables. I had initially read the supporting material to under the concepts . There are few topics which confused me but after watching the video course its crystal clear now :-).

Great course! Enjoyed every lesson of it!

Hi all! Glad you’ve found the course useful :D

Thank you for this course, Martin.

#1 takeaway for me is the small integer cache, which was something completely unknown for me. Consequently I also liked the python pub quiz referring to it.

#2 is the keyword package. Seems useful.

Perhaps something to add to the course: Usage (and caveats) of comparison operators == and is ?

Learned few things and refreshed a bit of what i know.. thank you

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