Obtenir des sous-ensembles

12.1 Plage d'index

Le code pour obtenir un sous-ensemble est similaire à celui pour obtenir une sous-liste. En ce sens, les tuples leur ressemblent beaucoup. Je n'aimerais pas dupliquer le matériel, mais comme on dit, la répétition est la mère de l'apprentissage…

Obtenir des sous-ensembles, ou le slicing, permet d'extraire des parties d'un tuple pour créer de nouveaux tuples. Ce processus est particulièrement utile lorsqu'il est nécessaire de travailler avec certains segments de données enregistrés dans un tuple.

Slicing Syntax

Les slices sont créés en utilisant des crochets, où les index de début et de fin sont indiqués, séparés par un deux-points. Si l'index de début n'est pas indiqué, l'extraction commence par le premier élément ; si l'index de fin n'est pas indiqué, l'extraction va jusqu'au bout du tuple.

Un slice de tuple peut être obtenu en utilisant la syntaxe tuple[start:stop:step], où :

• start — l'index de début de l'élément (inclus) ;
• stop — l'index de fin de l'élément (exclus) ;
• step — le pas avec lequel les éléments sont sélectionnés.

Exemples :

my_tuple = (0, 1, 2, 3, 4, 5)
sub_tuple = my_tuple[1:4]  # Obtenir un sous-tuple avec les éléments de l'index 1 à 3
print(sub_tuple) # Affiche (1, 2, 3)
            
sub_tuple_with_step = my_tuple[0:6:2]  # Obtenir chaque deuxième élément de 0 à 5
print(sub_tuple_with_step) # Affiche (0, 2, 4) 
        

Si start n'est pas indiqué, il est par défaut égal à 0, et si stop n'est pas indiqué, il est égal à len(tuple). Le paramètre step par défaut est 1.

Exemples :

# Créer un tuple avec les éléments de 0 à 5
my_tuple = (0, 1, 2, 3, 4, 5)

# Créer un nouveau tuple, à partir du deuxième élément du tuple d'origine
sub_tuple = my_tuple[1:] 
print(sub_tuple)  # Affiche : (1, 2, 3, 4, 5)

# Créer un nouveau tuple, incluant les éléments du début jusqu'au quatrième élément 
# (index 4) du tuple d'origine, avec un pas de 1 (par défaut)
sub_tuple_with_step = my_tuple[:5] 
print(sub_tuple_with_step)  # Affiche : (0, 1, 2, 3, 4)

12.2 Index négatifs

Les index négatifs en Python commencent à -1, ce qui correspond au dernier élément d'une liste (ou d'un tuple). -2 indiquera l'avant-dernier élément, et ainsi de suite. Utiliser des index négatifs simplifie l'accès aux éléments depuis la fin d'un tuple sans avoir à calculer leur position depuis le début.

Exemples d'utilisation

Jetons un œil à l'utilisation des index négatifs pour former un slice. Supposons que nous ayons un tuple avec les valeurs :

my_tuple = (10, 20, 30, 40, 50, 60, 70, 80)

Pour obtenir un sous-tuple contenant des éléments depuis la fin jusqu'au milieu du tuple, nous pouvons utiliser des index négatifs.

sub_tuple = my_tuple[-3:-1]
print(sub_tuple) # Affiche (60, 70)

Donc, my_tuple[-3:-1] choisit les éléments aux index -3 (troisième depuis la fin) jusqu'à -1 (non inclus), ce qui nous donne le tuple (60, 70).

Obtenir le dernier élément d'un tuple :

my_tuple = (10, 20, 30, 40, 50)
last_element = my_tuple[-1]
print(last_element) # Affiche 50 
    

Ici, my_tuple[-1] retournera toujours le dernier élément du tuple, ce qui est très pratique lorsque le nombre exact d'éléments dans le tuple est inconnu.

Inverser l'ordre des éléments dans un tuple :

my_tuple = (10, 20, 30, 40, 50)
reversed_tuple = my_tuple[::-1]
print(reversed_tuple) # Affiche (50, 40, 30, 20, 10) 
    

L'utilisation du slice [::-1] permet de renverser facilement et efficacement l'ordre des éléments dans un tuple, obtenant un nouveau tuple avec les éléments dans l'ordre inverse.

12.3 Y a-t-il un élément dans le tuple

Vérifier la présence d'un élément dans un tuple est une opération standard qui permet de savoir si un élément est dans le tuple. Cela se fait à l'aide de l'opérateur in, qui retourne True si l'élément est présent dans le tuple, et False sinon.

Utilisation de l'opérateur in

L'opérateur in est un moyen simple et intuitif pour vérifier la présence d'un élément :

my_tuple = (1, 2, 3, 4, 5)
element = 3
if element in my_tuple:
    print(f"{element} est dans le tuple.")
else:
    print(f"{element} n'est pas dans le tuple.")
    

Vérifier qu'un élément est absent :

Si tu veux t'assurer qu'un élément est absent dans le tuple, utilise simplement la construction not in :

names = ('Alice', 'Bob', 'Charlie')
search_name = 'Alice'
if search_name not in names:
    print(f"{search_name} n'est pas dans le tuple.")
else:
    print(f"{search_name} est dans le tuple.")
    

C'est presque comme travailler avec une liste - et c'est là que réside l'universalité et la simplicité de Python.