On 01/05/2014 08:40 PM, Keith Winston wrote:
On Sun, Jan 5, 2014 at 2:52 AM, Mark Lawrence <breamore...@yahoo.co.uk>wrote:
Homework for you :) Write a line of code that creates a list of say 3 or
4 integers, then write a line that creates a tuple with the same integers.
Use the dis module to compare the byte code that the two lines of code
produce. The difference is interesting.
Well... that was a very interesting assignment, though I'm going to have to
chew on it for a while to understand. I can see that the processing code
for a tuple is considerably shorter... it is processed in a gulp instead of
bite by byte... it doesn't have the "Build List" step at all (what goes on
inside of THAT?)... but I can't claim to really understand what I'm looking
at.
I notice, for example, if I include only constants (immutable types) in my
tuple, then it does that gulp thing. If I include a list in there too, all
hell breaks loose, and suddenly I'm Building Tuples (what goes on inside of
THAT?). A tuple of tuples still goes down in a single swallow, of course.
Sadly, you can see how my mind works here... hey, this was FUN! You can
assign me homework any time, teach!
A version of Mark's assigment, with only simple tuple items, but some consts and
some vars:
from dis import dis
x,y = 1,2
def f (i,j): # line 5 in source
a,b = 1,2
t1 = (1,2)
t2 = (a,b)
t3 = (x,y)
t4 = (i,j)
l = [1,2]
print(dis(f))
6 0 LOAD_CONST 3 ((1, 2))
3 UNPACK_SEQUENCE 2
6 STORE_FAST 2 (a)
9 STORE_FAST 3 (b)
7 12 LOAD_CONST 4 ((1, 2))
15 STORE_FAST 4 (t1)
8 18 LOAD_FAST 2 (a)
21 LOAD_FAST 3 (b)
24 BUILD_TUPLE 2
27 STORE_FAST 5 (t2)
9 30 LOAD_GLOBAL 0 (x)
33 LOAD_GLOBAL 1 (y)
36 BUILD_TUPLE 2
39 STORE_FAST 6 (t3)
10 42 LOAD_FAST 0 (i)
45 LOAD_FAST 1 (j)
48 BUILD_TUPLE 2
51 STORE_FAST 7 (t4)
11 54 LOAD_CONST 1 (1)
57 LOAD_CONST 2 (2)
60 BUILD_LIST 2
63 STORE_FAST 8 (l)
66 LOAD_CONST 0 (None)
69 RETURN_VALUE
[I call here const a value that is always the same, at every execution; thus in
principle know not only to the programmer, but to the compiler. I don't mean
immutable.]
The interesting part for me is the difference of construction when tuple items
are variable: the build_tuple routine. t2 is also const, abeit so-to-say an
"implicit" const tuple, while t1 is explicitely const, in value notation itself.
t2 is variable, since x & y may change in the meantime (between their first def
and call to f). t3 is variable by so-to-say definition of "variable".
This is a kind of little optimisation in the case a tuple is obviously const. It
is probably worth it because tuples are fix-size, since they are immutable (they
may just be fix-size arrays in the backstage, I don't know). Certainly python
does not even attempt such an optimisation for list due to their mutable and
flexible-size structure (they are flexible-size, dynamic arrays).
Denis
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor
