On Thu, Aug 06, 2015 at 11:34:51AM +0300, John Doe wrote:
> Can You, please, elaborate this "..Passing in Python is different than
> in C or other languages..."
Argument passing in Python is:
- different to Perl, C, Scala, Algol and Pascal;
- the same as Ruby, Lua, Applescript and Javascript;
- the same as Java boxed values (object);
- different to Java unboxed values (machine types).
In C, all values are passed by value. When you pass an argument to a
function, the C compiler makes a copy of that value and passes the
value.
In Pascal, values can be passed by value (like C), or by reference.
The simplest demonstration of pass-by-reference is to write a "swap"
procedure. In Python terms:
# This does not actually work in Python.
def swap(a, b):
tmp = a
a = b
b = tmp
x = 23
y = 42
swap(x, y)
print x, y # prints 42 23
z = 19
swap(x, z)
print x, z # prints 19 42
You *cannot* write a swap procedure like this in Python. The closest you
can do is write a function that returns the two values, then assign
them:
def swap(a, b):
return b, a
x, y = swap(x, y) # this works
but that is not pass by reference.
In Pascal, you can write such a swap procedure.
Scala and Algol use pass by name, and pass by value. This page explains
pass by name in Scala, and how it differs from pass by value:
http://alvinalexander.com/source-code/scala/simple-scala-call-name-example
In Java, unboxed values (not objects, low-level machine ints and floats)
are passed by value, like C.
Python, Ruby, Javascript, Lua, Java boxed values (objects), and many
other languages, all use the same passing style. This has a number of
names:
- pass by object;
- pass by sharing;
- pass by object sharing;
Some people (especially Ruby programmers) call it "pass by reference"
but that is wrong. Others (especially Java programmers) call it "call by
value, where the value is a reference" which is technically correct but
too long. Another name is "call by value/pass by reference", which is
just confusing.
See also:
https://en.wikipedia.org/wiki/Evaluation_strategy
In pass by object sharing, the argument is evaluated but *not* copied.
Since the argument is not copied, it is not pass-by-value. Inside the
function, you can modify the object, and since it is not a copy, the
original sees the changes. But *assignment* to the local variable inside
the function does not affect the caller's variable, so it is not
pass-by-reference.
To summarise:
Pass by value:
- Argument is copied? YES
- Assignment inside function affects original? NO
- Mutation of argument inside function affects original? NO
Pass by reference:
- Argument is copied? NO
- Assignment inside function affects original? YES
- Mutation of argument inside function affects original? YES
Pass by object sharing:
- Argument is copied? NO
- Assignment inside function affects original? NO
- Mutation of argument inside function affects original? YES
> 'Cause as far as I know - default major Python's implementation CPython
> is written in C.
That is irrelevent. The argument passing strategy of a language is part
of the language itself, not the implementation language.
C does not allow variables to change type. But Python does. You cannot
do this in C:
x = 23 # x is an integer
x = "foo" # and now it is a string
so clearly the behaviour of a programming language is not always the
same as that of the implementation language.
--
Steve
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor
