Florian/1ereNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

edit cours listes & tuples

Browse Source
This commit is contained in:
Florian Mathieu
2023-07-06 20:53:12 +02:00
parent 45a9a96ab5
commit 3365dd6adb
2 changed files with 110 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Progression.md
View File

@@ -1,11 +1,11 @@
| Séquence | Contenu | Projets associés |
| -------- | ------------------------------------------------------------ | -------------------------- |
| 1 - a | Introduction NSI, Découverte du markdown, jupyter notebook | - |
| 1 - b | Introduction à la programmation et révisions python | - |
| 1 - b | Introduction à la programmation et révisions python - variables, instructions conditionnelles, boucles, fonctions | - |
| 2 - a | Numération - Représentation des données : types et valeurs de base | Calculatrice |
| 2 - b | Représentation des données, types construits : listes, tuples, dictionnaires, données en table, structures imbriquées et compréhensions | Projet Pokedex, Zoo |
| 3 - a | Interactions entre l’homme et la machine sur le Web : html, css, javascript | Projet site web, projet JS |
| 3 - b | Les fonctions en python, constructions élémentaires, spécifications, mise au point de programmes, utilisation de bibliothèques | Mise au point de fonctions |
| 3 - b | Constructions élémentaires, spécifications, mise au point de programmes, utilisation de bibliothèques | Mise au point de fonctions |
| 4 - a | Architecture Informatique : historique de l'informatique, modèle Von Neumann, os... | Linux, M999 |
| 4 - b | Algorithmes : parcours séquentiel d'un tableau, algorithmes de tri, dichotomie... | Problème du crêpier |
| 5 - a | Algorithmes avancés : algorithmes gloutons, knn... | Pokedex avancé, Choipeaux |

166
representation_construits/chapitre_1/README.md
View File

