On 5/04/21 11:47 am, dn wrote:
I think I've read that the compiler is smart-enough to realise that the
RHS 'literal-tuples'?'tuple-literals' are being used as a 'mechanism',
and thus the inits are in-lined.

It does indeed seem to do this in some cases:

>>> def g(i, j, k):
...  a, b, c = i, j, k
...
>>> dis(g)
  2           0 LOAD_FAST                0 (i)
              2 LOAD_FAST                1 (j)
              4 LOAD_FAST                2 (k)
              6 ROT_THREE
              8 ROT_TWO
             10 STORE_FAST               3 (a)
             12 STORE_FAST               4 (b)
             14 STORE_FAST               5 (c)
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

If the RHS is a literal, it's a bit different:

>>> def f():
...  a, b, c = 1, 2, 3
...
>>> dis(f)
  2           0 LOAD_CONST               1 ((1, 2, 3))
              2 UNPACK_SEQUENCE          3
              4 STORE_FAST               0 (a)
              6 STORE_FAST               1 (b)
              8 STORE_FAST               2 (c)
             10 LOAD_CONST               0 (None)
             12 RETURN_VALUE

Here the tuple creation is being done at compile time,
so there's still an unpacking operation. It might not be
much different speed-wise from loading the values separately,
though.

--
Greg

--
https://mail.python.org/mailman/listinfo/python-list

Reply via email to