Exercice Corrigé: Les tuples en Python

# Méthode 1
# Créer un tuple vide et l'affecter à la variable 't'.
t = ()
# Afficher le contenu du tuple 't', qui est vide
print(t)

# Méthode 2
# Créer un tuple vide à l'aide du constructeur tuple() et l'affecter à la variable 'tt'.
tt = tuple()
# Afficher le contenu du tuple 'tt', qui est vide
print(tt) 

Sortie:

()
()

# Créer un tuple contenant des éléments de différents types
t = ("str", True, 2.5, 1)
# Afficher le contenu du tuple 't'.
print(t)

Sortie:

('str', True, 2.5, 1)

# Créer un tuple contenant une séquence de nombres
t = 1, 2, 3, 4, 5
# Afficher le contenu du tuple 't'.
print(t)

# Créer un tuple avec un seul élément (notez la virgule après l'élément)
t = 2,
# Afficher le contenu du tuple 't'.
print(t)

Sortie:

(1, 2, 3, 4, 5)
(2,)

# Créer un tuple contenant trois nombres
t = 6, 2, 4
# Afficher le contenu du tuple 't'.
print(t)

# Décompressez les valeurs du tuple dans les variables n1, n2 et n3.
n1, n2, n3 = t

# Afficher le contenu des variables.
print('Le contenu des variables:')
print(n1)
print(n2)
print(n3)

Sortie:

(6, 2, 4)
Le contenu des variables:
6
2
4

# Créer un tuple
t = (10,20,30,40) 
print(t)

t = t + (50,)
print(t)

# Conversion du tuple en liste
l = list(t) 

# Utiliser différentes méthodes pour ajouter des éléments à une liste
l.append(60)
t = tuple(l)
print(t)

Sortie:

(10, 20, 30, 40)
(10, 20, 30, 40, 50)
(10, 20, 30, 40, 50, 60)

# Créer un tuple contenant des caractères
t = ('h', 'e', 'l', 'l', 'o')
# Utilisez la méthode 'join' pour concaténer les caractères du tuple sans espace et créer une chaîne unique.
str = ''.join(t)
# Afficher la chaîne de caractères résultante
print(str)

Sortie:

hello

# Créer un tuple contenant une séquence d'éléments
t = ("w", "a", "y", "t", "o", "l", "e", "a", "r", "n", "x")
print(t)

# Récupère le troisième élément du tuple (index 2)
item = t[2]
# Afficher la valeur de l'élément.
print(item)

# Récupérer le troisième élément à partir de la fin du tuple (index -3)
item1 = t[-3]
# Afficher la valeur de l'élément.
print(item1) 

Sortie:

('w', 'a', 'y', 't', 'o', 'l', 'e', 'a', 'r', 'n', 'x')
y
r

# Créer un tuple contenant une suite de nombres
t = 1, 3, 4, 2, 2, 2, 2, 5, 6
print(t)

# Comptez le nombre de fois où la valeur 2 apparaît dans le tuple 't'.
count = t.count(2)
# Affichez le nombre de fois où le chiffre 2 apparaît.
print(count) 

Sortie:

(1, 3, 4, 2, 2, 2, 2, 5, 6)
4

# Créer un tuple contenant une séquence d'éléments
t = ("w", "a", "y", "t", "o", "l", "e", "a", "r", "n", "x")

# Vérifier si le caractère 'x' est présent dans le tuple 't' et afficher le résultat.
print("x" in t)

# Vérifier si le nombre 2 est présent dans le tuple 't' et afficher le résultat.
print(2 in t)

Sortie:

True
False

# Créer une liste contenant une séquence de nombres
liste = [6, 2, 3, 4, 1, 8]
# Afficher le contenu de la liste
print(liste)

# Utilisez la fonction 'tuple()', une fonction intégrée de Python, pour convertir la liste en un tuple.
t = tuple(liste)
# Afficher le contenu du tuple 't'.
print(t)

Sortie:

[6, 2, 3, 4, 1, 8]
(6, 2, 3, 4, 1, 8)

# Méthode 1
# Créer un tuple contenant une séquence d'éléments
t = ("w", "a", "y", "t", "o", "l", "e", "a", "r", "n", "x")
print(t)

# Les tuples sont immuables, il n'est donc pas possible de supprimer des éléments directement.
# Pour supprimer un élément, créez un nouveau tuple en fusionnant les éléments souhaités à l'aide de l'opérateur +.
res = t[:2] + t[3:]
# Afficher le tuple 't' mis à jour.
print(res)


# Méthode 2
# Convertir le tuple 't' en une liste
liste = list(t)
# Utilisez la méthode 'remove' pour supprimer l'élément 'y' de la liste.
liste.remove("y")
# Reconvertir la liste modifiée en un tuple pour obtenir 't' avec l'élément supprimé
t = tuple(liste)
# Afficher le tuple 't' final
print(t) 

Sortie:

('w', 'a', 'y', 't', 'o', 'l', 'e', 'a', 'r', 'n', 'x')
('w', 'a', 't', 'o', 'l', 'e', 'a', 'r', 'n', 'x')
('w', 'a', 't', 'o', 'l', 'e', 'a', 'r', 'n', 'x')

