typo, correction bloc de code et orthographe

representation_construits/chapitre_1/README.md

@@ -2,7 +2,7 @@
 
 -------------
 
-> ***Contenue*** : Notions introduites : le type conteneur, avec les listes, les tuples, parcours de séquences. 
+> ***Contenu*** : Notions introduites : le type conteneur, avec les listes, les tuples, parcours de séquences. 
 > ***Compétences*** : Comprendre la différence entre une liste python et un tuple. Maîtriser la création de conteneurs sur Python.
 
 ## Le programme
@@ -19,7 +19,7 @@
 
 Les types *conteneurs* comme les tuples ou les listes permettent de stocker des objets, et proposent des méthodes d'accès, de modification et d'itération sur ces mêmes objets.
 
-Ici nous allons voir trois types de conteneurs en particulier : les tuples, les listes, et enfin les dictionnaires. En apprenant à créer et à manipuler ces types d'objets, cela nous permettra de travailler sur un grand nombre de données de manière rapide et efficace.
+Ici nous allons voir deux types de conteneurs en particulier : les tuples, les listes. En apprenant à créer et à manipuler ces types d'objets, cela nous permettra de travailler sur un grand nombre de données de manière rapide et efficace.
 
 --------
 
@@ -75,24 +75,24 @@ print(liste)
 
 --------------
 
-### Accéder aux élèments d'une liste
+### Accéder aux éléments d'une liste
 
-Les élèments d'une liste peuvent être comparés à des élèments d'une séquence : chaque élèment a une position précise dans le conteneur, comme nous l'avons vu pour les chaînes de caractères (*str*).
+Les éléments d'une liste peuvent être comparés à des éléments d'une séquence : chaque élément a une position précise dans le conteneur, comme nous l'avons vu pour les chaînes de caractères (*str*).
 
-On appelle cette position *indice*, c'est cet indice qui nous permet d'accéder à un élèment en particulier.
+On appelle cette position *indice*, c'est cet indice qui nous permet d'accéder à un élément en particulier.
 
-Le premier élèment d'une liste a pour indice **0**.
+Le premier élément d'une liste a pour indice **0**.
 
-Tout comme avec les chaînes de caractères, un indice négatif permet d'accéder l'élèment en partant de la fin.
+Tout comme avec les chaînes de caractères, un indice négatif permet d'accéder l'élément en partant de la fin.
 
-Pour connaître le nombre total d'élèments dans une liste, on utilise la fonction ***len***
+Pour connaître le nombre total d'éléments dans une liste, on utilise la fonction ***len***
 
 ```python
 l_1 = [2,4,6,8]
 len (l_1)
 ```
 
-On peut désigner une **tranche** en indiquant l'indice du premier élèment, ainsi que celui du dernier ***non inclus*** :
+On peut désigner une **tranche** en indiquant l'indice du premier élément, ainsi que celui du dernier ***non inclus*** :
 
 ```py
 l_1[1:3]
@@ -106,9 +106,9 @@ Attention : Un indice qui dépasse la valeur *longueur de la liste - 1* provoque
 
 Comme indiqué plus haut, il est possible de créer et de parcourir une liste par une méthode dite *de compréhension* ou *itération*.
 
-Celà signifie qu'on construit cette liste à partir d'élèments itérables : que l'on peut répétèr. Par exemple :
+Celà signifie qu'on construit cette liste à partir d'éléments itérables : que l'on peut répéter. Par exemple :
 
-```pyth
+```python
 liste = [x for x in range(5)]
 print(liste)
 ```
@@ -119,7 +119,7 @@ L'intérêt des listes par compréhension, c'est que l'on peut utiliser les stru
 
 On peut également initialiser une liste à partir d'une autre :
 
-```pytho
+```python
 liste_1 = [1, 2, 3, 4]
 liste_2 = [2 * x for x in liste_1]
 print(liste_2)
