maj fichier matrice
This commit is contained in:
40
representation_construits/chapitre_1/MATRICES.md
Normal file
40
representation_construits/chapitre_1/MATRICES.md
Normal file
@@ -0,0 +1,40 @@
|
||||
# Tableaux Python
|
||||
|
||||
|
||||
|
||||
En python, une matrice est un *tableau de tableaux*.
|
||||
|
||||
```python
|
||||
matrice= [[2,4,3,7],[1,3,6,7],[5,7,0,2],[1,8,9,3]]
|
||||
```
|
||||
|
||||
On peut représenter l'instruction ci dessus de cette manière :
|
||||
|
||||
| 2 | 4 | 3 | 7 |
|
||||
| ---- | ---- | ---- | ---- |
|
||||
| 1 | 3 | 6 | 7 |
|
||||
| 5 | 7 | 0 | 2 |
|
||||
| 1 | 8 | 9 | 3 |
|
||||
|
||||
Pour accéder à un élèment d'une matrice, s'agissant d'un tableau de tableaux, on utilisera deux *indices* :
|
||||
|
||||
- L'indice du tableau contenant l'élèment
|
||||
- L'indice de l'élèment dans le tableau selectionné précédemment
|
||||
|
||||
On accède donc à l'élèment situé en ligne **i** et colonne **j** par
|
||||
|
||||
```pyth
|
||||
matrice[i][j]
|
||||
```
|
||||
|
||||
Par exemple si l'on reprend le tableau ci dessus :
|
||||
|
||||
```python
|
||||
matrice[2][3]
|
||||
2
|
||||
```
|
||||
|
||||
Soit la matrice m = [["a","b"],["c","d"],["e","f"],["g","h"]]
|
||||
|
||||
Comment accéder à l'élément "e" ?
|
||||
|
||||
@@ -17,17 +17,17 @@
|
||||
|
||||
----------
|
||||
|
||||
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.
|
||||
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.
|
||||
|
||||
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 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.
|
||||
|
||||
--------
|
||||
|
||||
### Les listes
|
||||
### Les tableaux
|
||||
|
||||
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 ?
|
||||
|
||||
Par exemple, si l'on décide de de manipuler une demi-douzaine de variables, doit on les déclarer comme ceci :
|
||||
Par exemple, si l'on décide de de manipuler une demi-douzaine de variables, doit on les déclarer comme ceci ?
|
||||
|
||||
```python
|
||||
var1 = int(input())
|
||||
@@ -38,31 +38,31 @@ var5 = int(input())
|
||||
var6 = int(input())
|
||||
```
|
||||
|
||||
Nous allons voir qu'avec une liste, nous allons pouvoir déclarer une variable à valeurs multiples.
|
||||
Nous allons voir que la structure de données appelée tableau va nous permettre de déclarer une variable à valeurs multiples.
|
||||
|
||||
-----------------
|
||||
|
||||
### Créer une liste
|
||||
### Créer un tableau
|
||||
|
||||
Liste vide :
|
||||
- Vide :
|
||||
|
||||
```python
|
||||
nom_liste = [ ]
|
||||
tab = [ ]
|
||||
```
|
||||
|
||||
On peut les créer par ***extension*** (comprendre *liste déclarée littéralement*) comme ceci :
|
||||
- On peut les créer par ***extension*** (comprendre *un tableau déclaré littéralement*) comme ceci :
|
||||
|
||||
```python
|
||||
nom_liste = [3, 8, 5, 4]
|
||||
tab = [3, 8, 5, 4]
|
||||
```
|
||||
|
||||
Mais aussi par ***compréhension*** (itération, que l'on verra plus loin)
|
||||
- Mais aussi par ***compréhension*** (itération, que l'on verra plus loin)
|
||||
|
||||
On peut tester ça dans la console python
|
||||
|
||||
```python
|
||||
lst = [2, 3, 5, 7 ]
|
||||
type (lst)
|
||||
tab = [2, 3, 5, 7 ]
|
||||
type (tab)
|
||||
```
|
||||
|
||||
Que retournent ces lignes python ?
|
||||
@@ -70,128 +70,128 @@ Que retournent ces lignes python ?
|
||||
On peut afficher la liste de la même manière qu'une variable classique : avec la commande *print*
|
||||
|
||||
```python
|
||||
print(lst)
|
||||
print(tab)
|
||||
```
|
||||
|
||||
--------------
|
||||
|
||||
### Accéder aux élèments d'une liste
|
||||
### Accéder aux élèments d'un tableau
|
||||
|
||||
Les élèments d'une liste peuvent être comparé à des élèments d'une séquence : chaque élèment a une position précise dans la liste, comme nous l'avons vu pour les chaînes de caractères (*str*)
|
||||
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*).
|
||||
|
||||
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'un tableau 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 un tableau, on utilise la fonction ***len***
|
||||
|
||||
```python
|
||||
lst = [2,4,6,8]
|
||||
len (lst)
|
||||
t_1 = [2,4,6,8]
|
||||
len (t_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
|
||||
lst [1:3]
|
||||
t_1[1:3]
|
||||
```
|
||||
|
||||
Attention : Un indice qui dépasse la valeur *longueur de la liste - 1* provoquera une erreur dans votre code
|
||||
Attention : Un indice qui dépasse la valeur *longueur du tableau - 1* provoquera une erreur dans votre code
|
||||
|
||||
----------
|
||||
|
||||
### Parcours d'une liste
|
||||
### Parcours d'une séquence
|
||||
|
||||
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*
|
||||
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*.
|
||||
|
||||
Celà signifie qu'on construit une liste à partir d'élèments itérables : que l'on peut répétèr. Par exemple :
|
||||
Celà signifie qu'on construit ce tableau à partir d'élèments itérables : que l'on peut répétèr. Par exemple :
|
||||
|
||||
```pyth
|
||||
liste = [x for x in range(5)]
|
||||
print(liste)
|
||||
tab = [x for x in range(5)]
|
||||
print(tab)
|
||||
```
|
||||
|
||||
Que vous affiche la console ?
|
||||
|
||||
L'intérêt des listes par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...
|
||||
L'intérêt de tableaux par compréhension, c'est que l'on peut utiliser les structures conditionnelles, à l'aide de boucles...
|
||||
|
||||
On peut également initialiser une liste à partir d'une autre liste
|
||||
On peut également initialiser un tableau à partir d'un autre :
|
||||
|
||||
```pytho
|
||||
liste = [1, 2, 3, 4]
|
||||
nouvelle_liste = [2 * x for x in liste]
|
||||
print(nouvelle_liste)
|
||||
tab_1 = [1, 2, 3, 4]
|
||||
tab_2 = [2 * x for x in liste]
|
||||
print(tab_2)
|
||||
```
|
||||
|
||||
Une fois que la liste est crée, on peut la parcourir :
|
||||
Une fois que votre conteneur est crée, on peut le parcourir :
|
||||
|
||||
```pyth
|
||||
for elt in lst:
|
||||
for elt in tab_2:
|
||||
print (elt, end='')
|
||||
```
|
||||
|
||||
Ici, on va afficher chaque élèment de la liste lst
|
||||
Ici, on va afficher chaque élèment de tab_2.
|
||||
|
||||
On peut également utiliser une boucle en itérant l'indice i des élèments :
|
||||
|
||||
```python
|
||||
for i in range (len(lst)):
|
||||
print(lst[i], end='')
|
||||
for i in range (len(tab_2)):
|
||||
print(tab_2[i], end='')
|
||||
```
|
||||
|
||||
Ici, pour i compris entre 0 et longueur de lst, on va affichier l'élèment correspondant à l'indice valant i.
|
||||
Ici, pour i compris entre 0 et longueur de tab_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 d'une liste
|
||||
- créer un tableau par extension, puis par itération
|
||||
- afficher les élèments de ce tableau
|
||||
|
||||
-----------
|
||||
|
||||
### Propriétés d'une liste
|
||||
### Propriétés
|
||||
|
||||
Une liste peut être modifiable : on parle d'un objet *mutable*
|
||||
Une structure comme un tableau peut être modifiable : on parle d'un objet *mutable*
|
||||
|
||||
- On peut donc supprimer un élèment d'une liste avec le mot clé *del*
|
||||
- On peut donc supprimer un élèment de la séquence avec le mot clé *del*
|
||||
|
||||
```pyth
|
||||
lst = [1,2,3,4,5]
|
||||
del lst[0]
|
||||
print(lst)
|
||||
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 donc 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 du tableau !
|
||||
|
||||
|
||||
|
||||
- On peut également ajouter un élèment à la liste :
|
||||
- On peut également ajouter un élèment :
|
||||
|
||||
```py
|
||||
lst = [1,2,3,4,5]
|
||||
lst.append(6)
|
||||
print (lst)
|
||||
tab = [1,2,3,4,5]
|
||||
tab.append(6)
|
||||
print (tab)
|
||||
[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* du tableau.
|
||||
|
||||
|
||||
|
||||
- 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 :
|
||||
|
||||
```pyth
|
||||
lst = [1,2,3,4,5]
|
||||
lst[1] = 8
|
||||
print (lst)
|
||||
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 une liste
|
||||
- Il est préférable de ne stocker que des données de même type dans un tableau.
|
||||
|
||||
Une liste peut être passée comme paramètre d'une fonction
|
||||
- Il peut-être passé comme paramètre d'une fonction
|
||||
|
||||
--------
|
||||
|
||||
@@ -199,7 +199,7 @@ Une liste peut être passée comme paramètre d'une fonction
|
||||
|
||||
## Les tuples (ou p-uplets)
|
||||
|
||||
À 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.
|
||||
À 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.
|
||||
|
||||
Mais ils peuvent néanmoins contenir des données de différents types.
|
||||
|
||||
@@ -233,7 +233,7 @@ En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple compos
|
||||
|
||||
### À retenir:
|
||||
|
||||
***Pour les listes et tuples :***
|
||||
***Pour les tableaux et tuples :***
|
||||
|
||||
| Opération | Résultat |
|
||||
| ---------- | ------------------------------------------------------------ |
|
||||
@@ -248,14 +248,15 @@ En réalité, cette syntaxe signifie : return (a, b) : on a donc un tuple compos
|
||||
| t[i:j] | Renvoie une partie de t de l'indice i à j non inclus |
|
||||
| t.index(x) | Renvoie l'indice de la première apparition de x dans t |
|
||||
| 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 |
|
||||
| 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 listes :***
|
||||
***Uniquement pour les tableaux :***
|
||||
|
||||
| Opération | Résultat |
|
||||
| -------------- | ------------------------------------------------------------ |
|
||||
| l.append(x) | Ajoute l'élément x à la fin de la liste l |
|
||||
| l[i] = x | Modifie la liste et affecte la valeur x à la case d'indice i |
|
||||
| l.insert(i, x) | Insère l'élément x dans la liste l à la position de l'indice i |
|
||||
| l.remove(x) | Supprime de la liste le premier élément dont la valeur est égale à x |
|
||||
| l.pop(i) | Enlève de la liste l'élément à la position i et renvoie sa valeur |
|
||||
| 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.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 |
|
||||
|
||||
|
||||
@@ -1,40 +0,0 @@
|
||||
# Tableaux Python
|
||||
|
||||
|
||||
|
||||
En python, un tableau est une liste de listes
|
||||
|
||||
```python
|
||||
tableau = [[2,4,3,7],[1,3,6,7],[5,7,0,2],[1,8,9,3]]
|
||||
```
|
||||
|
||||
On peut représenter le tableau suivant de cette manière :
|
||||
|
||||
| 2 | 4 | 3 | 7 |
|
||||
| ---- | ---- | ---- | ---- |
|
||||
| 1 | 3 | 6 | 7 |
|
||||
| 5 | 7 | 0 | 2 |
|
||||
| 1 | 8 | 9 | 3 |
|
||||
|
||||
Pour accéder à un élèment d'un tableau, puisqu'il s'agit d'une liste de liste, on utilisera deux *indices* :
|
||||
|
||||
- L'indice de la liste contenant l'élèment
|
||||
- L'indice de l'élèment dans la liste
|
||||
|
||||
On accède donc à l'élèment situé en ligne n°i et colonne n° j par
|
||||
|
||||
```pyth
|
||||
tab [i][j]
|
||||
```
|
||||
|
||||
Par exemple si l'on reprend le tableau ci dessus :
|
||||
|
||||
```python
|
||||
tableau [2][3]
|
||||
2
|
||||
```
|
||||
|
||||
Soit le tableau t = [["a","b"],["c","d"],["e","f"],["g","h"]]
|
||||
|
||||
Comment accéder à l'élément "e" ?
|
||||
|
||||
Reference in New Issue
Block a user