Salut à tous, je débute en Python et je me pose certaines questions à propos du passage de paramètres à une fonction. Par adresse ou par valeur ???
 
Exemple 1

def toto(x):
    x=5

a=0
print a       => 0 - ok
toto(a)
print a       => Toujours 0 - ok, cela a été passé par valeur

 
Exemple 2

def toto(x):
    x[0]=5

a=range(10)
print a[0]     => 0 - ok
toto(a)
print a[0]     => Là j'ai 5 - ok, la fonction "toto" a reçu l'adresse de mon tableau et a pu le modifier

 
Donc il semble que si on passe à une fonction un truc simple (style un int) le passage se fait par valeur, si on lui passe un truc complexe (un tableau, un objet) le passage se fait par adresse et la fonction peut modifier le truc reçu. Me trompe-je ???
 
Question subsidiaire => il y a moyen dans l'exemple 1 de faire en sorte que toto() modifie le paramètre reçu ???
 
Merci à tous

par adresse.
 
dans ton exemple1, tu ecrase l'adresse de ton 'ancien' x.
 
l'effet est surtout visible sur les paramètres par défaut :  
 

la sortie devrait être

 
Ok. Et il y a moyen de modifier le contenu de ce "x" et non son adresse (si on imagine que la valeur est calculée par la fonction et donc qu'on ne peut pas la passer lors de l'appel à toto) ???
Python c'est extra mais quand on vient du C on aime bien savoir ce qu'il se passe au fond des choses...

Python est comme java, il fonctionne par "passage de références par valeur".
 
Une "variable" comme "x" n'est en fait qu'un label, un pointeur vers une référence Python.
 
Donc "x = 5" donne simplement le label "x" à la référence vers l'objet de valeur "5"

non et non, et ça sort 5 et 3.
 
Ce dont tu parles, c'est le fait que le paramètre par défaut est construit une fois pour toute (quand la fonction est générée), donc quand çe paramètre est mutable ça fait des effets bizarres, les gens découvrent habituellement ça en utilisant des listes, quand ils modifient l'objet référencé:

>>> def foo(bar=5):
    print bar
 
    
>>> foo()
5
>>> foo(12)
12
>>> foo(bar=12)
12
>>> foo()
5
>>> def bar(baz=[]):
    print baz
 
    
>>> bar()
[]
>>> bar([1,2,3,4])
[1, 2, 3, 4]
>>> bar()
[]
>>> def bar(baz=[]):
    baz.append(random.randint(0,9))
    return baz
 
>>> bar()
[1]
>>> bar()
[1, 1]
>>> bar()
[1, 1, 5]
>>> bar()
[1, 1, 5, 5]
>>> bar([])
[4]
>>> bar([5,1])
[5, 1, 6]
>>> bar()
[1, 1, 5, 5, 7]
>>>

x n'est pas un conteneur, c'est un label vers une référence.
 
Ca ne correspond ni a un pointeur C ni a une référence C++ (surtout pas même)

>>> def bar(baz=[]):
    baz.append(random.randint(0,9))
    return baz
 
>>> bar()
[1]
>>> bar()
[1, 1]
>>> bar()
[1, 1, 5]
>>> bar()
[1, 1, 5, 5]
>>> bar([])
[4]
>>> bar([5,1])
[5, 1, 6]
>>> bar()
[1, 1, 5, 5, 7]
>>>

Excellent exemple très démonstratif.    
Si je ne me trompe pas, il montre l'existence d'une variable spécifique au paramètre par défaut et s'il n'y a pas de paramètre, c'est cette variable qui est utilisée (d'où le fait qu'on retrouve les nombres déjà générés quand on appelle bar() sans paramètre même si on a appelé bar() avec des paramètres entre temps)
 

Ok donc on peut pas. Bon, c'est pas grave et de toute façon je suis certain que si un jour j'ai besoin que ma fonction modifie une variable, je pourrai me débrouiller autrement. C'était juste pour savoir.
 
Merci  
 
PS: Mercredi, jeudi et vendredi je suis en stage Python intensif chez Bull (Massy Palaiseau). Je vais m'éclater    

Pas variable
 
Objet
 
Objet spécifique par défaut instancié au moment de la création (de l'instanciation) de la fonction, même
 
Sinon, oui.

oups

 
J'ai développé cet exemple et créé une méthode avec paramètre par défaut identique à la fonction bar()

class cTest():
    def bar(self, tab=[]):
        tab.append(random.randint(0,9))
        return tab

v1=cTest()
v2=cTest()
tab1=v1.bar()
print tab1    => [0]
tab1=v1.bar()
print tab1    => [0, 7]
tab1=v1.bar()
print tab1    => [0, 7, 4]
tab2=v2.bar()
print tab2    => [0, 7, 4, 4]

 
Ainsi, on peut s'apercevoir que cet objet instancié lors de l'appel de la méthode "bar" est commun à tous les objets "cTest" créés...

Ben oui, puisque la fonction "bar" est instanciée en même temps que la classe "cTest". Si c'était pas le cas, les gros objets un peu lourdingues seraient inutilisables (parce que leur instanciation signifieraient créer et initialiser toutes leurs méthodes et propriétés... un peu violent)