Comment vérifier si un tuple est vide en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un tuple est vide en Python. Le laboratoire couvre le concept de tuples vides, leur création à l'aide de parenthèses () et du constructeur tuple(), ainsi que leurs utilisations potentielles dans l'initialisation, les arguments de fonction et les valeurs par défaut.

Vous explorerez ensuite deux méthodes pour déterminer si un tuple est vide : en utilisant la fonction len() pour vérifier la longueur du tuple et en évaluant directement le tuple comme une valeur booléenne. Ces techniques vous fourniront des moyens pratiques d'identifier et de gérer les tuples vides dans votre code Python.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/ObjectOrientedProgrammingGroup(["Object-Oriented Programming"]) python(("Python")) -.-> python/PythonStandardLibraryGroup(["Python Standard Library"]) python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/ControlFlowGroup(["Control Flow"]) python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python/BasicConceptsGroup -.-> python/booleans("Booleans") python/ControlFlowGroup -.-> python/conditional_statements("Conditional Statements") python/DataStructuresGroup -.-> python/tuples("Tuples") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") python/ObjectOrientedProgrammingGroup -.-> python/constructor("Constructor") python/PythonStandardLibraryGroup -.-> python/data_collections("Data Collections") subgraph Lab Skills python/booleans -.-> lab-559589{{"Comment vérifier si un tuple est vide en Python"}} python/conditional_statements -.-> lab-559589{{"Comment vérifier si un tuple est vide en Python"}} python/tuples -.-> lab-559589{{"Comment vérifier si un tuple est vide en Python"}} python/build_in_functions -.-> lab-559589{{"Comment vérifier si un tuple est vide en Python"}} python/constructor -.-> lab-559589{{"Comment vérifier si un tuple est vide en Python"}} python/data_collections -.-> lab-559589{{"Comment vérifier si un tuple est vide en Python"}} end

Apprenez-en sur les tuples vides

Dans cette étape, vous apprendrez à connaître les tuples vides en Python. Les tuples sont une structure de données fondamentale en Python, similaires aux listes, mais avec une différence clé : les tuples sont immuables, ce qui signifie que leurs éléments ne peuvent pas être modifiés après leur création. Un tuple vide est simplement un tuple qui ne contient aucun élément.

Commençons par créer un tuple vide. Vous pouvez le faire de deux manières :

En utilisant des parenthèses () :
```
empty_tuple = ()
print(empty_tuple)
```
Créez un nouveau fichier nommé empty_tuple.py dans votre répertoire ~/project en utilisant l'éditeur VS Code. Copiez et collez le code ci-dessus dans le fichier.
```
()
```
Pour exécuter le script, ouvrez votre terminal et exécutez la commande suivante :
```
python ~/project/empty_tuple.py
```
Cela affichera un tuple vide () dans la console.
En utilisant le constructeur tuple() sans aucun argument :
```
empty_tuple = tuple()
print(empty_tuple)
```
Modifiez le fichier empty_tuple.py pour qu'il contienne le code ci-dessus.
```
()
```
Exécutez le script à nouveau en utilisant la même commande :
```
python ~/project/empty_tuple.py
```
Cela affichera également un tuple vide () dans la console.

Les deux méthodes donnent le même résultat : la création d'un tuple vide.

Maintenant, comprenons pourquoi les tuples vides sont utiles. Bien qu'ils puissent sembler insignifiants, ils peuvent être utiles dans plusieurs scénarios :

Initialisation : Vous pouvez vouloir initialiser une variable avec un tuple vide avant de la remplir avec des données plus tard.
Arguments de fonction : Certaines fonctions peuvent nécessiter un tuple comme argument, et vous pouvez vouloir passer un tuple vide si vous n'avez pas de données à fournir.
Valeurs par défaut : Les tuples vides peuvent servir de valeurs par défaut pour les paramètres de fonction.

Dans les étapes suivantes, vous apprendrez à vérifier la longueur d'un tuple et à évaluer les tuples vides en tant que valeurs booléennes.

Utilisez la fonction len() pour vérifier

Dans cette étape, vous apprendrez à utiliser la fonction len() pour vérifier la longueur d'un tuple. La fonction len() est une fonction intégrée (built-in) de Python qui renvoie le nombre d'éléments dans un objet, comme une chaîne de caractères, une liste ou un tuple.