@@ -1,9 +1,9 @@
## Représentation des données : tuples, tableaux et itérations
## Représentation des données : tuples, listes et itérations
-------------
> ***Contenue*** : Notions introduites : le type conteneur, avec les tableaux, les tuples, parcours de séquences.
> ***Compétences*** : Comprendre la différence entre un tableau python et un tuple. Maîtriser la création de conteneurs sur Python.
> ***Contenue*** : 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
@@ -17,15 +17,15 @@
----------
Les types *conteneurs* comme les tuples ou les tableaux permettent de stocker des objets, et proposent des méthodes d'accès, de modification et d'itération sur ces mêmes objets.
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 tableaux, 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 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.
--------
### Les tableaux
### Les listes
Pour le moment, nous n'avons appris à travailler qu'avec un nombre limité de variables. Cependant, il peut arriver que vous deviez lire, stocker, traiter et enfin imprimer des dizaines, voire des centaines ou des milliers de valeurs de données. Comment stocker et accéder efficacement à ces données ?
Pour le moment, nous n'avons appris à travailler qu'avec un nombre limité de variables. Cependant, il peut arriver que vous deviez lire, stocker, traiter et enfin imprimer des dizaines, voire des centaines ou des milliers de valeurs de données. Comment accéder efficacement à ces données ?
Par exemple, si l'on décide de de manipuler une demi-douzaine de variables, doit on les déclarer comme ceci ?
@@ -38,22 +38,22 @@ var5 = int(input())
var6 = int(input())
```
Nous allons voir que la structure de données appelée tableau va nous permettre de déclarer une variable à valeurs multiples.
Nous allons voir que la structure de données appelée liste va nous permettre de déclarer une variable à valeurs multiples.
-----------------
### Créer un tableau
### Créer une liste
- Vide :
```python
tab = [ ]
liste = [ ]
```
- On peut les créer par ***extension*** (comprendre *un tableau déclaré littéralement*) comme ceci :
- On peut les créer par ***extension*** (comprendre *une liste déclaré littéralement*) comme ceci :
```python
tab = [3, 8, 5, 4]
liste = [3, 8, 5, 4]
```
- Mais aussi par ***compréhension*** (itération, que l'on verra plus loin)
@@ -61,13 +61,13 @@ tab = [3, 8, 5, 4]
On peut tester ça dans la console python
```python
tab = [2, 3, 5, 7 ]
type (tab)
liste = [2, 3, 5, 7 ]
type (liste)
```
Que retournent ces lignes python ?
On peut afficher le tableau de la même manière qu'une variable classique : avec la commande *print*
On peut afficher la liste de la même manière qu'une variable classique : avec la commande *print*
```python
print(tab)
@@ -75,123 +75,171 @@ print(tab)
--------------
### Accéder aux élèments d'un tableau
### Accéder aux élèments d'une liste
Les élèments d'un tableau 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.
Le premier élèment d'un tableau 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.
Pour connaître le nombre total d'élèments dans un tableau, on utilise la fonction ***len***
Pour connaître le nombre total d'élèments dans une liste, on utilise la fonction ***len***
```python
t_1 = [2,4,6,8]
len (t_1)
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*** :
```py
t_1[1:3]
l_1[1:3]
```
Attention : Un indice qui dépasse la valeur *longueur du tableau - 1* provoquera une erreur dans votre code
Attention : Un indice qui dépasse la valeur *longueur de la liste - 1* provoquera une erreur dans votre code
----------
### Parcours d'une séquence
Comme indiqué plus haut, il est possible de créer et de parcourir un tableau par une méthode dite *de compréhension* ou *itération*.
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 ce tableau à 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étèr. Par exemple :
```pyth
tab = [x for x in range(5)]
print(tab)
liste = [x for x in range(5)]
print(liste)
```
Que vous affiche la console ?
L'intérêt de tableaux par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...
L'intérêt des listes par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...
On peut également initialiser un tableau à partir d'un autre :
On peut également initialiser une liste à partir d'une autre :
```pytho
tab_1 = [1, 2, 3, 4]
tab_2 = [2 * x for x in tab_2]
print(tab_2)
liste_1 = [1, 2, 3, 4]
liste_2 = [2 * x for x in tab_1]
print(liste_2)
```
Une fois que votre conteneur est crée, on peut le parcourir :
```pyth
for elt in tab_2:
for elt in liste_2:
print (elt, end='')
```
Ici, on va afficher chaque élèment de tab_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 :
```python
for i in range (len(tab_2)):
print(tab_2[i], end='')
for i in range (len(liste_2)):
print(liste_2[i], end='')
```
Ici, pour i compris entre 0 et longueur de tab_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 un tableau par extension, puis par itération
- afficher les élèments de ce tableau
- créer une liste par extension, puis par itération
- afficher les élèments de cette liste
-----------
### Propriétés
Une structure comme un tableau peut être modifiable : on parle d'un objet *mutable*
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***
```pyth
```python
toto = [1,2,3,4,5]
del toto[0]
print(toto)
[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 du tableau !
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**
```python
liste = [1, 2, 3, 2, 4, 5]
liste.remove(2)
print(liste)
[1,3,2,4,5]
```
- Pour en terminer avec la suppression d'élément, le mot clé ***pop*** permet de supprimer et de renvoyer l'élément à une position spécifique. Par défaut, il supprime et renvoie le dernier élément de la liste
```python
liste = [1, 2, 3, 4, 5]
dernier = liste.pop()
print(dernier)
5
print(liste)
[1, 2, 3, 4]
```
- On peut également ajouter un élèment :
- On peut ajouter un élèment avec le mot clé ***append*** :
```py
tab = [1,2,3,4,5]
tab.append(6)
print (tab)
```python
liste = [1,2,3,4,5]
liste.append(6)
print (liste)
[1,2,3,4,5,6]
```
L'élèment ajouté se positionne donc à la *fin* du tableau.
- L'élèment ajouté se positionne donc à la *fin* de la liste
- On peut également insérer un élément à une position spécifique dans la liste, avec ***insert*** :
```python
liste = [1, 2, 3, 4, 5]
liste.insert(2, 'trois')
print(liste)
[1, 2, 'trois', 3, 4, 5]
```
- Pour modifier un élèment en particulier, on lui affecte une nouvelle valeur :
```pyth
```python
t = [1,2,3,4,5]
t[1] = 8
print (t)
[1,8,3,4,5,6]
```
- Il est préférable de ne stocker que des données de même type dans un tableau.
- Il est préférable de ne stocker que des données de même type dans une liste.
- Il peut-être passé comme paramètre d'une fonction
- Enfin, il est possible de trier les éléments d'une liste en place, c'est-à-dire qu'elle modifie la liste elle-même, avec le mot clé ***sort***
```python
liste = [3, 1, 4, 1, 5, 9]
liste.sort()
print(liste)
[1, 1, 3, 4, 5, 9]
```
- Une liste peut-être passée comme paramètre d'une fonction
--------
@@ -199,7 +247,7 @@ print (t)
## Les tuples (ou p-uplets)
À la différence des tableaux, les tuples ne sont ***pas mutables***. On ne peut donc plus les modifier une fois créés, leur taille est fixe.
À la différence des listes, les tuples ne sont ***pas mutables***. On ne peut donc plus les modifier une fois créés, leur taille est fixe.
Mais ils peuvent néanmoins contenir des données de différents types.
@@ -211,7 +259,7 @@ print (tuple)
(1, 3)
```
Ici, de la même manière qu'avec les tableaux, 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)
@@ -233,7 +281,7 @@ En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple compos
### À retenir:
***Pour les tableaux et tuples :***
***Pour les listes et tuples :***
| Opération | Résultat |
| ---------- | ------------------------------------------------------------ |
@@ -250,13 +298,13 @@ En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple compos
| t.count(x) | Renvoie le nombre d'apparitions de x dans t |
| s + t | Renvoie une nouvelle séquence qui correspond à la concaténation de s et de t (seulement si s et t ont le même type) |
***Uniquement pour les tableaux :***
***Uniquement pour les listes :***
| Opération | Résultat |
| -------------- | ------------------------------------------------------------ |
| t.append(x) | Ajoute l'élément x à la fin du tableau t |
| t[i] = x | Modifie le tableau et affecte la valeur x à la case d'indice i |
| t.append(x) | Ajoute l'élément x à la fin de la liste t |
| t[i] = x | Modifie la liste et affecte la valeur x à la case d'indice i |
| t.insert(i, x) | Insère l'élément x à la position de l'indice i |
| t.remove(x) | Supprime le premier élément dont la valeur est égale à x |
| t.pop(i) | Enlève du tableau l'élément à la position i et renvoie sa valeur |
| t.pop(i) | Enlève de la liste l'élément à la position i et renvoie sa valeur |