Ubuntu-fr

Diiidouuuuu

None : comment ça marche ?

--------------------------------------------------------------------------------

Bonjour,

voilà, mon problème est tout bête mais très embarassant.

J'ai déclaré un paramètre d'une méthode avec comme valeur par défaut, None.

S'en suit un test dans le corps de la méthode :

if param == None:
...

Seulement voilà, le test ne marche pas mais alors vraiment pas.

et if param is None:

... non plus (vous l'auriez deviné)

Qu'ai-je donc fait pour mériter cela ? 

Au fait, ma version de python, c'est 2.5.2

Merci d'avance

Link31

Re : None : comment ça marche ?

Ben pourtant ça semble fonctionner chez moi :

link31@linux ~ % python
Python 2.5.2 (r252:60911, Nov 17 2008, 19:47:46) 
[GCC 4.1.2 (Gentoo 4.1.2 p1.0.1)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo(param = None):
...     if param == None:
...             print 'ok'
... 
>>> foo()
ok
>>> foo(42)
>>> foo('42')
>>> foo(None)
ok
>>>

Je précise que je ne connais pas ce langage, si ça se trouve la syntaxe n'est même pas bonne, mais on dirait quand même que ça marche.

Diiidouuuuu

Re : None : comment ça marche ?

Je te remercie, Link.
Effectivement, ça marche aussi chez moi.

Il y a peut-être un effet induit quelque part dans mon code.
Je suis en train d'essayer d'identifier ce qui provoque ce comportement doûteux.

Je vous préviendrai si j'ai trouvé.

Pour être plus précis, c'est un paramètre d'un constructeur à qui je donne une valeur par défaut qui est None.

Ce constructeur, je l'appelle depuis un constructeur d'une classe fille.

Pour cela, je fais : classe_mere(self).__init__ en transmettant une partie de ses paramètres dont celui qui à None par défaut.

Cela donne :

class classe_mere:
   def __init__(..., param = None, ...):
        .
        .
        .
        if param == None:
           ...
   #end def
#end class

class classe_fille(classe_mere):

     def __init__(..., param = None, ...):

          classe_mere(self).__init__(...., param, ...)
   
     #end def
#end class

Voilà, voilà.
Je pensais qu'il s'agissait d'une méconnaissance triviale de ma part.
Après avoir feuilleté le bouquin en ligne "Apprendre Python" (le voilier en couverture), j'ai vu que le test à None était autorisé. Alors, c'est pour ça que je m'en suis remis à vous.

Je dois faire quelque chose de déconseillé voire d'interdit mais l'interpréteur ne m'en dit rien non plus.

Donc, je vais m'atteler à trouver ce qui se passe.

Merci encore

Didouuuuuuu

Re : None : comment ça marche ?

Je n'utilisais pas la syntaxe usuelle d'appel à un constructeur de classe mère.

N'y connaissant rien, j'ai pensé à la convertion de self en une instance de la classe mère pour invoquer le constructeur de la classe mère :

classe_mere(self).__init__(...)

alors qu'il faut faire : classe_mere.__init__(self, ...)

twinsen93

Re : None : comment ça marche ?

et avec les classes nouvelle version (dérivées de object), on peut aussi faire :

super(classe_mere, self).__init(...)

aleph

Re : None : comment ça marche ?

> twinsen93

Bien vu.

----

Petite remarque à propos de None.
None est plus un *état* qu'une *valeur*. Pour tester None, il est préférable d'utiliser *is* plutôt que "==".

Petite anecdote lue sur la mailing list de Python 3000. X (j'ai oublié le nom) bossant dans le même bureau que GvR.

X        ---  he, Guido, qu'est ce qu'on fait quand on compare None ?
Guido  ---  Bof, disons que c'est plus petit que tout
X        ---  Bon, ok

et c'est ainsi que sous Python 2.x (2.6 inclus)

>>> None < 0
True
>>> None < 1
True
>>> z = [5, 2, None]
>>> z.sort()
>>> z
[None, 2, 5]
>>> a = None
>>> print ('a vaut None' if a is None else 'rien')
a vaut None

par contre, avec Python 3

>>> ---
None < 1
Traceback (most recent call last):
  File "<smid-last-command>", line 1, in <module>
TypeError: unorderable types: NoneType() < int()
>>> ---
None < 0
Traceback (most recent call last):
  File "<smid-last-command>", line 1, in <module>
TypeError: unorderable types: NoneType() < int()
>>> ---
z = [5, 1, None]
>>> ---
z.sort()
Traceback (most recent call last):
  File "<smid-last-command>", line 1, in <module>
TypeError: unorderable types: NoneType() < int()
>>> ---
a = None
>>> ---
print ('a est None' if a is None else 'rien')
a est None
>>> ---

Python 3 étant déjà là, autant prendre de bonnes (et correctes) habitudes.

twinsen93

Re : None : comment ça marche ?

Une autre remarque:

if param:
    ...

pour savoir si param est None n'est pas une bonne idée. En effet, None est bien faux, mais une liste, une chaine ou un dictionnaire vide l'est aussi.

aleph

Re : None : comment ça marche ?

> twinsens93

> pour savoir si param est None n'est pas une bonne idée.

Adjugé !

>>> def z(param=None):
        if param is None:
            return 'param is None'
        else:
            return 'param is not None'
            
>>> z(1)
param is not None
>>> z()
param is None
>>> z(range(4))
param is not None
>>> z(None)
param is None

> En effet, None est bien faux, mais une liste, une chaine ou un dictionnaire vide l'est aussi.

Attention, c'est assez subtil.

Affirmer que "None est bien faux" n'est pas correct. None n'est ni vrai ni faux dans le sens booléen, mais est faux parce que le type None n'est pas un type booléen.

>>> None == True
False
>>> None == False
False
>>> None == 1
False
>>> None == {}
False

cependant selon le *contexte* dans lequel None est utilisé, il peut "être vu" comme une valeur booléenne.

>>> def z2(param=None):
        if param:
            return 'param is True'
        else:
            return 'param is False'
            
>>> z2()
param is False
>>> z2('a')
param is True
>>> z2(None)
param is False
>>> z2(not None)
param is True