thanks, very usefull answer.
> Immutable types (e.g. strings, numbers, tuples) are generally returned > directly from functions, rather than returned as 'output parameters'. The > ability to return multiple values easily (via "return a, b, c" & "x, y, z > = myfunc()" generally eliminates the need for 'by reference' output > parameters as used by C, C++, Java and the like. > P.S. If you *really*, *really*, *really* want to fake output parameters, > just wrap them in a list: return multiple values is ok, I usualy use a function only to return one value, for exemple : value=IsSomething(), returning true, to include that in an if statement : if (isSomething(blabla) ) ... but It's not a problem to change that habit. and as I have read somewhere about python : "Explicit is better than implicit" Dominique. "Nick Coghlan" <[EMAIL PROTECTED]> a écrit dans le message de news: [EMAIL PROTECTED] > "houbahop <d.lapasset"@bag.python.org wrote: >> Thank you everyone, but I still not understand why such a comon feature >> like passing parameters byref that is present in most serious programming >> languages is not possible in a clean way,here in python. >> >> I have the habit to never use globals as far as possible and this involve >> that my main function is passing some parameters by reference to subs to >> allow them to modify the vars. > > Python could be said to pass everything by reference. You are getting > caught more by the difference between mutable and immutable types, than by > the distinction between 'pass by reference' and 'pass by value' that other > languages have (Python actually uses a blend of the two ideas - you get > references passed in, but it you use assignment on your arguments, the > caller is not affected). > > Items which are immutable can't be modified *at all* (not just in > subroutines). The only thing you can do is take the name that references > them and make them point to something else. Items which are mutable can be > both modified and made to point to something else. > > A list is mutable: > > .>>>L = L1 = [1, 2, 3] > .>>>L is L1 > True > .>>>L += [4] > .>>>L is L1 # Modification leaves us referencing the same thing > True > .>>> print L, L1 > [1, 2, 3, 4] [1, 2, 3, 4] > .>>> L = [] > .>>> L is L1 # Assignment gives a reference to a different thing > False > .>>> print L, L1 > [] [1, 2, 3, 4] > > A string is not: > > .>>>S = S1 = "123" > .>>>S is S1 > True > .>>>S += "4" # Even modification gives a reference to a different thing > .>>>S is S1 > False > .>>>print S, S1 > "1234", "123" > >> I would be sad to break my structured programming scheme because a lack >> of feature. > > As you work with Python, you'll find a lot of the heavy lifting is done > with mutable types (particularly list and dict). For these, modification > within a function is quite straightforward (just modify the argument > directly - e.g. by adding items to a list or dictionary). > > Immutable types (e.g. strings, numbers, tuples) are generally returned > directly from functions, rather than returned as 'output parameters'. The > ability to return multiple values easily (via "return a, b, c" & "x, y, z > = myfunc()" generally eliminates the need for 'by reference' output > parameters as used by C, C++, Java and the like. > > Regards, > Nick. > > P.S. If you *really*, *really*, *really* want to fake output parameters, > just wrap them in a list: > > def myfunc(outputparam): > # Do something > outputparam[0] = result > > x = [] # Like declaring x as a pointer to something > myfunc(x) # The function fills the 'pointer' > x = x[0] # We dereference our 'pointer' > > There's generally a better way, though (which way that is depends greatly > on the context). > > Cheers, > Nick. > > -- > Nick Coghlan | [EMAIL PROTECTED] | Brisbane, Australia > --------------------------------------------------------------- > http://boredomandlaziness.skystorm.net -- http://mail.python.org/mailman/listinfo/python-list