fonction None ?

Le
Méta-MCI \(MVP\)
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
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses Page 1 / 2
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Michel Leunen
Le #1753283
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
--
Michel Leunen
http://linux.leunen.com

kib
Le #1753863
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.

Une page qui explique tout ça en détails :

http://homepage.mac.com/s_lott/books/python/htmlchunks/ch15s09.html


Bruno Desthuilliers
Le #1753862
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


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
Le #1754441
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.

params = ('a', 'b', 'c')
def fun1(params):
... print params



...
def fun2(*params):
... print params



...
def fun3(un, deux, *params):
... print un, deux, params



...
for fun in (fun1, fun2, fun3):
... try:



... print "calling %s(params)" % fun
... fun(params)
... except Exception, e:
... print e
... try:
... print "calling %s(*params)" % fun
... fun(*params)
... except Exception, e:
... print e
...
calling <function fun1 at 0xb7dc7374>(params)
('a', 'b', 'c')
calling <function fun1 at 0xb7dc7374>(*params)
fun1() takes exactly 1 argument (3 given)
calling <function fun2 at 0xb7dc73ac>(params)
(('a', 'b', 'c'),)
calling <function fun2 at 0xb7dc73ac>(*params)
('a', 'b', 'c')
calling <function fun3 at 0xb7dc73e4>(params)
fun3() takes at least 2 arguments (1 given)
calling <function fun3 at 0xb7dc73e4>(*params)
a b ('c',)






La même chose existe pour les arguments nommés, avec la notation ** (le
paramètre étant canoniquement nommé kwargs ou kw (pour 'keywords
args')), ie:
def func(a, b, **kw):
... print a, b, kw



...
func(1, 2, parrot="dead", knight="ni")
1 2 {'knight': 'ni', 'parrot': 'dead'}




avec la réciproque pour passer un dict:

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
Le #1754440
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

Pierre Quentel
Le #1758027
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

Laurent Pointal
Le #1759265
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\)
Le #1761086
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
Méta-MCI \(MVP\)
Le #1759263
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

Méta-MCI (MVP)
Le #1759262
'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

Publicité
Poster une réponse
Anonyme