newbie questions

[houbahop]

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" <ncoghlan at iinet.net.au> a écrit dans le message de news: 
mailman.7597.1102940166.5135.python-list at python.org...
> "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   |   ncoghlan at email.com   |   Brisbane, Australia
> ---------------------------------------------------------------
>             http://boredomandlaziness.skystorm.net