@@ -127,26 +127,26 @@ print(liste_2)
 
 Une fois que votre conteneur est crée, on peut le parcourir :
 
-```pyth
+```python
 for elt in liste_2:
 	print (elt, end='')
 ```
 
-Ici, on va afficher chaque élèment de liste_2.
+Ici, on va afficher chaque élément de liste_2.
 
-On peut également utiliser une boucle en itérant l'indice i des élèments :
+On peut également utiliser une boucle en itérant l'indice i des éléments :
 
 ```python
 for i in range (len(liste_2)):
 	print(liste_2[i], end='')
 ```
 
-Ici, pour i compris entre 0 et longueur de liste_2, on va affichier l'élèment correspondant à l'indice valant i.
+Ici, pour i compris entre 0 et longueur de liste_2, on va affichier l'élément correspondant à l'indice valant i.
 
  À faire : 
 
 - créer une liste par extension, puis par itération
-- afficher les élèments de cette liste
+- afficher les éléments de cette liste
 
 -----------
 
@@ -154,7 +154,7 @@ Ici, pour i compris entre 0 et longueur de liste_2, on va affichier l'élèment
 
 Une structure comme une liste peut être modifiable : on parle d'un objet *mutable*
 
-- On peut donc supprimer un élèment de la séquence avec le mot clé ***del***
+- On peut donc supprimer un élément de la séquence avec le mot clé ***del***
 
   ```python
   toto = [1,2,3,4,5]
@@ -163,7 +163,7 @@ Une structure comme une liste peut être modifiable : on parle d'un objet *mutab
   [2,3,4,5]
   ```
 
-  Il faut noter qu'en supprimant l'élèment situé à l'indice 0, j'ai fait changer tous les indices des élèments de la liste !
+  Il faut noter qu'en supprimant l'élément situé à l'indice 0, j'ai fait changer tous les indices des éléments de la liste !
 
 - On peut également supprimer la première occurence d'un élement à la valeur spécifiée avec le mot clé **remove** 
 
@@ -187,7 +187,7 @@ print(liste)
 
 
 
-- On peut ajouter un élèment avec le mot clé ***append***  : 
+- On peut ajouter un élément avec le mot clé ***append***  : 
 
   ```python
   liste = [1,2,3,4,5]
@@ -196,7 +196,7 @@ print(liste)
   [1,2,3,4,5,6]
   ```
 
-  - L'élèment ajouté se positionne donc à la *fin* de la liste
+  - L'élément ajouté se positionne donc à la *fin* de la liste
 
     
 
@@ -215,7 +215,7 @@ print(liste)
 
   
 
-- Pour modifier un élèment en particulier, on lui affecte une nouvelle valeur :
+- Pour modifier un élément en particulier, on lui affecte une nouvelle valeur :
 
 ```python
 t = [1,2,3,4,5]
@@ -253,17 +253,17 @@ Mais ils peuvent néanmoins contenir des données de différents types.
 
 Pour initialiser un tuple, on utilise cette syntaxe :
 
-```pyth
+```python
-tuple = (1, 3)
+mon_tuple = (1, 3)
-print (tuple)
+print (mon_tuple)
 (1, 3)
 ```
 
-Ici, de la même manière qu'avec les listes, on pourra accéder à un élèment en particulier via son indice
+Ici, de la même manière qu'avec les listes, on pourra accéder à un élément en particulier via son indice
 
 ```python
-tuple = (1, 3, 5, 7, 9)
+mon_tuple = (1, 3, 5, 7, 9)
-tuple[-1]
+mon_tuple[-1]
 9
 ```
 
@@ -271,7 +271,7 @@ De plus, on peut tout à fait utiliser l'itération pour construire ou parcourir
 
 Enfin, il est courant, dans une fonction, de renvoyer plusieurs valeurs. Par exemple, via ce type de syntaxe :
 
-```pyth
+```python
 return a, b
 ```