Pour limiter les instructions, lors d'une utilisation massive de
callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre :
def void(*param):
pass
Mais cela cela entraînerait la création d'un espace de noms, des
affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Désolé de sauter pieds joints dans ce thread mais j'ai une petite question de débutant complet. J'ai cherché dans la doc mais je n'arrive pas à trouver. Quel est le sens de l'* devant param dans le définition de la fonction? Quelle différence entre def void(*param) et def void(param)?
Michel -- Michel Leunen http://linux.leunen.com
Méta-MCI (MVP) wrote:
def void(*param):
pass
Désolé de sauter pieds joints dans ce thread mais j'ai une petite
question de débutant complet. J'ai cherché dans la doc mais je n'arrive
pas à trouver.
Quel est le sens de l'* devant param dans le définition de la fonction?
Quelle différence entre def void(*param) et def void(param)?
Désolé de sauter pieds joints dans ce thread mais j'ai une petite question de débutant complet. J'ai cherché dans la doc mais je n'arrive pas à trouver. Quel est le sens de l'* devant param dans le définition de la fonction? Quelle différence entre def void(*param) et def void(param)?
Michel -- Michel Leunen http://linux.leunen.com
kib
Méta-MCI (MVP) wrote:
def void(*param): pass
Désolé de sauter pieds joints dans ce thread mais j'ai une petite question de débutant complet. J'ai cherché dans la doc mais je n'arrive pas à trouver. Quel est le sens de l'* devant param dans le définition de la fonction? Quelle différence entre def void(*param) et def void(param)?
Michel
Avec ceci, param est un tuple contenant les paramètres que tu transmets à la fonction.
Tu as aussi la syntaxe suivante : "def void(**param)" qui elle emploie un dictionnaire.
Désolé de sauter pieds joints dans ce thread mais j'ai une petite
question de débutant complet. J'ai cherché dans la doc mais je n'arrive
pas à trouver.
Quel est le sens de l'* devant param dans le définition de la fonction?
Quelle différence entre def void(*param) et def void(param)?
Michel
Avec ceci, param est un tuple contenant les paramètres que tu transmets
à la fonction.
Tu as aussi la syntaxe suivante : "def void(**param)" qui elle emploie
un dictionnaire.
Désolé de sauter pieds joints dans ce thread mais j'ai une petite question de débutant complet. J'ai cherché dans la doc mais je n'arrive pas à trouver. Quel est le sens de l'* devant param dans le définition de la fonction? Quelle différence entre def void(*param) et def void(param)?
Michel
Avec ceci, param est un tuple contenant les paramètres que tu transmets à la fonction.
Tu as aussi la syntaxe suivante : "def void(**param)" qui elle emploie un dictionnaire.
Pour limiter les instructions, lors d'une utilisation massive de callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre : def void(*param): pass
tant qu'a faire, ajoute un **kw
Mais cela cela entraînerait la création d'un espace de noms, des affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Si quelqu'un a une idée...
A ma connaissance, yapa. Et effectivement, quand j'y pense, y aurait éventuellement matière à un PEP.
Bruno Desthuilliers
Méta-MCI (MVP) wrote:
def void(*param): pass
Désolé de sauter pieds joints dans ce thread mais j'ai une petite question de débutant complet. J'ai cherché dans la doc mais je n'arrive pas à trouver. Quel est le sens de l'* devant param dans le définition de la fonction?
Arguments variables positionnels. La fonction accepte un nombre quelconque (<%5) d'arguments positionnels optionnels, qui seront disponible sous la forme d'un tuple nommé 'params' (nb: traditionnellement, on utilise 'args').
La réciproque lors de l'appel d'une fonction est fonction(*<sequence>), cf ci-dessous.
Quelle différence entre def void(*param) et def void(param)?
Dans le second cas, la fonction attend un unique argument.
kw = {"a":"A", "b":"B", "machin":"bidule"} func(**kw) A B {'machin': 'bidule'}
Tout ceci étant largement documenté, of course: http://www.python.org/doc/current/tut/node6.html#SECTION006700000000000000000
Méta-MCI (MVP) wrote:
def void(*param):
pass
Désolé de sauter pieds joints dans ce thread mais j'ai une petite
question de débutant complet. J'ai cherché dans la doc mais je n'arrive
pas à trouver.
Quel est le sens de l'* devant param dans le définition de la fonction?
Arguments variables positionnels. La fonction accepte un nombre
quelconque (<%5) d'arguments positionnels optionnels, qui seront
disponible sous la forme d'un tuple nommé 'params' (nb:
traditionnellement, on utilise 'args').
La réciproque lors de l'appel d'une fonction est
fonction(*<sequence>), cf ci-dessous.
Quelle différence entre def void(*param) et def void(param)?
Dans le second cas, la fonction attend un unique argument.
Désolé de sauter pieds joints dans ce thread mais j'ai une petite question de débutant complet. J'ai cherché dans la doc mais je n'arrive pas à trouver. Quel est le sens de l'* devant param dans le définition de la fonction?
Arguments variables positionnels. La fonction accepte un nombre quelconque (<%5) d'arguments positionnels optionnels, qui seront disponible sous la forme d'un tuple nommé 'params' (nb: traditionnellement, on utilise 'args').
La réciproque lors de l'appel d'une fonction est fonction(*<sequence>), cf ci-dessous.
Quelle différence entre def void(*param) et def void(param)?
Dans le second cas, la fonction attend un unique argument.
kw = {"a":"A", "b":"B", "machin":"bidule"} func(**kw) A B {'machin': 'bidule'}
Tout ceci étant largement documenté, of course: http://www.python.org/doc/current/tut/node6.html#SECTION006700000000000000000
Michel Leunen
Bruno Desthuilliers wrote:
Tout ceci étant largement documenté, of course: http://www.python.org/doc/current/tut/node6.html#SECTION006700000000000000000
Oui, c'est effectivement facile à trouver quand on sait ce qu'on cherche :-) Merci à ceux qui ont répondu et particulièrement à Bruno pour son explication détaillée.
Michel
-- Michel Leunen http://linux.leunen.com
Bruno Desthuilliers wrote:
Tout ceci étant largement documenté, of course:
http://www.python.org/doc/current/tut/node6.html#SECTION006700000000000000000
Oui, c'est effectivement facile à trouver quand on sait ce qu'on cherche :-)
Merci à ceux qui ont répondu et particulièrement à Bruno pour son
explication détaillée.
Tout ceci étant largement documenté, of course: http://www.python.org/doc/current/tut/node6.html#SECTION006700000000000000000
Oui, c'est effectivement facile à trouver quand on sait ce qu'on cherche :-) Merci à ceux qui ont répondu et particulièrement à Bruno pour son explication détaillée.
Michel
-- Michel Leunen http://linux.leunen.com
Pierre Quentel
On 20 mar, 23:05, "Méta-MCI (MVP)" wrote:
Bonsoir !
Pour limiter les instructions, lors d'une utilisation massive de callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre : def void(*param): pass Mais cela cela entraînerait la création d'un espace de noms, des affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Si quelqu'un a une idée...
@+
Michel Claveau
Bonjour,
J'ai beau me gratter la tête, je n'arrive pas à voir ce que c'est, une "utilisation massive de callbacks" qui justifierait l'existence d'une fonction qui ne fait rien et ne consomme aucune ressource
Tu pourrais nous désobfusquer le truc avec un pitit exemple ?
Pierre
On 20 mar, 23:05, "Méta-MCI (MVP)" <enleverlesX.X...@XmclaveauX.com>
wrote:
Bonsoir !
Pour limiter les instructions, lors d'une utilisation massive de
callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre :
def void(*param):
pass
Mais cela cela entraînerait la création d'un espace de noms, des
affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Si quelqu'un a une idée...
@+
Michel Claveau
Bonjour,
J'ai beau me gratter la tête, je n'arrive pas à voir ce que c'est, une
"utilisation massive de callbacks" qui justifierait l'existence d'une
fonction qui ne fait rien et ne consomme aucune ressource
Tu pourrais nous désobfusquer le truc avec un pitit exemple ?
Pour limiter les instructions, lors d'une utilisation massive de callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre : def void(*param): pass Mais cela cela entraînerait la création d'un espace de noms, des affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Si quelqu'un a une idée...
@+
Michel Claveau
Bonjour,
J'ai beau me gratter la tête, je n'arrive pas à voir ce que c'est, une "utilisation massive de callbacks" qui justifierait l'existence d'une fonction qui ne fait rien et ne consomme aucune ressource
Tu pourrais nous désobfusquer le truc avec un pitit exemple ?
Pierre
Laurent Pointal
Le Thu, 20 Mar 2008 23:05:40 +0100, Méta-MCI (MVP) a écrit :
Bonsoir !
Pour limiter les instructions, lors d'une utilisation massive de callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre : def void(*param): pass Mais cela cela entraînerait la création d'un espace de noms, des affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Si quelqu'un a une idée...
Avec lambda ?
@+
Michel Claveau
-- Laurent POINTAL -
Le Thu, 20 Mar 2008 23:05:40 +0100, Méta-MCI (MVP) a écrit :
Bonsoir !
Pour limiter les instructions, lors d'une utilisation massive de
callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre :
def void(*param):
pass
Mais cela cela entraînerait la création d'un espace de noms, des
affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Le Thu, 20 Mar 2008 23:05:40 +0100, Méta-MCI (MVP) a écrit :
Bonsoir !
Pour limiter les instructions, lors d'une utilisation massive de callbacks, je cherche une fonction "None".
Certes, je pourrais faire un truc du genre : def void(*param): pass Mais cela cela entraînerait la création d'un espace de noms, des affectations de noms aux paramètres, etc.
J'aurais aimé une pseudo fonction qui évite même l'appel.
Si quelqu'un a une idée...
Avec lambda ?
@+
Michel Claveau
-- Laurent POINTAL -
Méta-MCI \(MVP\)
Bonsoir !
En pratique, je définis un truc d'impression. Il y a donc une classe "ligne", qui contient des "champs". Chaque champ est caractérisé par une position, un format, divers attributs, et une fonction callback. Le but de cette fonction est de gérer les exceptions. Elle est appelée après récupération des attributs des champs, mais avant leur utilisation. Si, par exemple, un champ est imprimé en bleu, l'appel de la callgirl, heu... de la callback, permet de choisir du rouge, si, par exemple, il s'agit d'une valeur négative.
Passer par une fonction callback permet de séparer l'utilisation, du code lui-même.
Dans la pratique, il arrive souvent à ces états de faire entre 200 et 1000 pages. A raison de 75 lignes par page, et de 5 à 15 champs par ligne, on arrive vite au taf annoncé.
Certes, pour l'instant, j'utilise un if callback: callback(..., ...., ....
Mais, une instruction gagnée, c'est une instruction gagnée ! (merci, monsieur de Lapalisse).
Et puis, le principe d'une fonction None(...) qui squizze l'appel est loin d'être anormal.
J'espère avoir été un poil plus clair.
@+
Michel Claveau
Bonsoir !
En pratique, je définis un truc d'impression.
Il y a donc une classe "ligne", qui contient des "champs". Chaque champ
est caractérisé par une position, un format, divers attributs, et une
fonction callback.
Le but de cette fonction est de gérer les exceptions. Elle est appelée
après récupération des attributs des champs, mais avant leur
utilisation.
Si, par exemple, un champ est imprimé en bleu, l'appel de la callgirl,
heu... de la callback, permet de choisir du rouge, si, par exemple, il
s'agit d'une valeur négative.
Passer par une fonction callback permet de séparer l'utilisation, du
code lui-même.
Dans la pratique, il arrive souvent à ces états de faire entre 200 et
1000 pages. A raison de 75 lignes par page, et de 5 à 15 champs par
ligne, on arrive vite au taf annoncé.
Certes, pour l'instant, j'utilise un
if callback: callback(..., ...., ....
Mais, une instruction gagnée, c'est une instruction gagnée ! (merci,
monsieur de Lapalisse).
Et puis, le principe d'une fonction None(...) qui squizze l'appel est
loin d'être anormal.
En pratique, je définis un truc d'impression. Il y a donc une classe "ligne", qui contient des "champs". Chaque champ est caractérisé par une position, un format, divers attributs, et une fonction callback. Le but de cette fonction est de gérer les exceptions. Elle est appelée après récupération des attributs des champs, mais avant leur utilisation. Si, par exemple, un champ est imprimé en bleu, l'appel de la callgirl, heu... de la callback, permet de choisir du rouge, si, par exemple, il s'agit d'une valeur négative.
Passer par une fonction callback permet de séparer l'utilisation, du code lui-même.
Dans la pratique, il arrive souvent à ces états de faire entre 200 et 1000 pages. A raison de 75 lignes par page, et de 5 à 15 champs par ligne, on arrive vite au taf annoncé.
Certes, pour l'instant, j'utilise un if callback: callback(..., ...., ....
Mais, une instruction gagnée, c'est une instruction gagnée ! (merci, monsieur de Lapalisse).
Et puis, le principe d'une fonction None(...) qui squizze l'appel est loin d'être anormal.
J'espère avoir été un poil plus clair.
@+
Michel Claveau
Méta-MCI \(MVP\)
Bonsoir !
quand j'y pense, y aurait éventuellement matière à un PEP.
OK, mais un PEP, c'est en anglais... Alors, si tu te sens, vas-y (ou, plutôt, Go! ) Mais perso, c'est largement au-delà de mes capacités épistolaires-zé-linguistiques.
@-salutations -- Michel Claveau
Bonsoir !
quand j'y pense, y aurait éventuellement matière à un PEP.
OK, mais un PEP, c'est en anglais...
Alors, si tu te sens, vas-y (ou, plutôt, Go! )
Mais perso, c'est largement au-delà de mes capacités
épistolaires-zé-linguistiques.
quand j'y pense, y aurait éventuellement matière à un PEP.
OK, mais un PEP, c'est en anglais... Alors, si tu te sens, vas-y (ou, plutôt, Go! ) Mais perso, c'est largement au-delà de mes capacités épistolaires-zé-linguistiques.
@-salutations -- Michel Claveau
Méta-MCI (MVP)
'soir !
Avec lambda ?
Là, j'ai des doutes sur l'efficacité de lambda. Déjà, relativement à un simple IF (actuellement) ; mais surtout face à un "None-appel"
@+
Michel Claveau
'soir !
Avec lambda ?
Là, j'ai des doutes sur l'efficacité de lambda. Déjà, relativement à un
simple IF (actuellement) ; mais surtout face à un "None-appel"
