function-arguments by reference

Hy!

is it possible to pass function-arguments by reference?
(for example in PHP you can use the "&" operator ... )

thx
iolo

"EsC" <christian.eslbauer@liwest.at> writes:[color=blue]
> is it possible to pass function-arguments by reference?
> (for example in PHP you can use the "&" operator ... )[/color]

No. If there's a specific situation you want to handle, say what it
is and someone will say how to deal with it in Python. For example if
you want a function that returns multiple values, just return a list:

def get_three_nums ():
return (2, 3, 5)

a, b, c = get_three_nums ()

sets a=2, b=3, and c=5. You don't have to do anything kludgy like
"get_three_nums (&a, &b, &c)" or whatever. If you want to swap two
variables, you can just use a list assignment like in perl:

(x, y) = (y, x)

EsC:[color=blue]
>is it possible to pass function-arguments by reference?[/color]

This is a FAQ.
http://www.python.org/doc/faq/progra...l-by-reference

--
René Pijlman

On Tue, 30 Dec 2003 14:21:46 +0100, rumours say that "EsC"
<christian.eslbauer@liwest.at> might have written:
[color=blue]
>Hy!
>
>is it possible to pass function-arguments by reference?
>(for example in PHP you can use the "&" operator ... )
>
>thx
>iolo
>[/color]

There is no such concept as "pass by value" in python. Only references
are passed around, and therefore there is no special syntax for that.

What you need to understand is that objects can be mutable (changeable)
or immutable. Search for these terms in the python documentation.

In other languages, variables are a container: they contain a "value".
In python, "variables" are only "names" referring to "objects" and they
have no "value". If you assign anything to a name, you just change the
object it is pointing to.

Presumably you ask this question because you want your function to pass
back some more data than its return value. Python handles fine multiple
values, check for "tuple" in the docs.

An example: (I am not familiar with php, therefore I will write program
A in pseudocode, but you will get the point I hope)

function f(&a):
if (a > 10) then a = 10
return (a*2)

var = 20
result = f(var)

This function makes sure that the "var" variable stays less than or
equal to 10, and then returns the double of the corrected argument.

In python you would do this:

def f(a):
if a > 10:
a = 10
return a, a*2

var = 20
var, result = f(var)

If not covered, please write back.

PS reading this could be helpful too:
http://www.effbot.org/zone/python-objects.htm

--
TZOTZIOY, I speak England very best,
Ils sont fous ces Redmontains! --Harddix

hy!

thanks for your explanations!

i want to avoid performance-problems by repeated (very often)
function-calls with very long strings.
in some languages (C, PHP, Powerbuilder, ...) i have the opportunity,
to pass "by value" or "by reference/pointer)".

"by value": the CPU must perform a complete copy of the string
"by reference/pointer": only a long value (address) is passed ...
the performance difference is in most cases unimportant, but sometimes ...

Unfortunately i made an error by testing the behavior of Phyton, and
so i thougt, LISTs are also passed "by value".
But this isn't true, and so i can solve my problem by putting the string-
argument in the first place of a list.

greetings
iolo

"Christos TZOTZIOY Georgiou" <tzot@sil-tec.gr> schrieb im Newsbeitrag
news:79v2vv0ijgdvqu354uh4mh21v4b3liurj0@4ax.com...[color=blue]
> On Tue, 30 Dec 2003 14:21:46 +0100, rumours say that "EsC"
> <christian.eslbauer@liwest.at> might have written:
>[color=green]
> >Hy!
> >
> >is it possible to pass function-arguments by reference?
> >(for example in PHP you can use the "&" operator ... )
> >
> >thx
> >iolo
> >[/color]
>
> There is no such concept as "pass by value" in python. Only references
> are passed around, and therefore there is no special syntax for that.
>
> What you need to understand is that objects can be mutable (changeable)
> or immutable. Search for these terms in the python documentation.
>
> In other languages, variables are a container: they contain a "value".
> In python, "variables" are only "names" referring to "objects" and they
> have no "value". If you assign anything to a name, you just change the
> object it is pointing to.
>
> Presumably you ask this question because you want your function to pass
> back some more data than its return value. Python handles fine multiple
> values, check for "tuple" in the docs.
>
> An example: (I am not familiar with php, therefore I will write program
> A in pseudocode, but you will get the point I hope)
>
> function f(&a):
> if (a > 10) then a = 10
> return (a*2)
>
> var = 20
> result = f(var)
>
> This function makes sure that the "var" variable stays less than or
> equal to 10, and then returns the double of the corrected argument.
>
> In python you would do this:
>
> def f(a):
> if a > 10:
> a = 10
> return a, a*2
>
> var = 20
> var, result = f(var)
>
> If not covered, please write back.
>
> PS reading this could be helpful too:
> http://www.effbot.org/zone/python-objects.htm
>
> --
> TZOTZIOY, I speak England very best,
> Ils sont fous ces Redmontains! --Harddix[/color]

