On 11/15/19 6:56 AM, R.Wieser wrote: > There are quite a number of languages where /every/ type of argument > (including values) can be transfered "by reference". Though some default to > "by value", where others default to "by reference".
It seems you are stuck in a programming model different than what Python provides, In a very real sense, the terms call "By Reference" and "By Value" don't apply to Python. Those concepts presume that a variable name represents a bucket of bytes that holds some value, and call by value copies those bytes into a new variable for the subroutine, and call by Reference creates a pointer value back to original value, and all uses of that parameter work indirect that pointer. That is NOT how Python works. In Python, in effect, every name in your code is just a reference which points to some object (This is called binding). Multiple names can point to the same object (or no names, at which point the object is subject to being garbage collected). Names themselves aren't objects, so you can't really make one name refer to another, only to the same object that the other one does. (In actuality, these collections of names are implemented basically in a Dictionary, so using this sort of implementation details you can sort of get that result, but I don't think that is defined to work in the language). In the more classical languages, to draw a model of the variables you have in memory, you take a big sheet of paper, put down each variable name, and next to it a box where you put what value is stored in the variable, and that value is intimately associated with that variable name. You might have some objects being or containing pointers/references and in that case you can represent it by an arrow from the box representing the pointer to the object it is pointing to. There may be some object that are created without a name (like on the heap), but many of the objects are directly tied to a name. In Python you do this differently. On one side of your paper, you put your variable names, and on the other (perhaps a larger side) all the values/objects you are working with. Each name gets an arrow to an object to show what object it is currently bound to. Objects store the values they hold, and some, like collections) also have arrows to other objects they reference. An arrow always points to an object, never to a name on the left side. An assignment just changes what object a reference points to. If it is a 'top level' name being assigned to (as opposed to referring to a member of an object or element of a collection), that is changing one of the names on the left side of the page. This difference in value model means you have to think about things differently, and in a very real sense makes the terms 'by value' and 'by reference' not applicable. You don't get values 'By Value', because you didn't get a copy of the object reference, so if you mutate it, the caller sees the change, but also it isn't by reference, as you can't rebind the callers reference to point to a different object. This isn't 'Wrong' just 'Different'. It takes some getting used to a different model, and I think it helps to accept that it is different rather than trying to keep trying to translate how Python does things into how some other language does it, as the latter make you focus on the things it can't do, not the things it can. -- Richard Damon -- https://mail.python.org/mailman/listinfo/python-list
