typo, correction bloc de code et orthographe
This commit is contained in:
@@ -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
|
||||
tuple = (1, 3)
|
||||
print (tuple)
|
||||
```python
|
||||
mon_tuple = (1, 3)
|
||||
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)
|
||||
tuple[-1]
|
||||
mon_tuple = (1, 3, 5, 7, 9)
|
||||
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
|
||||
```
|
||||
|
||||
|
||||
Reference in New Issue
Block a user