Re: variable declaration

[Brian van den Broek]

Steve Holden said unto the world upon 2005-02-07 17:51:
Alexander Zatvornitskiy wrote:
Привет Alex!
05 февраля 2005 в 17:00, Alex Martelli в своем письме к All писал:
<SNIP>
 AM> to all intents and purposes working "as if"
 AM> it was a declaration.  If I had to vote about the one worst formal
 AM> defect of Python, it would surely be 'global'.
Second worsest - 'def'? :)
The reason global is a wart can clearly be seen in the following example:
 >>> x = 3
 >>> def f(tf, v):
 ...   if tf:
 ...     global x
 ...   x = v
 ...
 >>> f(0, 5)
 >>> x
5
 >>>
This makes it apparent that the global statement is *not* executable, 
the only one in the language that is not.
<SNIP>
regards
 Steve
Hi,
Steve's example makes my brain hurt. :-)
I'd appreciate it if someone could tell me if I am understanding the 
example correctly. (My grasp of the terminology and issues at play is 
a bit shaky.)

Let me simplify Steve's example to:
.def hurts_my_brain(v):
.    if False:     # unlike Steve's eg, ensuring that the
.        global x  # nested block is never hit at runtime
.    x = v
(I checked, and it works the same as the original eg, modulo change of 
function name.)

Is the right way to understand it in this vicinity:
At compile time (by which I mean when the Python bytecode is built) 
the global statement is hit and has the effect of `bumping up' the 
function local name `x' to the module namespace, making the function 
local name `x' synonymous with the module global name `x'. At runtime, 
the `global x' is never reached, but it has already, at compile time, 
had its effect on the nature of the function object hurts_my_brain. 
Further, if the function had instead said 'if True:' the global 
statement would have been reached at runtime, but would have been 
without effect due to this, having already been `used up' in the 
creation of the bytecode.

Can it then be further (truly :-) ) said that
if False:
    # thousands of lines of code here
would effect the structure of the function object's bytecode, but not 
its behaviour when run? Or, at most, would cause a performance effect 
due to the bytecode being bloated by thousands of line's worth of code 
that would never get executed?

Thanks for any confirmation of my understanding / rectification of 
same. Best,

Brian vdB
--
http://mail.python.org/mailman/listinfo/python-list