Comment vérifier si une variable est None en Python

Introduction

Dans ce labo, vous apprendrez à vérifier si une variable est None en Python. Le labo commence par expliquer la valeur None, une constante spéciale représentant l'absence de valeur. Vous créerez des scripts Python pour comprendre comment None est retourné par les fonctions lorsqu'aucune valeur n'est présente, comment assigner None à des variables et comment utiliser None comme argument par défaut dans les fonctions.

Le labo vous guide ensuite à travers l'utilisation de l'opérateur is pour vérifier spécifiquement si une variable est None, en la différenciant d'autres valeurs fausses telles que 0, False et les chaînes de caractères vides. Cela vous permet d'identifier précisément quand une variable contient véritablement la valeur None dans votre code Python.

Skills Graph

Comprendre la valeur None

Dans cette étape, vous allez apprendre à propos de la valeur None en Python. None est une constante spéciale en Python qui représente l'absence de valeur ou une valeur nulle. Elle est souvent utilisée pour indiquer qu'une variable n'a pas été assignée de valeur ou qu'une fonction ne retourne pas de valeur.

Commençons par créer un fichier Python nommé none_example.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.

## ~/project/none_example.py
def greet(name):
    if name:
        return "Hello, " + name
    else:
        return None

result = greet("Alice")
print(result)

result = greet("")
print(result)

Dans ce code :

• Nous définissons une fonction greet qui prend un name en entrée.
• Si name n'est pas vide, la fonction retourne une chaîne de salutation.
• Si name est vide, la fonction retourne None.
• Nous appelons la fonction greet avec "Alice" et une chaîne vide "" et affichons les résultats.

Maintenant, exécutons le script Python :

python ~/project/none_example.py

Vous devriez voir la sortie suivante :

Hello, Alice
None

Comme vous pouvez le voir, lorsque nous appelons greet avec "Alice", elle retourne "Hello, Alice". Lorsque nous l'appelons avec une chaîne vide, elle retourne None, qui est ensuite affiché dans la console.

None n'est pas le même que 0, False ou une chaîne vide. C'est une valeur distincte qui représente l'absence de valeur.

Vous pouvez assigner None à une variable :

## ~/project/none_example2.py
x = None
print(x)

Exécutez le script :

python ~/project/none_example2.py

Sortie :

None

Vous pouvez également utiliser None comme valeur d'argument par défaut dans une fonction :

## ~/project/none_example3.py
def my_function(arg=None):
    if arg is None:
        print("No argument was passed.")
    else:
        print("Argument:", arg)

my_function()
my_function("Hello")

Exécutez le script :

python ~/project/none_example3.py

Sortie :

No argument was passed.
Argument: Hello

Dans cet exemple, si aucun argument n'est fourni lors de l'appel de my_function, arg prendra la valeur par défaut None.

Utiliser l'opérateur is pour vérifier si une valeur est None

Dans cette étape, vous apprendrez à utiliser l'opérateur is pour vérifier si une variable est None. En Python, l'opérateur is est utilisé pour tester si deux variables font référence au même objet en mémoire. Cela est différent de l'opérateur ==, qui vérifie si deux variables ont la même valeur. Lorsque vous travaillez avec None, il est recommandé d'utiliser l'opérateur is car None est un objet singleton, ce qui signifie qu'il n'y a qu'une seule instance de None en mémoire.

Créons un fichier Python nommé is_none_example.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.

## ~/project/is_none_example.py
def check_none(value):
    if value is None:
        print("The value is None")
    else:
        print("The value is not None")

x = None
check_none(x)

y = "Hello"
check_none(y)

Dans ce code :

• Nous définissons une fonction check_none qui prend une value en entrée.
• Nous utilisons l'opérateur is pour vérifier si value est None.
• Si value est None, nous affichons "The value is None".
• Sinon, nous affichons "The value is not None".
• Nous appelons la fonction check_none avec None et "Hello" pour démontrer la différence.

Maintenant, exécutons le script Python :

python ~/project/is_none_example.py

Vous devriez voir la sortie suivante :

