Bonjour,
j'aurais avoir votre avis sur la raison qui a poussé la communauté
python à ne pas implémenter la surcharge de méthode en Python. Outre le
fait que les paramêtres ne soient pas typés, leur nombres peut être un
guide pour la sélection de la bonne méthode et cela simplifierait
grandement l'écriture de programmes objets (au moins pour des gens comme
moi qui ont des réflexes acquis en c++ ;-) )
En guise d'exemple, comment écririez vous simplement en python les deux
méthodes sum et sum suivantes :
def sum(x, y):
return x + y
def sum(x, y, z):
return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le
namespace courant.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Xavier Combelle
En guise d'exemple, comment écririez vous simplement en python les deux méthodes sum et sum suivantes :
def sum(x, y): return x + y
def sum(x, y, z): return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le namespace courant. Les arguments avec des valeurs par défauts, c'est nickel.
def sum(x, y, z=None): if z is None: return x + y else: return x + y + z
mais comme expliqué dans le tutoriel Avertissement important: La valeur par défaut est évaluée seulement une fois. Ceci est important lorsque la valeur par défaut est un objet modifiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fur et à mesure des appels: def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3) Ceci affichera [1] [1, 2] [1, 2, 3]
à méditer ...
En guise d'exemple, comment écririez vous simplement en python les deux
méthodes sum et sum suivantes :
def sum(x, y):
return x + y
def sum(x, y, z):
return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le
namespace courant.
Les arguments avec des valeurs par défauts, c'est nickel.
def sum(x, y, z=None):
if z is None:
return x + y
else:
return x + y + z
mais comme expliqué dans le tutoriel
Avertissement important: La valeur par défaut est évaluée seulement une
fois. Ceci est important lorsque la valeur par défaut est un objet
modifiable comme une liste ou un dictionnaire. Par exemple, la fonction
suivante accumule les arguments qui lui sont passés au fur et à mesure
des appels:
def f(a, l = []):
l.append(a)
return l
print f(1)
print f(2)
print f(3)
Ceci affichera
[1]
[1, 2]
[1, 2, 3]
En guise d'exemple, comment écririez vous simplement en python les deux méthodes sum et sum suivantes :
def sum(x, y): return x + y
def sum(x, y, z): return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le namespace courant. Les arguments avec des valeurs par défauts, c'est nickel.
def sum(x, y, z=None): if z is None: return x + y else: return x + y + z
mais comme expliqué dans le tutoriel Avertissement important: La valeur par défaut est évaluée seulement une fois. Ceci est important lorsque la valeur par défaut est un objet modifiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fur et à mesure des appels: def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3) Ceci affichera [1] [1, 2] [1, 2, 3]
à méditer ...
Yermat
Xavier Combelle wrote:
En guise d'exemple, comment écririez vous simplement en python les deux méthodes sum et sum suivantes :
def sum(x, y): return x + y
def sum(x, y, z): return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le namespace courant.
Les arguments avec des valeurs par défauts, c'est nickel. def sum(x, y, z=None): if z is None: return x + y else: return x + y + z
mais comme expliqué dans le tutoriel Avertissement important: La valeur par défaut est évaluée seulement une fois. Ceci est important lorsque la valeur par défaut est un objet modifiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fur et à mesure des appels: def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3) Ceci affichera [1] [1, 2] [1, 2, 3]
à méditer ...
Ou encore on utilise le sum de base :
sum([1,2,3]) 6
def mySum(*args): ... return sum(args)
...
mySum(1,2,3) 6
cela vous montre aussi l'astuce d'utiliser *args et **dict :
Pour l'exemple précedent, il est souvent conseillé de laisser la valeur par défaut à None et de la changer à autre chose si nécessaire. N'oubliez pas que si quelqu'un utilise votre module, il ne saura pas forcément la valeur par défaut.
def push(value, col=None): if col is None: col = [] return col.append(value)
-- Cordialement, Yermat
Xavier Combelle wrote:
En guise d'exemple, comment écririez vous simplement en python les
deux méthodes sum et sum suivantes :
def sum(x, y):
return x + y
def sum(x, y, z):
return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous
le namespace courant.
Les arguments avec des valeurs par défauts, c'est nickel.
def sum(x, y, z=None):
if z is None:
return x + y
else:
return x + y + z
mais comme expliqué dans le tutoriel
Avertissement important: La valeur par défaut est évaluée seulement une
fois. Ceci est important lorsque la valeur par défaut est un objet
modifiable comme une liste ou un dictionnaire. Par exemple, la fonction
suivante accumule les arguments qui lui sont passés au fur et à mesure
des appels:
def f(a, l = []):
l.append(a)
return l
print f(1)
print f(2)
print f(3)
Ceci affichera
[1]
[1, 2]
[1, 2, 3]
à méditer ...
Ou encore on utilise le sum de base :
sum([1,2,3])
6
def mySum(*args):
... return sum(args)
...
mySum(1,2,3)
6
cela vous montre aussi l'astuce d'utiliser *args et **dict :
Pour l'exemple précedent, il est souvent conseillé de laisser la valeur
par défaut à None et de la changer à autre chose si nécessaire.
N'oubliez pas que si quelqu'un utilise votre module, il ne saura pas
forcément la valeur par défaut.
def push(value, col=None):
if col is None:
col = []
return col.append(value)
En guise d'exemple, comment écririez vous simplement en python les deux méthodes sum et sum suivantes :
def sum(x, y): return x + y
def sum(x, y, z): return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le namespace courant.
Les arguments avec des valeurs par défauts, c'est nickel. def sum(x, y, z=None): if z is None: return x + y else: return x + y + z
mais comme expliqué dans le tutoriel Avertissement important: La valeur par défaut est évaluée seulement une fois. Ceci est important lorsque la valeur par défaut est un objet modifiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fur et à mesure des appels: def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3) Ceci affichera [1] [1, 2] [1, 2, 3]
à méditer ...
Ou encore on utilise le sum de base :
sum([1,2,3]) 6
def mySum(*args): ... return sum(args)
...
mySum(1,2,3) 6
cela vous montre aussi l'astuce d'utiliser *args et **dict :
Pour l'exemple précedent, il est souvent conseillé de laisser la valeur par défaut à None et de la changer à autre chose si nécessaire. N'oubliez pas que si quelqu'un utilise votre module, il ne saura pas forcément la valeur par défaut.
def push(value, col=None): if col is None: col = [] return col.append(value)
-- Cordialement, Yermat
Jerome
Yermat wrote:
Xavier Combelle wrote:
En guise d'exemple, comment écririez vous simplement en python les deux méthodes sum et sum suivantes :
def sum(x, y): return x + y
def sum(x, y, z): return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le namespace courant.
Les arguments avec des valeurs par défauts, c'est nickel. def sum(x, y, z=None): if z is None: return x + y else: return x + y + z
mais comme expliqué dans le tutoriel Avertissement important: La valeur par défaut est évaluée seulement une fois. Ceci est important lorsque la valeur par défaut est un objet modifiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fur et à mesure des appels: def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3) Ceci affichera [1] [1, 2] [1, 2, 3]
à méditer ...
Ou encore on utilise le sum de base :
sum([1,2,3]) 6
def mySum(*args): ... return sum(args)
...
mySum(1,2,3) 6
cela vous montre aussi l'astuce d'utiliser *args et **dict :
Pour l'exemple précedent, il est souvent conseillé de laisser la valeur par défaut à None et de la changer à autre chose si nécessaire. N'oubliez pas que si quelqu'un utilise votre module, il ne saura pas forcément la valeur par défaut.
def push(value, col=None): if col is None: col = [] return col.append(value)
Merci pour vos réponses.
Pour sum, c'était bien évidemment un exemple et la solution utilisant les fonctions intégrés de python ne m'intéresse pas ;-).
Pour la solution avec les *args et *argd, je pense que c'est la solution la plus élégante et je vais probablement l'utiliser.
Yermat wrote:
Xavier Combelle wrote:
En guise d'exemple, comment écririez vous simplement en python les
deux méthodes sum et sum suivantes :
def sum(x, y):
return x + y
def sum(x, y, z):
return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous
le namespace courant.
Les arguments avec des valeurs par défauts, c'est nickel.
def sum(x, y, z=None):
if z is None:
return x + y
else:
return x + y + z
mais comme expliqué dans le tutoriel
Avertissement important: La valeur par défaut est évaluée seulement
une fois. Ceci est important lorsque la valeur par défaut est un objet
modifiable comme une liste ou un dictionnaire. Par exemple, la
fonction suivante accumule les arguments qui lui sont passés au fur et
à mesure des appels:
def f(a, l = []):
l.append(a)
return l
print f(1)
print f(2)
print f(3)
Ceci affichera
[1]
[1, 2]
[1, 2, 3]
à méditer ...
Ou encore on utilise le sum de base :
sum([1,2,3])
6
def mySum(*args):
... return sum(args)
...
mySum(1,2,3)
6
cela vous montre aussi l'astuce d'utiliser *args et **dict :
Pour l'exemple précedent, il est souvent conseillé de laisser la valeur
par défaut à None et de la changer à autre chose si nécessaire.
N'oubliez pas que si quelqu'un utilise votre module, il ne saura pas
forcément la valeur par défaut.
def push(value, col=None):
if col is None:
col = []
return col.append(value)
Merci pour vos réponses.
Pour sum, c'était bien évidemment un exemple et la solution utilisant
les fonctions intégrés de python ne m'intéresse pas ;-).
Pour la solution avec les *args et *argd, je pense que c'est la solution
la plus élégante et je vais probablement l'utiliser.
En guise d'exemple, comment écririez vous simplement en python les deux méthodes sum et sum suivantes :
def sum(x, y): return x + y
def sum(x, y, z): return x + y + z
De manière, bien sur, à ce que les deux puissent être utilisées sous le namespace courant.
Les arguments avec des valeurs par défauts, c'est nickel. def sum(x, y, z=None): if z is None: return x + y else: return x + y + z
mais comme expliqué dans le tutoriel Avertissement important: La valeur par défaut est évaluée seulement une fois. Ceci est important lorsque la valeur par défaut est un objet modifiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fur et à mesure des appels: def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3) Ceci affichera [1] [1, 2] [1, 2, 3]
à méditer ...
Ou encore on utilise le sum de base :
sum([1,2,3]) 6
def mySum(*args): ... return sum(args)
...
mySum(1,2,3) 6
cela vous montre aussi l'astuce d'utiliser *args et **dict :
Pour l'exemple précedent, il est souvent conseillé de laisser la valeur par défaut à None et de la changer à autre chose si nécessaire. N'oubliez pas que si quelqu'un utilise votre module, il ne saura pas forcément la valeur par défaut.
def push(value, col=None): if col is None: col = [] return col.append(value)
Merci pour vos réponses.
Pour sum, c'était bien évidemment un exemple et la solution utilisant les fonctions intégrés de python ne m'intéresse pas ;-).
Pour la solution avec les *args et *argd, je pense que c'est la solution la plus élégante et je vais probablement l'utiliser.
Yermat
Jerome wrote:
Yermat wrote:
Xavier Combelle wrote:
[...] Pour sum, c'était bien évidemment un exemple et la solution utilisant
les fonctions intégrés de python ne m'intéresse pas ;-).
C'est bien pour cela que je n'ai pas insisté. Malheureusement dés que l'on parle de ce problème, tout le monde donne le même exemple... ;-)
Pour la solution avec les *args et *argd, je pense que c'est la solution la plus élégante et je vais probablement l'utiliser.
Tout à fait. C'est aussi celle qui est le plus dans l'exprit python... De plus si une fonction réagit différement selon ses arguments, il devrait y avoir plusieurs fonctions avec des noms différents...
-- Cordialement, Yermat
Jerome wrote:
Yermat wrote:
Xavier Combelle wrote:
[...]
Pour sum, c'était bien évidemment un exemple et la solution utilisant
les fonctions intégrés de python ne m'intéresse pas ;-).
C'est bien pour cela que je n'ai pas insisté. Malheureusement dés que
l'on parle de ce problème, tout le monde donne le même exemple... ;-)
Pour la solution avec les *args et *argd, je pense que c'est la solution
la plus élégante et je vais probablement l'utiliser.
Tout à fait. C'est aussi celle qui est le plus dans l'exprit python...
De plus si une fonction réagit différement selon ses arguments, il
devrait y avoir plusieurs fonctions avec des noms différents...
[...] Pour sum, c'était bien évidemment un exemple et la solution utilisant
les fonctions intégrés de python ne m'intéresse pas ;-).
C'est bien pour cela que je n'ai pas insisté. Malheureusement dés que l'on parle de ce problème, tout le monde donne le même exemple... ;-)
Pour la solution avec les *args et *argd, je pense que c'est la solution la plus élégante et je vais probablement l'utiliser.
Tout à fait. C'est aussi celle qui est le plus dans l'exprit python... De plus si une fonction réagit différement selon ses arguments, il devrait y avoir plusieurs fonctions avec des noms différents...
