j'ai défini une fonction dont le premier argument attendu est une
méthode d'instance.
Tout fonctionnait nickel jusqu'au moment ou j'ai été confronté au cas ou
la méthode passée en argument a elle-même besoin de pas mal d'arguments
(nommés).
Je me suis dis "pas de problème, j'ai repéré la fonction qui va bien, à
savoir apply()"....
Sauf que l'utilisation de apply() est déconseillée.
D'un autre coté il me semble avoir lu je ne sais plus ou (un document
qui ressemble à la PEP8) que les protos de fonctions/méthodes avec *args
et **kwargs étaient à éviter à la faveur d'arguments positionnels et/ou
nommés explicites.
La question est donc très simple: est ce que j'utilise apply() dans ma
fonction ou est ce que je modifie le proto de mes méthodes avec **kwargs
comme argument (beurk!) ?
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
Bruno Desthuilliers
Bonsoir,
j'ai défini une fonction dont le premier argument attendu est une méthode d'instance. Tout fonctionnait nickel jusqu'au moment ou j'ai été confronté au cas ou la méthode passée en argument a elle-même besoin de pas mal d'arguments (nommés). Je me suis dis "pas de problème, j'ai repéré la fonction qui va bien, à savoir apply()"....
deprecated
Sauf que l'utilisation de apply() est déconseillée.
!-)
D'un autre coté il me semble avoir lu je ne sais plus ou (un document qui ressemble à la PEP8) que les protos de fonctions/méthodes avec *args et **kwargs étaient à éviter à la faveur d'arguments positionnels et/ou nommés explicites. La question est donc très simple: est ce que j'utilise apply() dans ma fonction ou est ce que je modifie le proto de mes méthodes avec **kwargs comme argument (beurk!) ?
Ni l'un ni l'autre... Par contre, relire la doc et faire quelques essais, ça peut être un bon début !-)
class MaClasse(object): def __init__(self, name): self.name = name
def fait_ceci(self, toto, tataB): print "%s (name=%s) called with toto=%s and tata=%s" % (self, self.name, toto, tata)
j'ai défini une fonction dont le premier argument attendu est une
méthode d'instance.
Tout fonctionnait nickel jusqu'au moment ou j'ai été confronté au cas ou
la méthode passée en argument a elle-même besoin de pas mal d'arguments
(nommés).
Je me suis dis "pas de problème, j'ai repéré la fonction qui va bien, à
savoir apply()"....
deprecated
Sauf que l'utilisation de apply() est déconseillée.
!-)
D'un autre coté il me semble avoir lu je ne sais plus ou (un document
qui ressemble à la PEP8) que les protos de fonctions/méthodes avec *args
et **kwargs étaient à éviter à la faveur d'arguments positionnels et/ou
nommés explicites.
La question est donc très simple: est ce que j'utilise apply() dans ma
fonction ou est ce que je modifie le proto de mes méthodes avec **kwargs
comme argument (beurk!) ?
Ni l'un ni l'autre... Par contre, relire la doc et faire quelques
essais, ça peut être un bon début !-)
class MaClasse(object):
def __init__(self, name):
self.name = name
def fait_ceci(self, toto, tataB):
print "%s (name=%s) called with toto=%s and tata=%s"
% (self, self.name, toto, tata)
j'ai défini une fonction dont le premier argument attendu est une méthode d'instance. Tout fonctionnait nickel jusqu'au moment ou j'ai été confronté au cas ou la méthode passée en argument a elle-même besoin de pas mal d'arguments (nommés). Je me suis dis "pas de problème, j'ai repéré la fonction qui va bien, à savoir apply()"....
deprecated
Sauf que l'utilisation de apply() est déconseillée.
!-)
D'un autre coté il me semble avoir lu je ne sais plus ou (un document qui ressemble à la PEP8) que les protos de fonctions/méthodes avec *args et **kwargs étaient à éviter à la faveur d'arguments positionnels et/ou nommés explicites. La question est donc très simple: est ce que j'utilise apply() dans ma fonction ou est ce que je modifie le proto de mes méthodes avec **kwargs comme argument (beurk!) ?
Ni l'un ni l'autre... Par contre, relire la doc et faire quelques essais, ça peut être un bon début !-)
class MaClasse(object): def __init__(self, name): self.name = name
def fait_ceci(self, toto, tataB): print "%s (name=%s) called with toto=%s and tata=%s" % (self, self.name, toto, tata)
j'ai défini une fonction dont le premier argument attendu est une méthode d'instance. Tout fonctionnait nickel jusqu'au moment ou j'ai été confronté au cas ou la méthode passée en argument a elle-même besoin de pas mal d'arguments (nommés). Je me suis dis "pas de problème, j'ai repéré la fonction qui va bien, à savoir apply()"....
deprecated
Sauf que l'utilisation de apply() est déconseillée.
!-)
D'un autre coté il me semble avoir lu je ne sais plus ou (un document qui ressemble à la PEP8) que les protos de fonctions/méthodes avec *args et **kwargs étaient à éviter à la faveur d'arguments positionnels et/ou nommés explicites. La question est donc très simple: est ce que j'utilise apply() dans ma fonction ou est ce que je modifie le proto de mes méthodes avec **kwargs comme argument (beurk!) ?
Ni l'un ni l'autre... Par contre, relire la doc et faire quelques essais, ça peut être un bon début !-) prout ;o)
class MaClasse(object): def __init__(self, name): self.name = name
def fait_ceci(self, toto, tataB): print "%s (name=%s) called with toto=%s and tata=%s" % (self, self.name, toto, tata)
Ca ne m'était tout simplement pas venu à l'esprit (tout perturbé que j'étais à l'idée de refaire tous les protos de mes belles méthodes ... ;o) Pour rebondir sur tes conseils de relecture de docs et d'essais (une petite demi-heure* tous les matins de "gym" me fait le plus grand bien), je dirai que je me retrouve quand même avec des **kwargs (héhé).
Si, si, grand merci, en plus t'as parfaitement capté (correctement du premier coup :) mes besoins, pas forcément exprimés avec la terminologie adéquate ....
* tiens, je vais me relire la PEP8, ça peut pas faire de mal
Bonsoir,
j'ai défini une fonction dont le premier argument attendu est une
méthode d'instance.
Tout fonctionnait nickel jusqu'au moment ou j'ai été confronté au cas ou
la méthode passée en argument a elle-même besoin de pas mal d'arguments
(nommés).
Je me suis dis "pas de problème, j'ai repéré la fonction qui va bien, à
savoir apply()"....
deprecated
Sauf que l'utilisation de apply() est déconseillée.
!-)
D'un autre coté il me semble avoir lu je ne sais plus ou (un document
qui ressemble à la PEP8) que les protos de fonctions/méthodes avec *args
et **kwargs étaient à éviter à la faveur d'arguments positionnels et/ou
nommés explicites.
La question est donc très simple: est ce que j'utilise apply() dans ma
fonction ou est ce que je modifie le proto de mes méthodes avec **kwargs
comme argument (beurk!) ?
Ni l'un ni l'autre... Par contre, relire la doc et faire quelques
essais, ça peut être un bon début !-) prout ;o)
class MaClasse(object):
def __init__(self, name):
self.name = name
def fait_ceci(self, toto, tataB):
print "%s (name=%s) called with toto=%s and tata=%s"
% (self, self.name, toto, tata)
Ca ne m'était tout simplement pas venu à l'esprit (tout perturbé que
j'étais à l'idée de refaire tous les protos de mes belles méthodes ... ;o)
Pour rebondir sur tes conseils de relecture de docs et d'essais (une
petite demi-heure* tous les matins de "gym" me fait le plus grand bien),
je dirai que je me retrouve quand même avec des **kwargs (héhé).
Si, si, grand merci, en plus t'as parfaitement capté (correctement du
premier coup :) mes besoins, pas forcément exprimés avec la terminologie
adéquate ....
* tiens, je vais me relire la PEP8, ça peut pas faire de mal
j'ai défini une fonction dont le premier argument attendu est une méthode d'instance. Tout fonctionnait nickel jusqu'au moment ou j'ai été confronté au cas ou la méthode passée en argument a elle-même besoin de pas mal d'arguments (nommés). Je me suis dis "pas de problème, j'ai repéré la fonction qui va bien, à savoir apply()"....
deprecated
Sauf que l'utilisation de apply() est déconseillée.
!-)
D'un autre coté il me semble avoir lu je ne sais plus ou (un document qui ressemble à la PEP8) que les protos de fonctions/méthodes avec *args et **kwargs étaient à éviter à la faveur d'arguments positionnels et/ou nommés explicites. La question est donc très simple: est ce que j'utilise apply() dans ma fonction ou est ce que je modifie le proto de mes méthodes avec **kwargs comme argument (beurk!) ?
Ni l'un ni l'autre... Par contre, relire la doc et faire quelques essais, ça peut être un bon début !-) prout ;o)
class MaClasse(object): def __init__(self, name): self.name = name
def fait_ceci(self, toto, tataB): print "%s (name=%s) called with toto=%s and tata=%s" % (self, self.name, toto, tata)
Ca ne m'était tout simplement pas venu à l'esprit (tout perturbé que j'étais à l'idée de refaire tous les protos de mes belles méthodes ... ;o) Pour rebondir sur tes conseils de relecture de docs et d'essais (une petite demi-heure* tous les matins de "gym" me fait le plus grand bien), je dirai que je me retrouve quand même avec des **kwargs (héhé).
Si, si, grand merci, en plus t'as parfaitement capté (correctement du premier coup :) mes besoins, pas forcément exprimés avec la terminologie adéquate ....
* tiens, je vais me relire la PEP8, ça peut pas faire de mal
Méta-MCI \(MVP\)
Bonjour !
Y a-t'il une (bonne) raison, pour ne pas appeler la fonction "Apply" ?
