I'm wrong or Will we fix the ducks limp?
BartC
bc at freeuk.com
Wed Jun 8 13:29:06 EDT 2016
On 08/06/2016 15:18, Antoon Pardon wrote:
> Op 08-06-16 om 14:34 schreef BartC:
>>
>> So you have partial updates and full updates. A proper reference will
>> be able to do both via the reference. Python can only do a partial
>> update and the reason is that the reference points to the object, not
>> the variable; there is no way to change the variable to link it with
>> another, distinct object.
>>
>> If the object is a list, then that can be modified to any extent, even
>> replacing the contents completely, but it will still be a list. In the
>> case of an int or string, then it's impossible to change. So there are
>> limitations to what can be done.
>>
>> Getting back to Pascal (as I /can/ remember how reference parameters
>> work for integers), assigning to a reference integer parameter in a
>> function will change the caller's version. Python can only emulate
>> that by passing a one-element list or using some such trick. Affecting
>> readability and, likely, performance.
>>
> I don't see why we should determine what a /proper/ reference
> can do, based on what it does in one specific language.
Because there are some things that such references can do that Python
can't do with its object reference model, not without some difficulty or
having to write convoluted code.
And it doesn't really depend on the language as the differences are easy
to demonstrate, provided the language still has something along the
lines of:
a = b
to do normal assignment.
(1) Reference parameters
def fn(&x):
x=1000
a="ABC"
fn(a)
print (a) # should produce 1000
I've used "&" here as a device to make the 'x' param work as though it
was passed by reference. That is, an /additional/ reference to the one
Python might already use behind the scenes.
(2) Replace (not just modify) a variable's value and type indirectly
a = 17
p = &a
*p = "Dog"
print a # should be "Dog"
Here "&" and "*" are used to indicate possible 'reference'/dereference
operations.
With the last example, then this Python code:
a = 17
p = a
Might result in the following internal structures:
0x300:a:[pyref:0x10020] Variable
0x400:p:[pyref:0x10020] Variable
0x10020:[int: 17] Object
With the p = &a version, it would be more like:
0x300:a:[pyref:0x10020] Variable
0x400:p:[pyref:0x10040] Variable
0x10020:[int: 17] Object
0x10040:[varref: 0x300] Object
It's that 0x300 reference to 'a' itself, not just the object linked to
it, that is what Python can't do.
--
Bartc
More information about the Python-list
mailing list