Home/ Questions/Q 6245613
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-24T12:32:15+00:00

Consider the following code snippet: dict [name] = 0 dict [name] += 1 dict

  • 0

Consider the following code snippet:

dict [name] = 0
dict [name] += 1
dict [name] += 1

Does the python interpreter automatically recognise the repeated references to the dictionary value and use a cached local reference instead?, somewhat akin to the aliasing optimisations of C/C++, becoming something like so:

value = dict [name]
value = 0
value += 1
value += 1

Obviously, it’s not a big deal to do this manually but I’m curious if it’s actually necessary. any insight, feedback, etc is appreciated.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    You can run it through the disassembler to find out:

    import dis

def test():
    name = 'test'
    tdict = {}
    tdict[name] = 0
    tdict[name] += 1
    tdict[name] += 1

dis.dis(test)

    Running this we get:

     13           0 LOAD_CONST               1 ('test')
              3 STORE_FAST               0 (name)

 14           6 BUILD_MAP                0
              9 STORE_FAST               1 (tdict)

 15          12 LOAD_CONST               2 (0)
             15 LOAD_FAST                1 (tdict)
             18 LOAD_FAST                0 (name)
             21 STORE_SUBSCR        

 16          22 LOAD_FAST                1 (tdict)
             25 LOAD_FAST                0 (name)
             28 DUP_TOPX                 2
             31 BINARY_SUBSCR       
             32 LOAD_CONST               3 (1)
             35 INPLACE_ADD         
             36 ROT_THREE           
             37 STORE_SUBSCR        

 17          38 LOAD_FAST                1 (tdict)
             41 LOAD_FAST                0 (name)
             44 DUP_TOPX                 2
             47 BINARY_SUBSCR       
             48 LOAD_CONST               3 (1)
             51 INPLACE_ADD         
             52 ROT_THREE           
             53 STORE_SUBSCR        
             54 LOAD_CONST               0 (None)
             57 RETURN_VALUE

    It looks like, in this case, that LOAD_FAST is loading up the values of tdict and name each time we try to access it to perform the increment, so the answer would appear to be no.

    • 0