Finding the instance reference of an object [long and probably boring]
tjreedy at udel.edu
Fri Nov 7 20:35:19 CET 2008
Steven D'Aprano wrote:
> On Fri, 07 Nov 2008 08:48:19 -0700, Joe Strout wrote:
> Unfortunately, the term "name" is *slightly* ambiguous in Python. There
> are names, and then there are objects which have a name attribute, which
> holds a string. This attribute is usually called __name__ but sometimes
> it's called other things, like func_name.
3.0 corrects that divergence.
>>> def foo(): pass
> You're assuming that call-by-sharing isn't a standard term. That's not
> true. It's a standard term that is sadly not well known, I believe
> because of the ignorance of most coders to the history of their own
> discipline. (I include myself in that.)
Call by sharing
Also known as "call by object" or "call by object-sharing" is an
evaluation strategy first named by Barbara Liskov et al for the language
CLU in 1974. It is used by languages such as Python and Iota and
(as argued by some) Java, although the term is not in common use by
the Java community. Call-by-sharing implies that values in the language
are based on objects rather than primitive types.
The semantics of call-by-sharing differ from call-by-reference in that
assignments to function arguments within the function aren't visible to
the caller (unlike by-reference sematics). However since the function
has access to the same object as the caller (no copy is made), mutations
to those objects within the function are visible to the caller, which
differs from call-by-value semantics.
Although this term has widespread usage in the Python community,
identical semantics in other languages such as Java and Visual Basic are
often described as call-by-value, where the value is implied to be a
reference to the object.
Call by Sharing
The caller and called routine communicate only through the argument and
result objects; routines do not have access to any variables of the caller.
After the assignments of actual arguments to formal arguments, the
caller and the called routine share objects. If the called routine
modifies a shared object, the modification is visible to the caller on
return. The names used to denote the shared objects are distinct in the
caller and called routine; if a routine assigns an object to a formal
argument variable, there is no effect on the caller. From the point of
view of the invoked routine, the only difference between its formal
argument variables and its other local variables is that the formals are
initialized by its caller.
Python object *do* have access to surrounding scopes, but the second
paragraph exact described Python, as does the corresponding Wikipedia entry.
• Call by sharing
– Used by languages where variables are already references to objects
– Parameters are references to objects, but assignments to those parameters
don’t change them at the level of the caller — e.g. Java uses call-by-value
for primitives (int, char) and uses call-by-sharing for Objects
And Google had other links to course notes using 'call by sharing'
Terry Jan Reedy
More information about the Python-list