Utilisons la fonction len() pour vérifier la longueur d'un tuple vide :

Ouvrez le fichier empty_tuple.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.
Modifiez le fichier pour qu'il contienne le code suivant :
```
empty_tuple = ()
length = len(empty_tuple)
print(length)
```
Ici, nous créons d'abord un tuple vide empty_tuple. Ensuite, nous utilisons la fonction len() pour obtenir sa longueur et la stockons dans la variable length. Enfin, nous affichons la valeur de length.
```
0
```
Pour exécuter le script, ouvrez votre terminal et exécutez la commande suivante :
```
python ~/project/empty_tuple.py
```
Cela affichera 0 dans la console, indiquant que le tuple vide a une longueur de zéro.

Maintenant, essayons de vérifier la longueur d'un tuple non vide :

Modifiez le fichier empty_tuple.py pour qu'il contienne le code suivant :
```
non_empty_tuple = (1, 2, 3)
length = len(non_empty_tuple)
print(length)
```
Ici, nous créons un tuple non_empty_tuple contenant trois éléments : 1, 2 et 3. Ensuite, nous utilisons la fonction len() pour obtenir sa longueur et l'affichons.
```
3
```
Exécutez le script à nouveau en utilisant la même commande :
```
python ~/project/empty_tuple.py
```
Cela affichera 3 dans la console, indiquant que le tuple a une longueur de trois.

La fonction len() est un outil utile pour déterminer la taille des tuples et d'autres objets itérables en Python. Dans l'étape suivante, vous apprendrez comment les tuples vides sont évalués en tant que valeurs booléennes.

Évaluation en tant que valeur booléenne

Dans cette étape, vous apprendrez comment les tuples vides sont évalués en tant que valeurs booléennes en Python. En Python, certaines valeurs sont considérées comme « vraies » (elles s'évaluent à True dans un contexte booléen) et d'autres sont considérées comme « fausses » (elles s'évaluent à False). Les tuples vides sont considérés comme faussy.

Voyons cela en action :

Ouvrez le fichier empty_tuple.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.
Modifiez le fichier pour qu'il contienne le code suivant :
```
empty_tuple = ()

if empty_tuple:
    print("The tuple is truthy")
else:
    print("The tuple is falsy")
```
Ici, nous créons un tuple vide empty_tuple. Ensuite, nous utilisons une instruction if pour vérifier sa valeur booléenne. Si elle est vraie, nous affichons "The tuple is truthy". Sinon, nous affichons "The tuple is falsy".
```
The tuple is falsy
```
Pour exécuter le script, ouvrez votre terminal et exécutez la commande suivante :
```
python ~/project/empty_tuple.py
```
Cela affichera "The tuple is falsy" dans la console, indiquant que le tuple vide s'évalue à False dans un contexte booléen.

Maintenant, essayons avec un tuple non vide :

Modifiez le fichier empty_tuple.py pour qu'il contienne le code suivant :
```
non_empty_tuple = (1, 2, 3)

if non_empty_tuple:
    print("The tuple is truthy")
else:
    print("The tuple is falsy")
```
Ici, nous créons un tuple non vide non_empty_tuple contenant trois éléments.
```
The tuple is truthy
```
Exécutez le script à nouveau en utilisant la même commande :
```
python ~/project/empty_tuple.py
```
Cela affichera "The tuple is truthy" dans la console, indiquant que le tuple non vide s'évalue à True dans un contexte booléen.

Comprendre comment les tuples vides et d'autres structures de données sont évalués en tant que valeurs booléennes est important pour écrire un code Python concis et efficace, surtout lorsqu'il s'agit de traiter des instructions conditionnelles et des boucles.

Résumé

Dans ce laboratoire (lab), vous avez appris à connaître les tuples vides en Python, qui sont des structures de données immuables ne contenant aucun élément. Vous pouvez créer un tuple vide en utilisant soit des parenthèses () soit le constructeur tuple() sans arguments. Les tuples vides sont utiles pour l'initialisation, les arguments de fonction et les valeurs par défaut. Le laboratoire présente ensuite comment vérifier si un tuple est vide en utilisant la fonction len().