The value is None
The value is not None

Comme vous pouvez le voir, l'opérateur is identifie correctement quand une variable est None.

Il est important d'utiliser is None au lieu de == None lors de la vérification de None. Bien que == None puisse fonctionner dans certains cas, il n'est pas garanti de fonctionner dans toutes les situations, en particulier lorsqu'il s'agit d'objets personnalisés qui redéfinissent l'opérateur ==. L'utilisation de is None est la méthode recommandée et la plus fiable pour vérifier si une valeur est None.

Voici un autre exemple pour illustrer ceci :

## ~/project/is_none_example2.py
class MyClass:
    def __eq__(self, other):
        return True  ## Always return True for equality

obj = MyClass()
print(obj == None)  ## Might return True due to the overridden __eq__ method
print(obj is None)  ## Always returns False because obj is not None

Exécutez le script :

python ~/project/is_none_example2.py

Sortie :

True
False

Cet exemple montre que l'utilisation de == None peut conduire à des résultats inattendus si la méthode __eq__ de l'objet est redéfinie. La vérification is None, en revanche, identifie toujours correctement si l'objet est effectivement None.

Différencier None des autres valeurs fausses

Dans cette étape, vous apprendrez à différencier None des autres valeurs fausses (falsy values) en Python. En Python, plusieurs valeurs sont considérées comme « fausses », c'est-à-dire qu'elles s'évaluent à False dans un contexte booléen. Cela inclut False, 0, 0.0, les chaînes vides (""), les listes vides ([]), les tuples vides (()), les dictionnaires vides ({}) et None.

Il est important de comprendre que bien que None soit une valeur fausse, il n'est pas identique à ces autres valeurs. L'utilisation de l'opérateur is est cruciale lorsqu'on vérifie spécifiquement si une valeur est None, car il permet de distinguer None des autres valeurs fausses.

Créons un fichier Python nommé falsy_values.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.

## ~/project/falsy_values.py
def check_falsy(value):
    if value:
        print(f"{value!r} is considered True")
    else:
        print(f"{value!r} is considered False")

check_falsy(None)
check_falsy(False)
check_falsy(0)
check_falsy("")
check_falsy([])

print("\nChecking with 'is None':")

def check_none(value):
    if value is None:
        print(f"{value!r} is None")
    else:
        print(f"{value!r} is not None")

check_none(None)
check_none(False)
check_none(0)
check_none("")
check_none([])

Dans ce code :

• Nous définissons une fonction check_falsy qui prend une value en entrée et vérifie sa valeur booléenne dans un contexte booléen.
• Nous définissons ensuite une fonction check_none qui utilise l'opérateur is None pour vérifier spécifiquement si la valeur est None.
• Nous appelons les deux fonctions avec None, False, 0, "" et [] pour démontrer les différences.

Maintenant, exécutons le script Python :

python ~/project/falsy_values.py

Vous devriez voir la sortie suivante :

None is considered False
False is considered False
0 is considered False
'' is considered False
[] is considered False

Checking with 'is None':
None is None
False is not None
0 is not None
'' is not None
[] is not None

Cette sortie montre clairement que bien que toutes les valeurs soient considérées comme fausses dans un contexte booléen, seul None est identifié comme None lorsque l'on utilise l'opérateur is None.

L'utilisation de is None garantit que vous vérifiez spécifiquement l'absence d'une valeur, plutôt que n'importe quelle valeur qui s'évalue à False. Cette distinction est importante pour écrire un code Python robuste et précis.

Résumé

Dans ce laboratoire (lab), vous avez appris à connaître la valeur None en Python, qui représente l'absence d'une valeur. Vous avez vu comment une fonction peut retourner None lorsqu'aucune valeur n'est disponible, et comment assigner None à une variable.

En outre, vous avez exploré l'utilisation de None comme valeur d'argument par défaut dans une fonction, permettant à la fonction de se comporter différemment lorsqu'aucun argument n'est fourni. Le laboratoire a démontré ces concepts grâce à des exemples pratiques et des extraits de code.