<jupyter_start><jupyter_text>Les tuples  DéfinitionLes tuples, instanciés par des parenthèses, se conçoivent comme la version immutable des listes. Ils sont réputés contenir 0 ou plus de 1 élément.<jupyter_code># No element = this is a tuple
t = ()
print(type(t))
# One element = this is not a tuple
t = (1)
print(type(tup))
# More than 1 element = this is a tuple
t = (1, 2)
print(type(t))<jupyter_output><empty_output><jupyter_text>Accéder à un élément du tupleClassiquement, la notation crochets permet d’accéder à un élément particulier du tuple :<jupyter_code>t = ('knight', 'noun')
t[1]<jupyter_output><empty_output><jupyter_text>Plus intéressante, la méthode qui permet de désempiler les éléments du tuple, sans avoir recours à une boucle :<jupyter_code>word, tag = ('knight', 'noun')
print(word)
print(tag)<jupyter_output><empty_output><jupyter_text>Autrement, en présence d’une boucle, un tuple se comporte comme une liste :<jupyter_code>t = ('knight', 'noun')
for element in t:
    print(element)<jupyter_output><empty_output><jupyter_text>Pour connaître l’indice d’un élément du tuple, recourir à la méthode `index()` :<jupyter_code>t.index('knight')<jupyter_output><empty_output><jupyter_text>ImmutabilitéCette caractéristique rend impossible la modification d’un tuple après sa création :<jupyter_code># An exception is raised
t = ('castle', 'verb')
t[1] = 'noun'<jupyter_output><empty_output><jupyter_text>Une étape intermédiaire de transformation de type en liste est nécessaire pour la réaliser avant de rétablir le tuple sous sa vraie forme :<jupyter_code>t = list(t)
t[1] = 'noun'
t = tuple(t)
print(t)<jupyter_output><empty_output><jupyter_text>**Remarque :** une liste à l’intérieur d’un tuple n’hérite pas de son caractère immutable.<jupyter_code>t = ('castle', ['noun', 'masculine', 'plural'])
t[1][2] = 'singular'
print(t)<jupyter_output><empty_output><jupyter_text>De la même manière, il n’est pas permis de supprimer un élément d’un tuple :<jupyter_code>t = ('castle', 'noun')
del(t[1])<jupyter_output><empty_output><jupyter_text>On peut en revanche supprimer le tuple complètement grâce à la fonction `del()` :<jupyter_code>del(t)<jupyter_output><empty_output><jupyter_text>Si l’on ne peut supprimer un élément d’un tuple, il est toutefois possible de le réaffecter, comme pour les chaînes de caractères :<jupyter_code>t = ('castle', 'verb')
# As a tuple needs more than 1 element,
# put a comma at the end
t = (t[0],) + ('noun',)
print(t)<jupyter_output><empty_output><jupyter_text>Fusionner des tuplesLorsque l’on dispose de deux tuples de longueur égale, c’est-à-dire avec exactement le même nombre d’éléments, on peut les fusionner en une seule liste de tuples avec la fonction `zip()` :<jupyter_code>words = ('castle', 'knights', 'keep')
tags = ('noun', 'noun', 'verb')
genders = ('masculine', 'masculine', '-')
tagged = zip(words, tags, genders)
for t in tagged:
    print(t)<jupyter_output><empty_output><jupyter_text>Techniques courantes sur les tuples TrierLes tuples peuvent être triés grâce à la fonction `sorted()`, mais le format de sortie sera une liste :<jupyter_code>words = ("We", "are", "the", "knights", "who", "say", "'Ni'!")
sorted(words)<jupyter_output><empty_output><jupyter_text>CalculsLa méthode `count()` renvoie le nombre d’occurrences d’un élément passé en paramètres :<jupyter_code>notes = (12, 15, 15, 7, 8, 13, 17, 9)
notes.count(9)<jupyter_output><empty_output><jupyter_text>Quelques autres fonctions utiles :- `len()` : renvoie le nombre d’éléments- `max()`: renvoie la valeur maximale- `min()`: renvoie la valeur minimale- `sum()` : renvoie la somme des valeurs de la liste<jupyter_code>print(len(notes))
print(max(notes))
print(min(notes))
print(sum(notes))<jupyter_output><empty_output><jupyter_text>ItérationSans surprise, l’itération sur les tuples s’effectue avec une boucle `for` :<jupyter_code>words = ("We", "are", "the", "knights", "who", "say", "'Ni'!")
for word in words:
    print(word, end=" ")<jupyter_output><empty_output><jupyter_text>La fonction `enumerate()` est également accessible :<jupyter_code>for idx, word in enumerate(words):
    print(idx, end=" ")<jupyter_output><empty_output><jupyter_text>Dans la réalité, l’exemple précédent se résoud plus simplement avec une liste. Les tuples servent davantage à relier étroitement des éléments dans un ensemble. L’exemple suivant est plus réaliste :<jupyter_code>sentence = [
    ("We", "PNP", "we"),
    ("are", "VBB", "be"),
    ("the", "AT0", "the"),
    ("knights", "NN2", "knight"),
    ("who", "PNQ", "who"),
    ("say", "VBB", "say"),
    ("Ni", "NP0", "ni"),
    ("!", "SENT", "!"),
]<jupyter_output><empty_output><jupyter_text>Et pour désempiler chaque élément d’un tuple :<jupyter_code>for word, tag, lemma in sentence:
    print(word, tag, lemma, end="/")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14036906489736678, 'fraction_numerical': 0.006427534729421522, 'mean_word_length': 6.805825242718447, 'pattern_counts': {'":': 0, '<': 77, '<?xml version=': 0, '>': 77, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '19', 'dir': 'jupyter-structured-clean-dedup', 'id': '446699', 'license': 'MIT', 'n_tokens_mistral': 1841, 'n_tokens_neox': 1810, 'n_words': 509, 'path': '2.data-structures/23.tuples.ipynb', 'repo_name': 'mdjamina/python-M1TAL', 'size': '4823'}