EsC <christian.eslbauer@liwest.at> wrote:[color=blue]
> hy![/color]
[color=blue]
> thanks for your explanations![/color]
[color=blue]
> i want to avoid performance-problems by repeated (very often)
> function-calls with very long strings.
> in some languages (C, PHP, Powerbuilder, ...) i have the opportunity,
> to pass "by value" or "by reference/pointer)".[/color]

The text of the string is not copied; a reference to the string/object
is passed into the function. You can modify objects passed into
functions (but only if they're mutable--strings and integers are
examples of immutable objects), but you cannot rebind the variable
holding the value in the caller's scope.

There have been some discussions in this newsgroup about whether
Python is call-by-value or not. I'm not sure if I want to recommend
looking for them; there was no good consensus about the terminology.

hy JCM!

damned - you are right!
i didn't know the way Python is handling arguments
up to now! It's a little bit different to other languages
i know - and somtimes even a little bit easier.

i made some (useless) performance-tests to proof your exclamations ...
if somebody is interested: i enclosed the code and results ...

- String 1 & String2: only read-access within the called function
the runtime is almost identical; therefore the text of the string can't
be copied
- String 3: the argument string is modified but NOT passed back to
the caller;
- String 4: the argument string is passed "by reference" within a
list object and modified.

i think this informations are very interesting
thanks!

greetings
iolo

------------ CODE -------------
import sys
from string import *
from time import *

def ls(str):
return len(str)

def ll(str):
return len(str[0])

def as(str):
str += "x"
return len( str )

def al(str):
str[0] += "x"
return len( str[0] )

loop = 2000
strlen = 30000
strl = []
strl.append("")
strs = ""

for a in range(strlen):
strs += 'x'
strl[0] += 'y'

print "Loop: ", loop
print "Stringlength: " , strlen

print
print 'String 1'
l = 0
start = time()
for x in range(loop):
l += ls(strs)
end = time()
print "duration in seconds: ", end - start
print "result: ", l
if strlen == l / loop:
print 'OK'
else:
print 'ERROR'

print
print 'String 2'
l = 0
start = time()
for x in range(loop):
l += ll(strl)
end = time()
print "duration in seconds: ", end - start
print "result: ", l
if strlen == l / loop:
print 'OK'
else:
print 'ERROR'

print
print 'String 3'
l = 0
start = time()
for x in range(loop):
l += as(strs)
end = time()
print "duration in seconds: ", end - start
print "result: ", l
if l == loop * strlen + loop:
print 'OK'
else:
print 'ERROR'

print
print 'String 4'
l = 0
start = time()
for x in range(loop):
l += al(strl)
end = time()
print "duration in seconds: ", end - start
print "result: ", l
if l == (loop / 2 ) * ((strlen + 1) + (strlen + loop)):
print 'OK'
else:
print 'ERROR'

---------------- RESULT ----------------
Loop: 50000
Stringlength: 200000

String 1
duration in seconds: 0.0620000362396
result: 10000000000
OK

String 2
duration in seconds: 0.0779999494553
result: 10000000000
OK

String 3
duration in seconds: 3.2349998951
result: 10000050000
OK

String 4
duration in seconds: 5.93700003624
result: 11250025000
OK
--------------------------------------------------

"JCM" <joshway_without_spam@myway.com> schrieb im Newsbeitrag
news:bss7u2$18e$1@fred.mathworks.com...[color=blue]
> EsC <christian.eslbauer@liwest.at> wrote:[color=green]
> > hy![/color]
>[color=green]
> > thanks for your explanations![/color]
>[color=green]
> > i want to avoid performance-problems by repeated (very often)
> > function-calls with very long strings.
> > in some languages (C, PHP, Powerbuilder, ...) i have the opportunity,
> > to pass "by value" or "by reference/pointer)".[/color]
>
> The text of the string is not copied; a reference to the string/object
> is passed into the function. You can modify objects passed into
> functions (but only if they're mutable--strings and integers are
> examples of immutable objects), but you cannot rebind the variable
> holding the value in the caller's scope.
>
> There have been some discussions in this newsgroup about whether
> Python is call-by-value or not. I'm not sure if I want to recommend
> looking for them; there was no good consensus about the terminology.[/color]

EsC wrote:
[color=blue]
>hy JCM!
>
>damned - you are right!
>i didn't know the way Python is handling arguments
>up to now! It's a little bit different to other languages
>i know - and somtimes even a little bit easier.
>
>i made some (useless) performance-tests to proof your exclamations ...
>if somebody is interested: i enclosed the code and results ...
>
>- String 1 & String2: only read-access within the called function
>the runtime is almost identical; therefore the text of the string can't
>be copied
>
>[/color]
I don't think your test code proves that the string is not copied, only
that passing a reference to a string takes approximately the same amount
of time as passing a reference to a list and accessing the 1st item.

