si vs si A n'est pas Rien:

La déclaration

if A:

appellera A.__nonzero__() (voir Spécial noms de méthode de la documentation) et utiliser la valeur de retour de cette fonction. Voici le résumé:

object.__nonzero__(self)

Appelés à mettre en œuvre vérité le test de la valeur et de l'exploitation intégré bool(); doit retourner False ou True, ou leur entier équivalents de 0 ou 1. Lorsque cette méthode n'est pas définie, __len__() est appelée, si elle est définie, et l'objet est considérée comme vraie si son résultat est différent de zéro. Si une classe ne définit ni les __len__() ni __nonzero__(), toutes ses instances sont considérées comme de vraies.

D'autre part,

if A is not None:

compare seulement la référence A avec None pour voir si elle est la même ou pas.

if x: #x is treated True except for all empty data types [],{},(),'',0 False, and None

donc c'est pas le même que

if x is not None # which works only on None

Ils faire des choses très différentes.

Le ci-dessous vérifie si a a rien, sauf les valeurs False, [], None, '' et 0. Il vérifie la valeur de A.

if A:

Le ci-dessous vérifie si A est un objet différent de "None". Il vérifie et compare les référence (adresse mémoire) de l'Un et Aucun.

if A is not None:

---

Mise à JOUR: de Plus amples explications

De nombreuses fois les deux semblent faire la même chose, de sorte que beaucoup de gens les utilisent de façon interchangeable - c'est une très mauvaise idée. La raison, les deux donnent le même résultat est de nombreuses fois par pure coïncidence grâce à l'optimisation de l'interpréteur/compilateur comme stage ou quelque chose d'autre.

Avec ces optimisations dans l'esprit, des entiers et des chaînes de la même valeur jusqu'en utilisant le même espace mémoire. Ce qui explique probablement pourquoi les deux chaînes distinctes agissent comme s'ils sont les mêmes.

> a = 'test'
> b = 'test'
> a is b
True
> a == b
True

D'autres choses ne se comportent pas de la même..

> a = []
> b = []
> a is b
False
> a == b
True

Les deux listes ont clairement leur propre mémoire. Étonnamment tuples de se comporter comme des chaînes de caractères.

> a = ()
> b = ()
> a is b
True
> a == b
True

C'est probablement parce que les tuples sont garantis de ne pas changer, donc il est logique de réutiliser la même mémoire.

Ligne de fond est que vous ne pouvez pas compter sur les coïncidences. Juste parce qu'il charlatans comme un canard, ça veut pas dire que c'est un canard. Utilisation is et == selon ce que vous voulez vérifier. Ces choses peuvent être difficiles à déboguer depuis is se lit comme de la prose que nous avons souvent écrémer sur elle.

La plupart des guides que j'ai vu suggèrent que vous devriez utiliser

si Un:

à moins d'avoir une raison d'être plus précis.

Il y a quelques légères différences. Il y a d'autres valeurs que rien que le retour de Faux, par exemple vide de listes ou de 0, alors pensez à ce que c'est que vous êtes vraiment à tester.

Ça dépend du contexte.

- Je utiliser if A: lorsque je m'attends à A à être une sorte de collection, et je ne veux exécuter le bloc, si la collection n'est pas vide. Cela permet à l'appelant de passer un bon comportement de collection, vide ou non, et de faire ce que j'attends. Il permet également None et False pour réprimer l'exécution du bloc, qui est parfois commode de code d'appel.

Otoh, que, si je m'attends à A à certains complètement arbitraire objet, mais il aurait pu être, par défaut,None, alors je toujours utilisation if A is not None, comme le code d'appel pourrait avoir délibérément adopté une référence à un regroupement vide, une chaîne vide, ou un 0 valeur de type numérique, booléen ou False, ou certains instance de la classe qui se trouve être faux dans le contexte booléen.

Et sur l'autre d'autre part, si je m'attends à A à être un peu plus spécifique de la chose (par exemple, instance d'une classe, je vais appeler des méthodes d'), mais il aurait pu être, par défaut,None, et je considère booléen par défaut de conversion d'être une propriété de la classe je n'ai pas l'esprit de l'application sur toutes les sous-classes, alors je vais juste utiliser if A: pour enregistrer mes doigts le terrible fardeau de taper un supplément de 12 caractères.

J'ai créé un fichier appelé test.py et il a couru sur l'interprète. Vous pouvez changer ce que vous voulez, pour tester sûr de savoir comment les choses se passe derrière les coulisses.

import dis

def func1():

    matchesIterator = None

    if matchesIterator:

        print( "On if." );

def func2():

    matchesIterator = None

    if matchesIterator is not None:

        print( "On if." );

print( "\nFunction 1" );
dis.dis(func1)

print( "\nFunction 2" );
dis.dis(func2)

C'est l'assembleur différence:

Source:

>>> import importlib
>>> reload( test )

Function 1
  6           0 LOAD_CONST               0 (None)
              3 STORE_FAST               0 (matchesIterator)

  8           6 LOAD_FAST                0 (matchesIterator)
              9 POP_JUMP_IF_FALSE       20

 10          12 LOAD_CONST               1 ('On if.')
             15 PRINT_ITEM
             16 PRINT_NEWLINE
             17 JUMP_FORWARD             0 (to 20)
        >>   20 LOAD_CONST               0 (None)
             23 RETURN_VALUE

Function 2
 14           0 LOAD_CONST               0 (None)
              3 STORE_FAST               0 (matchesIterator)

 16           6 LOAD_FAST                0 (matchesIterator)
              9 LOAD_CONST               0 (None)
             12 COMPARE_OP               9 (is not)
             15 POP_JUMP_IF_FALSE       26

 18          18 LOAD_CONST               1 ('On if.')
             21 PRINT_ITEM
             22 PRINT_NEWLINE
             23 JUMP_FORWARD             0 (to 26)
        >>   26 LOAD_CONST               0 (None)
             29 RETURN_VALUE
<module 'test' from 'test.py'>