A certainl part of an if() structure never gets executed.

[Dave Angel]

I think this is an excellent description of name binding with mutable 
objects.  I just have one clarification to insert below.

On 06/19/2013 01:08 AM, Tim Roberts wrote:
> Nick the Gr33k <support at superhost.gr> wrote:
>>
>> On 16/6/2013 4:55 ??, Tim Roberts wrote:
>>
>>> Nick the Gr33k <support at superhost.gr> wrote:
>>> Because Python lets you use arbitrary values in a Boolean context, the net
>>> result is exactly the same.
>>
>> What is an arbitrary value? don even knwo what arbitrary means literally
>> in English.
>
> Basically, it means "any".  In Python, you can use ANY value where a
> Boolean is expected.  All types have a Boolean meaning.  For integers, 0 is
> false, anything else is true.  For strings, an empty string "" is false,
> anything else is true.  For lists, an empty list [] is false, anything else
> is true.  For tuples, an empty tuple () is false, anything else is true.
> For dicts, an empty dict {} is false, anything else is true.
>
>> The argument being returned in an "and" or "or" expression is the one
>> that *determined' the evaluation of the expression.
>
> That's not exactly how I'd put it, but the statement is correct.  The last
> thing it had to evaulate is the result of the expression.
>
>> And actually what's being returned is not the argument itself but the
>> argument's value.
>
> But this is no different than any other programming language.  Expressions
> always use the value of their operands, and they always return a value.
>
> The name vs value thing is critical to understanding Python, in my opinion,
> and it can be a stumbling block when you're coming from another language.
> Here's how I think about it.
>
> Python had two distinct spaces: there is a space for names, and there is a
> space for objects (which are values).  Objects live in a nameless, faceless
> object cloud.
>
> A name is always bound to some object (which might be the "None" object). A
> name always knows its object, but an object never knows what names it is
> bound to.
>
> The only things that can be used in expressions and function arguments are
> objects.  Names are merely the way we specify which objects to be used.

Names are *one of* the ways we specify which objects are to be used. 
(We can also specify objects via an container and a subscript or slice, 
or via an attribute of another object.  And probably another way or two.)

>
>      a = [3]
>
> That creates a nameless list containing a single integer object with the
> value 3.  It then binds the name "a" to that list.  Note that the list has
> no clue that it is bound to any names.
>
>      b = a
>
> That binds "b" to the same list.  "b" and "a" are not related in any way,
> except that they happen to be bound to the same object.  Note that there is
> still only one list.
>
>      a.append(4)
>
> That modifies the list so that it now contains [3,4].  b is bound to the
> same list, so if you
>      print(b)
> you'll see [3,4]
>
> Now, let's say I do this:
>
>      a = [5]
>
> Here's where people get tripped up.  This does not change our original
> list.  Instead, it creates a new nameless list containing 5, and binds the
> name a to that list.  a and b are no longer bound to the same object.
>


-- 
DaveA