[I am actually enjoying this discussion, even though it does not address
the OP's question. It is helping to solidify *my* understanding.]
Joe said:
That's correct, but of course, C is a decades-old language barely a step
above assembler. For a fair comparison, pick any modern OOP language,
including the C derivatives (C++, Objective-C, Java), and compare a
Python object to an object in that language, rather than to a struct.
Okay, sorry, should have had C++ from the start. See my spiffed-up
example here, where I magically convert to C++ by replacing "struct"
with "class" and adding the word "public:". Still behaves the same, though.
I added the functions ByVal() and ByRef() to show that when you pass by
value, the contents of the object cannot be changed. This is not
possible in Python unless a copy of the object is made (which is what
C++ does automatically for you in pass-by-value).
In Python, the contents of the object are changed, which is most similar
to the pass by reference (or by pointer) construct in C++. But, yes, as
you say, technically:
passing the object by reference
== passing the address of the object by value.
But I think that is, to most programmers, a surprising use of the term
"pass by value".
And note in my example, nowhere do I explicitly take the address of s1.
The compiler does this for me in the ByRef() case. And nowhere to I make
a copy of s1. Again, the compiler does this for me in the ByVal() case.
The calls to ByVal() and ByRef() are identical. You cannot tell from the
calls which thing is going to happen.
-----------------------
class MyClass {public: int a;} s1, s2;
void ByVal(MyClass obj) {obj.a=42;}
void ByRef(MyClass &obj) {obj.a=43;}
int main()
{
s1.a = 1;
s2 = s1;
printf("s1.a %2d s2.a %2d\n", s1.a, s2.a);
s1.a = 99;
printf("s1.a %2d s2.a %2d\n", s1.a, s2.a);
ByVal(s1);
printf("s1.a %2d\n", s1.a);
ByRef(s1);
printf("s1.a %2d\n", s1.a);
}
--------------
class mystruct:
pass
def ByObject(obj): obj.a=42
s1 = mystruct()
s1.a = 1
s2 = s1
print "s1.a %2d s2.a %2d" % (s1.a,s2.a)
s1.a = 99
print "s1.a %2d s2.a %2d" % (s1.a,s2.a)
ByObject(s1)
print "s1.a %2d" % (s1.a)
--------------
C++ OUTPUT
s1.a 1 s2.a 1
s1.a 99 s2.a 1 # note s2.a does not change when s1.a is modified
s1.a 99 # contents of s1.a does not change when passed by val
s1.a 43 # it does change when passed by ref
Python OUTPUT
s1.a 1 s2.a 1
s1.a 99 s2.a 99 # s2.a "changes" because it's the same object as s1
s1.a 42 # Contents of object does change with function call.
....and in Python, of course, as you say, what you call the "value" of
s1, the address of the object, id(val), does not change.
>>
>> [skipping lots of stuff we agree on!]
>>
In C/C++, by contrast, variable names correspond directly to memory
locations and objects, and you can easily find the addresses of
variables.
Hmm, no, the C++ equivalent of an object reference would be:
SomeClass* foo;
Whoah, nonsequitor there. Let's back up. I did not use the word
"reference", and that is the point. And I am correct that C variable
names correspond to memory locations (or sometimes CPU registers -
optimizers can really mangle things). And you can get the addresses of
the variables themselves using the & operator.
Have a look at my example code again. s1 and s2 ARE OBJECTS THEMSELVES,
they are not references to objects. You can do this in C++ (not in
Python). You can pass whole objects, by value (they are copied by the
compiler), on the stack. And we both understand that you can't do that
in Python. That is why we differentiate between "pass by reference" and
"pass by value" in C++, and people generally understand what that means.
> ...
void NiftyMethod2(SomeClassPtr &arg) {...}
...
NiftyMethod2(foo);
Now, arg here is passed by reference (just like a ByRef parameter in RB
or .NET). That means that NiftyMethod2 could very well change the value
that is passed in. It could actually make foo point to something else.
No Python method can do that,
Yes, absolutely agreed. A Python method can never change *which* object
the caller points to, it can only change the *contents* of that object.
But the same is true in C++ as well. In your example, the address of the
foo variable itself can never be changed. You can change the *value* of
foo (so it points to a different object), or you can change the contents
of the object foo points to. foo is a variable with an address which you
can usually see with a printf("%x", &foo), and that is different from
the address of the object which you get when you say printf("%x", foo).
The value &foo cannot be changed.
because Python arguments are ALWAYS passed
by value. There is no call by reference in Python. Period, end of
story, nothing to see here.
Yea, BUT... If you tell this to a C++ programer without any further
explanation, they will be thoroughly confused and misinformed, unless
you point them to this thread or amend that statement with your version
of what "pass by value" means. I know what you mean, and you know what I
mean, but that's because we've both read through this thread ;-)
Look at my example. The ByVal() routine behaves how C++ programmers
expect "pass by value" to work. The contents of the caller's object
cannot be modified.
So, then, what to tell a C++ programmer about how Python passes
arguments? You say: tell them Python only passes by value. I disagree,
because I think that would confuse them. Rather than try to map C++
conventions onto Python, I think it is more useful to just tell them how
it really works. Maybe a few statements like this:
All values in Python are objects, from simple integers up to complex
user-defined classes.
An assignment in Python binds a variable name to an object. The
internal "value" of the variable is the memory address of an object,
and can be seen with id(var), but is rarely needed in practice.
The "value" that gets passed in a Python function call is the address
of an object (the id()).
When making a function call, myfunc(var), the value of id(var) can
never be changed by the function.
Not sure if these are the best. To get into much more detail, you have
to start explaining mutable and immutable objects and such.
dale