A better "proof" that the string is not copied is:
[color=blue][color=green][color=darkred]
>>> s1 = 'this is a string'
>>> def f(s2):[/color][/color][/color]
... print s1 is s2
...[color=blue][color=green][color=darkred]
>>> f(s1)[/color][/color][/color]
True[color=blue][color=green][color=darkred]
>>>[/color][/color][/color]

The "True" result indicates that both s1 and s2 are bound to the same
string object.
[color=blue]
>- String 3: the argument string is modified but NOT passed back to
>the caller;
>- String 4: the argument string is passed "by reference" within a
>list object and modified.
>
>i think this informations are very interesting
>thanks!
>
>greetings
>iolo
>
>
>------------ CODE -------------
>import sys
>from string import *
>from time import *
>
>def ls(str):
> return len(str)
>
>def ll(str):
> return len(str[0])
>
>def as(str):
> str += "x"
> return len( str )
>
>def al(str):
> str[0] += "x"
> return len( str[0] )
>
>loop = 2000
>strlen = 30000
>strl = []
>strl.append("")
>strs = ""
>
>for a in range(strlen):
> strs += 'x'
> strl[0] += 'y'
>
>print "Loop: ", loop
>print "Stringlength: " , strlen
>
>print
>print 'String 1'
>l = 0
>start = time()
>for x in range(loop):
> l += ls(strs)
>end = time()
>print "duration in seconds: ", end - start
>print "result: ", l
>if strlen == l / loop:
> print 'OK'
>else:
> print 'ERROR'
>
>print
>print 'String 2'
>l = 0
>start = time()
>for x in range(loop):
> l += ll(strl)
>end = time()
>print "duration in seconds: ", end - start
>print "result: ", l
>if strlen == l / loop:
> print 'OK'
>else:
> print 'ERROR'
>
>print
>print 'String 3'
>l = 0
>start = time()
>for x in range(loop):
> l += as(strs)
>end = time()
>print "duration in seconds: ", end - start
>print "result: ", l
>if l == loop * strlen + loop:
> print 'OK'
>else:
> print 'ERROR'
>
>print
>print 'String 4'
>l = 0
>start = time()
>for x in range(loop):
> l += al(strl)
>end = time()
>print "duration in seconds: ", end - start
>print "result: ", l
>if l == (loop / 2 ) * ((strlen + 1) + (strlen + loop)):
> print 'OK'
>else:
> print 'ERROR'
>
>---------------- RESULT ----------------
>Loop: 50000
>Stringlength: 200000
>
>String 1
>duration in seconds: 0.0620000362396
>result: 10000000000
>OK
>
>String 2
>duration in seconds: 0.0779999494553
>result: 10000000000
>OK
>
>String 3
>duration in seconds: 3.2349998951
>result: 10000050000
>OK
>
>String 4
>duration in seconds: 5.93700003624
>result: 11250025000
>OK
>--------------------------------------------------
>
>"JCM" <joshway_without_spam@myway.com> schrieb im Newsbeitrag
>news:bss7u2$18e$1@fred.mathworks.com...
>
>[color=green]
>>EsC <christian.eslbauer@liwest.at> wrote:
>>
>>[color=darkred]
>>>hy!
>>>
>>>
>>>thanks for your explanations!
>>>
>>>
>>>i want to avoid performance-problems by repeated (very often)
>>>function-calls with very long strings.
>>>in some languages (C, PHP, Powerbuilder, ...) i have the opportunity,
>>>to pass "by value" or "by reference/pointer)".
>>>
>>>[/color]
>>The text of the string is not copied; a reference to the string/object
>>is passed into the function. You can modify objects passed into
>>functions (but only if they're mutable--strings and integers are
>>examples of immutable objects), but you cannot rebind the variable
>>holding the value in the caller's scope.
>>
>>There have been some discussions in this newsgroup about whether
>>Python is call-by-value or not. I'm not sure if I want to recommend
>>looking for them; there was no good consensus about the terminology.
>>
>>[/color]
>
>
>
>[/color]

--
Matt Goodall, Pollenation Internet Ltd
w: http://www.pollenation.net
e: matt@pollenation.net

function-arguments by reference

re: function-arguments by reference

re: function-arguments by reference

re: function-arguments by reference

re: function-arguments by reference

re: function-arguments by reference

re: function-arguments by reference

re: function-arguments by reference

Similar Python bytes

/bytes/development

/bytes/it

/bytes/about