t = ('a','b','c','d','e','f','g','h')

# Utiliser le découpage (tuple[start:stop]) pour extraire une partie du tuple.
# L'index de départ est inclusif et l'index de fin est exclusif.

# Couper de l'index 3 (inclus) à l'index 5 (exclus) et le stocker dans la variable 'res'.
res = t[3:5]
print(res)

# Si l'index de départ n'est pas défini, il est pris au début du tuple.
res = t[:4]
print(res)

# Si l'index de fin n'est pas défini, il est pris jusqu'à la fin du tuple.
res = t[5:]
print(res)

# Si aucun index de début ou de fin n'est défini, il renvoie le tuple complet.
res = t[:]
print(res)

Sortie:

('d', 'e')
('a', 'b', 'c', 'd')
('f', 'g', 'h')
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')

# Créer un tuple en convertissant la chaîne 'hello world' en un tuple
t = tuple("hello world")
# Afficher le contenu du tuple 't'.
print(t)

# Obtenir l'index de la première occurrence du caractère 'w' dans le tuple 't'.
index = t.index("w")
# Afficher la valeur de l'index
print(index)

Sortie:

('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
6

# Créer un tuple en convertissant la chaîne 'waytolearnx' en un tuple
t = tuple("waytolearnx")
# Afficher le contenu du tuple 't'.
print(t)

# Utilisez la fonction 'len()' pour déterminer la longueur du tuple 't'.
print(len(t)) 

Sortie:

('w', 'a', 'y', 't', 'o', 'l', 'e', 'a', 'r', 'n', 'x')
11

# Créer un tuple contenant des tuples imbriqués, où chaque tuple intérieur est composé de deux éléments.
t = ((1, "a"), (2, "b"))

# Créer un dictionnaire en utilisant une expression génératrice pour échanger les éléments de chaque tuple interne.
# Le générateur itère à travers 't', et pour chaque tuple interne (x, y), il crée une paire clé-valeur (y, x).
res = dict((y, x) for x, y in t)

# Afficher le dictionnaire résultant.
print(res) 

Sortie:

{'a': 1, 'b': 2}

# Créer un tuple contenant une seule chaîne de caractères
t = ("waytolearnx")
res = reversed(t)
print(tuple(res))

# Créer un autre tuple contenant une séquence de nombres
t = (1, 2, 3, 4)
res = reversed(t)
print(tuple(res)) 

Sortie:

('x', 'n', 'r', 'a', 'e', 'l', 'o', 't', 'y', 'a', 'w')
(4, 3, 2, 1)

# Créer une liste de tuples où chaque tuple contient deux éléments, un caractère et un nombre.
l = [("z", 1), ("z", 2), ("x", 3)]

# Créer un dictionnaire vide pour stocker les résultats.
d = {}

# Itérer à travers chaque tuple (a, b) dans la liste l.
for a, b in l:
    # Utiliser 'setdefault' pour créer une liste vide dans le dictionnaire 'd' pour la clé 'a' si elle n'existe pas.
    # Ensuite, ajouter la valeur 'b' à la liste associée à la clé 'a'.
    d.setdefault(a, []).append(b)

# Afficher le dictionnaire résultant
print(d)

Sortie:

{'z': [1, 2], 'x': [3]}

# Create a list of tuples, where each tuple contains two elements.
l = [(1, 2), (3, 4), (5, 6)]

# Utilisez la fonction zip avec l'opérateur * pour décompresser et zipper les tuples.
res = list(zip(*l))

# PAfficher le résultat
print(res)

Sortie:

[(1, 3, 5), (2, 4, 6)]

# Créer un tuple contenant des nombres
t = (10, 20, 30, 40)

# Utiliser la méthode 'format' pour insérer le tuple ” t » dans la chaîne et afficher le résultat.
print('Ceci est un tuple {0}'.format(t))

Sortie:

Ceci est un tuple (10, 20, 30, 40)

# Créez une liste de tuples, où chaque tuple contient trois nombres.
l = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

# Utiliser une liste de compréhension pour itérer à travers chaque tuple 't' dans la liste 'l'.
# Pour chaque tuple, créer un nouveau tuple en supprimant le dernier élément et en ajoutant le nombre 99.
# Le résultat est une liste de tuples modifiés.
print([t[:-1] + (99,) for t in l])

Sortie:

[(1, 2, 99), (4, 5, 99), (7, 8, 99)]

# Créez une liste l contenant des tuples vides et des tuples contenant des caractères.
l = [(), (), ('',), ('x', 'y'), ('d', 'z', 'q'), ('c')]

# Utilisez une liste de compréhension pour filtrer les tuples vides en vérifiant si chaque tuple 't' dans 'l' n'est pas vide.
l = [t for t in l if t]

# Afficher la liste modifiée 'l' après avoir supprimé les tuples vides.
print(l)

Sortie:

[('',), ('x', 'y'), ('d', 'z', 'q'), 'c']