<jupyter_start><jupyter_text>Listes, chaînes de caractères et boucle for  Jupyter notebookBienvenue dans votre premier Jupyter notebook. Chaque cellule doit être exécutée en appuyant simulatanément sur les touches SHIFT + ENTER   Objectifs- Listes- Boucles `for`- Nouvel opérateur : moduloLes trois objectifs seront traités séparemment. Un exercice en seconde période vous permettra de mettre en action les listes, les boucles for et l'opérateur modulo.  ListesUne liste est une séquence de plusieurs valeurs (nombres, texte, booléen, etc.).  On la déclare avec des crochets `[]` et on sépare chaque élément par une virgule `,`.  Créer une listeCeci est une liste nommée `uneListe` avec 3 éléments: le nombre `123`, la chaîne de caractères `'hello'` et le booléen `True`. La deuxième ligne affiche la liste à l'aide de la fonction `print()`<jupyter_code>uneListe = [123, 'hello', True]
print(uneListe)<jupyter_output>[123, 'hello', True]<jupyter_text>Voici une autre liste nommée `arbres` qui contient quatre chaînes de caractères<jupyter_code>arbres = ['sapin', 'cedre', 'meleze', 'bouleau']
print(arbres)<jupyter_output>['sapin', 'cedre', 'meleze', 'bouleau']<jupyter_text>Accéder à un élément d'une liste (index)Chaque élément de la liste a un index (le premier est toujours 0, puis 1, puis 2, etc..). On peut donc afficher un seul élément de la listes en utilisant son index. On accède à l'élément 0 en utilisant la notation par crochets `[]`. Voici comment afficher le premier élément de la liste `arbres` (dont l'index est égal à 0)<jupyter_code>print(arbres[0])<jupyter_output><empty_output><jupyter_text>Voici comment afficher le quatrième élément de la liste `arbre` (dont l'index est égal à 3)<jupyter_code>print(arbres[3])<jupyter_output><empty_output><jupyter_text>Longueur d'une listeIl est encore possible de connaître la longueur de la liste (qui est un nombre) avec la fonction `len()` qui prend en paramètre la liste:<jupyter_code>longueur = len(arbres)
print(longueur)<jupyter_output><empty_output><jupyter_text>Chaînes de caractèresLes chaînes de caractères sont formés uniquement de caractères. On peut aussi accéder aux différents caractères de la chaîne avec la notation par crochets `[]`. Le premier élément est toujours 0, puis 1, etc..Ainsi si on déclare la chaîne de caractères `chaine = "Ceci est un texte"` et que l'on désire accéder au caractère `e` du verbe `est`, on écrit en Python : `chaine[5]` puisque c'est le sixième caractère (un espace est un caractère)<jupyter_code>chaine = "Ceci est un texte"
print(chaine[5])<jupyter_output><empty_output><jupyter_text>La boucle for Une boucle `for` permet de **répéter une suite d'instructions** (que l'on appelle un **bloc d'instructions**) en itérant (parcourant) chaque éléments d'un `objet`. Cet `objet` est soit :* une liste* une chaîne de caractères* le retour de la fonction `range()`  Structure de la boucle forElle a la structure simplifiée suivante:```pythonfor i in objet:    instruction 1    instruction 2    instruction 3```1. Commence par le mot-clef `for`2. Puis le nom d'un itérateur (une variable)3. Puis le mot-clef `in`4. Puis un objet itérable (une chaîne de caractères, une liste ou la fonction `range()` )5. Et termine par deux points `:`6. un bloc à répéter (indentée) Voici une itération sur la liste `arbre` qui contient des chaînes de caractères.<jupyter_code>for arbre in arbres:
    print(arbre)<jupyter_output><empty_output><jupyter_text>Voici une itération sur une plage de nombres.<jupyter_code>for i in range(3):
    print(i)<jupyter_output><empty_output><jupyter_text>Voici une itération sur une liste de nombres.<jupyter_code>l = [1, 3, 5, 7, 9, 11]
for i in l:
    print(i)<jupyter_output><empty_output><jupyter_text>Voici une itération sur une chaîne de caractères.<jupyter_code>chaine = "Ceci est un texte"
for c in chaine:
    print(c)<jupyter_output><empty_output><jupyter_text>Boucles for imbriquéesIl est tout à fait possible d'imbriquer plusieurs boucles `for`, mais attention, le nom de la variable itérateur doit être différent pour chacune des boucles.  Exemple avec des boucles imbriquéesIci deux boucles for sont imbriquées. La première parcourt l'intervalle 0-5, la seconde 2-4 et affiche le résultat de la somme des deux nombres<jupyter_code>for i in range(6):
    for j in range(2,5):
        print(i+j)<jupyter_output><empty_output><jupyter_text>L'opérateur ModuloL'opérateur modulo est nécessaire pour réussir l'exercice de la deuxième période.   Définition du moduloL'opérateur modulo (en python le signe est le pourcent `%`) est un opérateur qui calcule le reste `r` de la division entière de `a` par `b`. Exemple : ```a = 9b = 4a % b = 1````9` divisé par `4` est égal à `2*4 + 1`. Le modulo vaut donc `1`.A noter que l'on peut aussi utiliser des nombres en virgule flottante ainsi que des nombres négatifs. Dans ce dernier cas, Python choisi le signe négatif du diviseur en non celui du dividente<jupyter_code>9%4
8%-3
-8%-3<jupyter_output><empty_output><jupyter_text>Exemple d'utilisation du moduloImaginons que l'on considère un objet itérable (comme une liste ou une chaîne de caractère) et que l'on parcourt ses éléments par incrément de `+ 1`. On souhaite voir cet objet itérable comme un objet **circulaire** : le dernier élément est contigü au premier. Supposons que l'on déclare la chaîne de caractères suivante:```pythonchaine = "abcde"```alors ```pythonindex = 0print(chaine[index])```retourne `a` et ```pythonlongueur = len(chaine)index = longueur - 1print(chaine[index])```retoune `e`<jupyter_code>chaine = "abcde"
index = 0
print(chaine[index])
longueur = len(chaine)
index = longueur - 1
print(chaine[index])<jupyter_output><empty_output><jupyter_text>Si maintenant on essaie d'accéder à l'élément `longueur + 1` soit :```pythonlongueur = len(chaine)index = longueur + 1chaine[index]```Python produit une erreur :```python---------------------------------------------------------------------------IndexError                                Traceback (most recent call last) in ()----> 1 print(chaine[longueur])IndexError: string index out of range```qui signifie que l'index choisi (`longueur + 1 = 6`) est en dehors de l'intervalle considéré (la longueur de la chaîne de caractères)<jupyter_code>index = longueur + 1
print(chaine[index])<jupyter_output><empty_output><jupyter_text>Pour remédier à cela, on utilise simplement le reste de la division entière entre l'index et la longueur, soit le modulo:```pythonindex = 10print(chaine[10%longueur])```<jupyter_code>index = 10
print(chaine[index%longueur])<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10457516339869281, 'fraction_numerical': 0.011855905152758778, 'mean_word_length': 5.308724832214765, 'pattern_counts': {'":': 0, '<': 59, '<?xml version=': 0, '>': 60, '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': '15', 'dir': 'jupyter-structured-clean-dedup', 'id': '465438', 'license': 'MIT', 'n_tokens_mistral': 2336, 'n_tokens_neox': 2321, 'n_words': 793, 'path': 'doc/python/vi/3/3_cours.ipynb', 'repo_name': 'LeilaBHC/edunum', 'size': '6579'}