Finding the instance reference of an object

[Joe Strout]

On Oct 17, 2008, at 3:19 PM, Grant Edwards wrote:

>> And my real point is that this is exactly the same as in every
>> other modern language.
>
> No, it isn't.  In many other languages (C, Pascal, etc.), a
> "variable" is commonly thought of as a fixed location in memory
> into which one can put values.  Those values may be references
> to objects.

Right, though not in languages like C and Pascal that don't HAVE the  
notion of objects.  We really ought to stop bringing up those  
dinosaurs and instead compare Python to any modern OOP language.

>  In Python, that's not how it works.  There is no
> "location in memory" that corresponds to a variable with a
> particular name the way there is in C or Pascal or Fortran or
> many other languages.

No?  Is there any way to prove that, without delving into the Python  
source itself?

If not, then I think you're talking about an internal implementation  
detail.

> All that exists in Python is a name->object mapping.

And what does that name->object mapping consist of?  At some level,  
there has to be a memory location that stores the reference to the  
object, right?

>> Nothing unusual here at all (except that some of us here seem
>> to want to make up new terminology for standard behavior,
>> perhaps in order to make Python seem more exotic).
>
> That's because it is fundamentally different from what happens
> in languages like C.

What happens in a modern OOP language is just as fundamentally  
different (which is to say, not really very much) from what happens in  
C or FORTRAN or COBOL, too.

But if there's any demonstrable difference between Python and any  
other modern OOP language, I'd love to hear about it.

>>> a = a + [something]
>>>
>>> rebinds a
>>
>> In standard terminology, it assigns a new value to a.
>
> The problem is that listeners from a C or FORTRAN background
> will infer that there is a fixed region of memory named "a" and
> "assigning a value to a" means writing that new value into the
> region of memory named "a".

And they'd be correct.  The value being written, in this case, as a  
reference to some data that lives somewhere on the heap.  Point that  
out, and now their understanding is correct.

But if you instead say something like "all parameters are passed by  
reference in Python," then the user gets the wrong idea.  That  
statement has a specific meaning which is, quite demonstrably, not true.

If you make up new terms like "rebinds," well, I guess at least that  
avoids giving the listener the wrong idea.  Instead it gives them no  
idea at all, which may be better, but not as good as giving them the  
right idea.  It still leaves them to investigate what actually  
happens, and ultimately they will find that the parameters are always  
passed by value in Python.  May as well save them the trouble and  
point that out up front.

And how many recovering FORTRAN or C programmers do we get around  
here, anyway?  Java is what they've been teaching in school for the  
last several years, and it was C++ for a good decade before that.  The  
semantics of Python (insofar as objects, assignments, and parameters  
are concerned) are exactly the same as Java, and Java is just a  
cleaned-up and streamlined C++.  Even old-timers (like me) who learned  
FORTRAN and COBOL way back in the day have long since moved on.

Best,
- Joe