Commit 3d3ea250 authored by Matthieu Boileau's avatar Matthieu Boileau
Browse files

Minor in 02

parent 4ee039a7
%% Cell type:markdown id: tags:
# Variables et types de données
![](fig/python-logo.png)
- Variables
- Types de données
- Fichiers
***
*Contenu sous licence [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0)*
%% Cell type:markdown id: tags:
## Langage python et sa syntaxe
### Variables et affectation
Pour accéder à une donnée, on lui donne un nom que l'on appelle variable.
Cette opération s'appelle une **affectation** (ou *assignation*) et se fait avec l'opérateur `=`.
```python
variable_x = donnee_x
```
signifie qu'on affecte la `donnee_x` à la `variable_x`.
Exécutez la cellule suivante pour définir trois variables nommées : `age`, `prenom` et `taille`.
%% Cell type:code id: tags:
``` python
```
# Par exemple: donnons la valeur 23 à la variable 'age'
age = 23
# Les variables peuvent se référer à divers types de données : des chaînes de caractères...
prenom = 'Julien'
# Des nombres réels, etc...
taille = 1.83
```
%% Cell type:markdown id: tags:
### Le mécanisme d'affectation en détail
Lors de l'affectation `x = donnee_x`, Python :
1. crée et mémorise le nom de variable `x`
3. crée un objet dont le type dépend de la nature de la donnée et y stocke la valeur particulière `donnee_x`
4. établit une référence entre le nom de la variable `x` et l'emplacement mémoire de `donnee_x`. Cette référence est mémorisée dans l'espace de nom.
%% Cell type:markdown id: tags:
### Accéder à la valeur d'une variable
Pour se servir de la donnée référencée par une variable, il suffit d'utiliser le nom cette variable.
La fonction [``print()``](https://docs.python.org/3/library/functions.html#print) affiche à l'écran ce qui lui est passé en paramètre. On peut lui donner plusieurs paramètres séparés par des virgules : ``print()`` les affichera tous, séparés par un espace.
%% Cell type:code id: tags:
``` python
```
print('Julien', 23, 1.83)
print(prenom, 'a', age, 'ans, et mesure', taille, 'mètre')
```
%% Cell type:markdown id: tags:
Les variables peuvent changer et ainsi se référer à une autre donnée.
%% Cell type:code id: tags:
``` python
```
age = 23
print(age)
age = 24
print(age)
```
%% Cell type:markdown id: tags:
### L'affectation du point de vue de l'objet
#### La notion d'objet
En python, toute donnée est contenue dans un **objet.**
En programmation, un objet est un conteneur qui regroupe :
- des données
- les méthodes pour interagir avec ces données
Exemple de l'objet de type entier relatif (`int`) :
- sa donnée : la valeur du nombre entier
- ses méthodes : les opérations mathématiques, la conversion vers les chaînes de caractères, etc.
%% Cell type:markdown id: tags:
Affecter une valeur à une variable revient à nommer un objet, c'est-à-dire référencer cet objet par un nom.
Exemple avec l'entier `7` :
- pour Python, `7` est l'objet de type entier (`int`) dont la donnée est le nombre $~7$
- lorsqu'on écrit `7` dans un programme, Python crée l'objet correspondant et lui affecte un identifiant unique dans l'espace de nom courant.
- cet identifiant est renvoyé par la fonction intrinsèque [`id()`](https://docs.python.org/3/library/functions.html#id) :
%% Cell type:code id: tags:
``` python
```
print(id(7))
```
%% Cell type:markdown id: tags:
```python
x = 7
```
signifie qu'on nomme l'objet `7` avec la variable `x`.
Autrement dit, `x` devient **une référence vers cet objet.**
%% Cell type:code id: tags:
``` python
```
print(id(7))
x = 7
print(id(x))
y = x
print(id(y)) # y référence le même objet que x
```
%% Cell type:markdown id: tags:
### Le type
Les variables n'ont pas de type propre : c'est la donnée qui est typée, pas la variable qui la référence.
Une variable peut donc faire référence à une donnée d'un autre type après une nouvelle assignation.
Une variable peut donc faire référence à une donnée d'un autre type après une nouvelle affectation.
La fonction [`type()`](https://docs.python.org/3/library/functions.html#type) retourne le type effectif de la donnée passée en paramètre.
%% Cell type:code id: tags:
``` python
```
# Des nombres
age = 23
print(type(age))
```
%% Cell type:code id: tags:
``` python
```
# Les variables peuvent aussi changer de type : chaîne de caractères
age = 'vingt quatre ans'
print(type(age))
```
%% Cell type:code id: tags:
``` python
```
# Sans limites...
age = 24.5
print(type(age))
```
%% Cell type:code id: tags:
``` python
```
# Attention aux pièges...
age = '25'
print(type(age))
```
%% Cell type:markdown id: tags:
Une variable peut être initialisée avec des valeurs constantes, comme vu précédement, mais aussi à partir d'autres variables ou de valeurs retournées par des opérations, des fonctions, etc.
**Exemple :** La fonction [max()](https://docs.python.org/3/library/functions.html#min) retourne le plus grand de ses paramètres.
%% Cell type:code id: tags:
``` python
```
a = 1
b = a
c = a * 2
d = max(a, 2, 3, c)
print(a, b, c, d)
```
%% Cell type:markdown id: tags:
Les variables, une fois définies dans une cellule **exécutée**, continuent d'exister dans les suivantes car toutes les cellules sont connectées à la même instance du noyau python.
> **Note :** En cas de redémarrage du notebook, toutes les variables existantes sont détruites, il faut donc ré-exécuter les cellules qui les définissent si l'on veut de nouveau pouvoir les utiliser.
%% Cell type:code id: tags:
``` python
```
abcd = 1234
```
%% Cell type:markdown id: tags:
Ici, la variable nommée ``abcd`` survit, d'une cellule à la suivante...
%% Cell type:code id: tags:
``` python
```
print(abcd)
```
%% Cell type:markdown id: tags:
Si on veut faire disparaître une variable, on peut utiliser la fonction [`del()`](https://docs.python.org/3/reference/simple_stmts.html#the-del-statement).
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
a = 2
print(a)
del(a)
print(a)
```
%% Cell type:markdown id: tags:
**Note :** [``del``](https://docs.python.org/3/reference/simple_stmts.html#the-del-statement) est aussi utilisé pour enlever des éléments dans des conteneurs modifiables (listes, dictionnaires). Nous aborderons ce sujet plus tard.
%% Cell type:markdown id: tags:
## Types de données
#### Types de base
- None
- Booléens
- Numériques
- entiers
- flottants
- complexes
%% Cell type:markdown id: tags:
#### Séquences
- Chaines de caractères
- listes
- tuples
%% Cell type:markdown id: tags:
#### Conteneurs
- Dictionnaires
- Ensembles
%% Cell type:markdown id: tags:
#### Fichiers
%% Cell type:markdown id: tags:
## Types de base
### `None`
- Il existe dans python un type de données particulier : `None`.
- `None` représente un objet sans valeur. On s'en sert comme valeur de retour en cas d'erreur ou pour représenter un cas particulier.
- `None` est équivalent à `NULL` en Java et en C.
%% Cell type:code id: tags:
``` python
```
a = None
print(a)
print(type(a))
```
%% Cell type:markdown id: tags:
### Booléens
Les booléens ne peuvent avoir que deux valeurs :
```python
True, False
```
On peut utiliser la fonction [`bool()`](https://docs.python.org/3/library/functions.html#bool) pour construire un booléen.
Dans un contexte booléen, toutes ces valeurs sont équivalentes à `False` :
- `None`
- le zéro des types numériques, par exemple : `0, 0.0, 0j`.
- les séquences vides, par exemple : `'', (), []`.
- les dictionnaires vides, par exemple, `{}`.
Tout le reste est équivalent à `True` :
- une valeur numérique différente de zéro
- une séquence non vide
- un dictionnaire non vide
%% Cell type:markdown id: tags:
#### Exemples de constructions de valeurs booléennes à partir d'autres types
%% Cell type:code id: tags:
``` python
```
print(bool(None), bool())
print(bool(0), bool(1))
print(bool(0.0), bool(0.5))
print(bool(0j), bool(3j))
print(bool(''), bool('abc'))
print(bool(()), bool((1, 0.5, 'toto')))
print(bool([]), bool([None]))
print(bool({}), bool({'ane': True, 'chat': True}))
```
%% Cell type:markdown id: tags:
#### Exemple d'utilisation d'un contexte booléen
%% Cell type:code id: tags:
``` python
```
Am_I_OK = True
if Am_I_OK:
print('OK')
else:
print('KO')
print(Am_I_OK)
print(type(Am_I_OK))
```
%% Cell type:markdown id: tags:
> **Exercice :**
> 1. Supposons que vous soyez malade, mettez `Am_I_OK` à la valeur `False` puis réexecutez la cellule.
> 2. Essayez avec d'autres types : `list`, `None`, nombres, etc...
%% Cell type:markdown id: tags:
### Numériques
#### Entiers
La taille est illimitée.
%% Cell type:code id: tags:
``` python
```
# Il n'y a plus de distinction entre les entiers "courts" et les entiers "longs"
entier = 4
print(entier)
print(type(entier))
# Ce nombre nécéssite 131 bits
entier = 1415926535897932384626433832795028841971
print(entier)
print(type(entier))
```
%% Cell type:markdown id: tags:
Ou plus exactement, la taille n'est pas limitée par le langage mais par la mémoire disponible sur le système.
> **Note :** En python version < 3, il existait deux types distincts ``int`` et ``long``...
%% Cell type:markdown id: tags:
- On peut utiliser la fonction interne [``int()``](https://docs.python.org/3/library/functions.html#int) pour créer des nombres entiers.
- `int()` peut créer des entiers à partir de leur représentation sous forme de chaîne de caractères
- On peut aussi spécifier la base :
%% Cell type:code id: tags:
``` python
```
entier = int(12)
print(entier)
print(type(entier))
entier = int('13')
print(entier)
print(type(entier))
entier = int('0xFF', 16)
print(entier)
print(type(entier))
```
%% Cell type:markdown id: tags:
#### Flottants (réels 64 bits)
Pour créer des nombres réels (en virgule flottante), on peut utiliser la fonction interne [``float()``](https://docs.python.org/3/library/functions.html#float).
La précision est limitée à 16 chiffres significatifs.
%% Cell type:code id: tags:
``` python
```
pi_approx = 3.1415926535897932
print(pi_approx)
print(type(pi_approx))
print('{:.16f}'.format(pi_approx))
tropgros = float('Infinity')
print(type(tropgros))
print(tropgros)
```
%% Cell type:markdown id: tags:
#### Flottants
Attention ! Python autorise un affichage plus long que la précision des flottants mais tous les chiffres après le 16ème chiffre significatif sont faux :
%% Cell type:code id: tags:
``` python
```
# On demande 20 chiffres après la virgule, alors que 16 seulement sont exacts
print('{:.20f}'.format(pi_approx))
```
%% Cell type:markdown id: tags:
Attention à ne pas effectuer des opérations interdites...
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
print(3.14 / 0)
```
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
print(34 % 0)
```
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
print(27 // 0.0)
```
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
print(1 + None)
```
%% Cell type:markdown id: tags:
#### Complexes
Les nombres complexes, à deux dimensions, peuvent être créés en utilisant le suffixe `j` à la fin d'un entier ou réel ou en utilisant la fonction interne [`complex()`](https://docs.python.org/3/library/functions.html#complex)
%% Cell type:code id: tags:
``` python
```
complexe = 1 + 2j
print('représentation :', complexe)
print(type(complexe))
c = .3j
print(c)
```
%% Cell type:markdown id: tags:
## Séquences
Les séquences sont des conteneurs d'objets où les objets référencés sont ordonnés.
Python supporte nativement trois types de séquences :
- les chaînes de caractères
- les listes
- les tuples
%% Cell type:markdown id: tags:
### Chaînes de caractères
Pour le traitement de données textuelles, python utilise les chaînes de caractères.
Pour délimiter le texte on utilise des guillemets `"` (double-quote) ou des apostrophes `'` (single-quote).
%% Cell type:code id: tags:
``` python
```
mois1 = 'janvier'
mois2 = "février"
print(mois1, mois2)
```
%% Cell type:markdown id: tags:
Les deux formes sont très utiles car elles permettent d'utiliser des guillemets ou des apostrophes dans des chaînes de caractères de manière simple.
%% Cell type:code id: tags:
``` python
```
arbre = "l'olivier"
print(arbre)
cuisson_pates = "huit minutes (8')"
print(cuisson_pates)
record_100m = 'neuf secondes et 58 dixièmes (9"58)'
print(record_100m)
```
%% Cell type:markdown id: tags:
Sinon, pour avoir une apostrophe ou un guillemet dans une chaîne de caractères, il faut le faire précéder d'un `\` *(backslash)*. Ce qui est beaucoup moins lisible, mais parfois obligatoire (par exemple une chaîne avec à la fois des guillemets et des apostrophes).
%% Cell type:code id: tags:
``` python
```
arbre = 'l\'alisier'
pates = '8\''
record = "9\"58"
print(arbre, pates, record)
duel = 'guillemet: " et apostrophes: \' peuvent être utilisés dans une même chaîne...'
print(duel)
multi = '''Dans une "triplequoted" (voire plus loin), on peut (presque) tout utiliser: `"“ ”,'"«»'"' et ça ne pose pas de problème...'''
print(multi)
```
%% Cell type:markdown id: tags:
#### Caractères spéciaux
Il est possible de définir des chaînes de caractères qui contiennent des caractères spéciaux. Ils sont introduits par des séquences de deux caractères dont le premier est `\`. On l'appelle le caractère d'échappement.
- retour à la ligne : ``\n``
- tabulation : ``\t``
- *backslash :* ``\\``
- un caractère unicode avec son code : ``\uXXXX`` (où les ``XXXX`` sont le code hexadécimal représentant ce caractère)
Plus d'information dans la [documentation officielle](https://docs.python.org/3/tutorial/introduction.html#strings)
%% Cell type:code id: tags:
``` python
```
print("Une belle présentation, c'est :\n\t- bien ordonné\n\t- aligné\n\t- même s'il y en a plein\nEt c'est plus joli.")
print("Une belle présentation, c'est :")
print('\t- bien ordonné')
print('\t- aligné')
print("\t- même s'il y en a plein\nEt c'est plus joli.")
```
%% Cell type:markdown id: tags:
#### Chaînes multilignes
Pour écrire plusieurs lignes d'une façon plus lisible, il existe les chaînes multilignes :
%% Cell type:code id: tags:
``` python
```
# L'équivalent est :
print("""\
Une belle présentation, c'est :
\t- bien ordonné
\t- aligné
\t- même s'il y en a plein
Et c'est plus joli.""")
```
%% Cell type:markdown id: tags:
> **Exercice** : enlevez le caractère `\` de la 2ème ligne dans la cellule ci-dessus, et comparez le résultat à celui de la cellule de code précédente (3 cellules plus haut)
%% Cell type:markdown id: tags:
Les deux formes de délimiteurs sont aussi utilisables : guillemets triples ou apostrophes triples.
%% Cell type:code id: tags:
``` python
```
multi1 = '''m
a
r
s est un mois "multiligne"'''
print(multi1, '\n')
multi2 = """a
v
r
i
l l'est aussi"""
print(multi2)
```
%% Cell type:markdown id: tags:
#### Unicode
En python 3 , toutes les chaînes de caractères sont unicode, ce qui permet d'utiliser des alphabets différents, des caractères accentués ou des pictogrammes, etc.
Exemples de caractères spéciaux :
%% Cell type:code id: tags:
``` python
```
unicode_str = "Les échecs (♔♕♖♗♘♙), c'est \u263A"
print(unicode_str)
japanese_str = 'Du japonais : ウェブ'
print(japanese_str)
mix_str = '你好 kollha दुनिया'
print('"' + mix_str + '"', 'veut dire: "bonjour tout le monde"')
```
%% Cell type:markdown id: tags:
Pour une liste de caractères unicode, voir [ici](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
%% Cell type:markdown id: tags:
#### Chaînes brutes *(raw strings)*
Il s'agit de chaînes dans lesquelles les séquences d'échappement ne sont pas remplacées : `r'...'`, `r'''...'''`, etc.
%% Cell type:code id: tags:
``` python
```
normal_str = "chaîne normale: \n est un retour à la ligne, \t est une tabulation"
print(normal_str)
raw_str = r"chaîne RAW: \n est un retour à la ligne, \t est une tabulation"
print(raw_str)
```
%% Cell type:markdown id: tags:
#### Concaténation
Plusieurs chaînes de caractères contigües sont rassemblées.
%% Cell type:code id: tags:
``` python
```
b = 'a' 'z' 'e' 'r' 't' 'y'
print(b)
```
%% Cell type:markdown id: tags:
On peut mélanger les genres.
%% Cell type:code id: tags:
``` python
```
a = 'une chaine qui est \t' r'''la somme de \n ''' """plusieurs morceaux..."""
print(a)
```
%% Cell type:markdown id: tags:
On peut utiliser la fonction ``str()`` pour créer une chaîne de caractère à partir d'autres objets.
%% Cell type:code id: tags:
``` python
```
a = 23
ch_a = str(a)
print(type(a), a)
print(type(ch_a), repr(ch_a))
a = 3.14
ch_a = str(a)
print(type(a), a)
print(type(ch_a), repr(ch_a))
```
%% Cell type:markdown id: tags:
On ne peut pas mélanger les guillemets et les apostrophes pour délimiter une chaîne de caractères.
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
a = "azerty'
```
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
a = 'azerty"
```
%% Cell type:markdown id: tags:
> **Exercice** : corrigez les deux cellules ci dessus.
%% Cell type:markdown id: tags:
#### Le formatage de chaîne de caractère avec `format()`
On peut formater du texte, c'est à dire utiliser une chaîne de caractères qui va servir de modèle pour en fabriquer d'autres.
Historiquement, il existe plusieurs méthodes.
Nous ne voyons ici qu'une utilisation basique de la méthode [`format()`](https://docs.python.org/3/library/stdtypes.html#str.format).
%% Cell type:markdown id: tags:
`format()` remplace les occurences de ``'{}'`` par des valeurs qu'on lui spécifie en paramètre.
Le type des valeurs passées n'est pas important, une représentation sous forme de chaîne de caractère sera automatiquement créée, avec la fonction [``str()``](https://docs.python.org/3/library/functions.html#func-str).
```python
'Bonjour {} !'.format('le monde')
```
%% Cell type:code id: tags:
``` python
```
variable_1 = 27
variable_2 = 'vingt huit'
ch_modele = 'Une chaine qui contient un {} ainsi que {} et là {}'
ch_modele.format('toto', variable_1, variable_2)
```
%% Cell type:markdown id: tags:
#### Les spécifications de format
Des indicateurs peuvent être fournis à la méthode `format()` pour spécifier le type de donnée à intégrer et la manière de formater sa représentation.
- `:d` pour des entiers
- `:s` pour des chaînes de caractères
- `:f` pour des nombres flottants
- `:x` pour un nombre entier affiché en base hexadécimale
- `:o` pour un nombre entier affiché en base octale
- `:e` pour un nombre affiché en notation exponentielle
%% Cell type:code id: tags:
``` python
```
import math
a = 27
print("""un entier : {:d},
une chaîne : {:s},
un flottant avec une précision spécifiée : {:.02f}""".format(a, 'Arte', math.pi))
print('Des hexadécimaux: {:x} {:x} {:x} {:x}'.format(254, 255, 256, 257))
print('Des octaux: {:o} {:o} {:o} {:o}'.format(254, 255, 256, 257))
print('Des nombres en notation exponentielle {:e}'.format(2**64))
```
%% Cell type:markdown id: tags:
**Attention :** Si le type de la donnée passée ne correspond pas à la séquence de formatage, python va remonter une erreur.
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
variable_3 = 'une chaine de caracteres'
# Exemple d'erreur de type : on fournit une chaîne de caractères
# alors que la méthode attend un entier
print('on veut un entier : {:d}'.format(variable_3))
```
%% Cell type:markdown id: tags:
On peut se servir de cette fonctionnalité pour tabuler du texte de taille variable.
%% Cell type:code id: tags:
``` python
```
print("""
Alignons à droite les animaux:
Un animal : {:>8s}.
Un animal : {:>8s}.
Un animal : {:>18s}, qui se croit plus malin que les autres.
Un animal : {:>8s}.
Un animal : {:>8s}.""".format('âne', 'becasse', 'chat', 'dinde', 'elephant'))
```
%% Cell type:markdown id: tags:
> **Exercice** : remettez le chat à sa place.
%% Cell type:markdown id: tags:
#### *f-string*
Depuis Python 3.6, il existe une autre syntaxe appelée *f-string* qui ajoute de la concision et de la lisibilité :
```python
f"La {<variable>:<format>} est nommée dans la chaîne."
```
%% Cell type:code id: tags:
``` python
```
print('Soit {:.03f} la valeur de pi sur 3 décimales.'.format(math.pi))
# devient
print(f'Soit {math.pi:.03f} la valeur de pi sur 3 décimales.')
```
%% Cell type:markdown id: tags:
**Remarques :**
- cette syntaxe n'est pas toujours utilisable
- le code sera incompatible avec python < 3.6
%% Cell type:markdown id: tags:
Pour plus d'informations sur le formatage de chaînes de caractères, voir la [doc Python](https://docs.python.org/3/library/string.html#formatstrings) correspondante.
%% Cell type:markdown id: tags:
### Listes
- Une liste est un objet pouvant contenir d'autres objets
- Ces objets, appelés éléments, sont ordonnés de façon séquentielle, les uns à la suite des autres
- C'est un conteneur dynamique dont le nombre et l'ordre des éléments peuvent varier
On crée une liste en délimitant par des crochets ``[]`` les éléments qui la composent :
%% Cell type:code id: tags:
``` python
```
L = ['egg', 'spam', 'spam', 'spam', 'bacon']
print(L, 'est de type', type(L))
```
%% Cell type:markdown id: tags:
Une liste peut contenir n'importe quel type d'objets.
%% Cell type:code id: tags:
``` python
```
L0 = [1, 2]
L2 = [None, True, False, 0, 1, 2**64, 3.14, '', 0+1j, 'abc']
L1 = []
L2 = [None, True, False, 0, 1, 2**64, 3.14, '', 0+1j, 'abc']
L3 = [[1, 'azerty'], L0]
print(L0, L1)
print(L2)
print(L3)
```
%% Cell type:markdown id: tags:
On peut utiliser la fonction [``list()``](https://docs.python.org/3/library/functions.html#func-list) pour créer une liste a partir d'autres séquences ou objets.
%% Cell type:code id: tags:
``` python
```
a = list()
b = list('bzzzzzt')
print(a)
print(b)
```
%% Cell type:markdown id: tags:
On accède aux éléments d'une liste grâce à un indice. Le premier élément est **indicé 0.**
%% Cell type:code id: tags:
``` python
```
print(L)
print(L[0])
print(L[4])
```
%% Cell type:markdown id: tags:
Un dépassement d'indice produit une erreur :
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
print(L[10])
```
%% Cell type:markdown id: tags:
Les listes sont dites *muables* : on peut modifier la séquence de ses éléments.
%% Cell type:markdown id: tags:
Je remplace le deuxième élément :
%% Cell type:code id: tags:
``` python
```
L[1] = 'tomatoes'
print(L)
L[3] = 9
print(L)
```
%% Cell type:markdown id: tags:
#### Méthodes associées aux listes
##### Méthodes ne modifiant pas la liste
- La longueur d'une liste est donnée par fonction [`len()`](https://docs.python.org/3/library/functions.html#len)
- `L.index(elem)` renvoie l'indice de l'élément `elem` (le 1er rencontré)
##### Méthodes modifiant la liste
- `L.append()` ajoute un élément à la fin
- `L.pop()` retourne le dernier élément et le retire de la liste
- `L.sort()` trie
- `L.reverse()` inverse l'ordre
Plus d'infos dans la [doc officielle](https://docs.python.org/3/library/stdtypes.html#typesseq-mutable).
%% Cell type:markdown id: tags:
#### Exemples
%% Cell type:code id: tags:
``` python
```
L = ['egg', 'spam', 'spam', 'spam', 'bacon']
print('len() renvoie:', len(L))
L.append('spam') # Ne renvoie pas de valeur
print('Après append():', L)
print('len() renvoie:', len(L))
```
%% Cell type:code id: tags:
``` python
```
print('pop() renvoie:', L.pop())
print('Après pop():', L)
```
%% Cell type:code id: tags:
``` python
```
L.reverse() # Ne renvoie pas de valeur
print('Après reverse():', L)
```
%% Cell type:code id: tags:
``` python
```
print('index() renvoie:', L.index('egg'))
```
%% Cell type:code id: tags:
``` python
```
L.remove('spam') # Ne renvoie pas de valeur
print('Après remove:', L)
```
%% Cell type:markdown id: tags:
> Dans les exemples précédents, remarquez la syntaxe qui permet d'appliquer une méthode à un objet :
> ```python
> objet.methode()
> ```
> Ici, `.methode()` est une fonction propre au type de `objet`.
> Si `.methode()` existe pour un autre type, elle n'a pas forcément le même comportement.
> Nous verrons plus en détail ce mécanisme dans la section dédiée à la programmation objet.
%% Cell type:markdown id: tags:
Pour obtenir la liste des méthodes associées aux listes, on peut utiliser la fonction interne [`help()`](https://docs.python.org/3/library/functions.html#help) :
%% Cell type:code id: tags:
``` python
```
help(L) # ou aussi help([])
```
%% Cell type:markdown id: tags:
On peut créer facilement des listes répétitives grâce a l'opération de multiplication.
%% Cell type:code id: tags:
``` python
```
a = ['a', 1] * 5
print(a)
```
%% Cell type:markdown id: tags:
Mais on ne peut pas 'diviser' une liste.
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
a = [1, 2, 3, 4]
print(a / 2)
```
%% Cell type:markdown id: tags:
> **Exercice :** Manipulez la liste ``L`` ci-dessous avec les méthodes associées aux listes.
%% Cell type:code id: tags:
``` python
```
L = ['egg', 'spam', 'spam', 'spam', 'bacon']
# Votre code ci-dessous
```
%% Cell type:markdown id: tags:
Vous trouverez la documentation complète sur les listes [ici](https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types).
%% Cell type:markdown id: tags:
### Tuples
Les Tuples (ou n-uplets en Français) sont des séquences *immuables* :
on ne peut pas les modifier après leur création.
On les initialise ainsi :
%% Cell type:code id: tags:
``` python
```
T = ('a', 'b', 'c')
print(T, 'est de type', type(T))
T = 'a', 'b', 'c' # une autre façon, en ommettant les parenthèses
print(T, 'est de type', type(T))
T = tuple(['a', 'b', 'c']) # à partir d'une liste
print(T, 'est de type', type(T))
T = ('a') # ceci n'est pas un tuple
print(T, 'est de type', type(T))
T = ('a',) # Syntaxe pour initialiser un tuple contenant un seul élément
print(T, 'est de type', type(T))
# Syntaxe alternative pour initialiser un tuple contenant un seul élément.
# Préférez celle avec parenthèses.
T = 'a',
print(T, 'est de type', type(T))
```
%% Cell type:markdown id: tags:
Une fois créée, cette séquence ne peut être modifiée.
%% Cell type:code id: tags:
``` python
```
T = ('a', 'b', 'c')
print(T[1]) # On peut utiliser un élément
```
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
T[1] = 'z' # mais on ne peut pas le modifier
```
%% Cell type:markdown id: tags:
Intérêt des tuples par rapport aux listes :
- plus rapide à parcourir que les listes
- immuables donc "protégés"
- peuvent être utilisés comme clé de dictionnaires (cf. plus loin)
%% Cell type:markdown id: tags:
On peut créer des tuples a partir d'autres séquences ou objets grâce à la fonction [``tuple()``](https://docs.python.org/3/library/functions.html#func-tuple).
%% Cell type:code id: tags:
``` python
```
a = [1, 2, 3, 'toto']
print(type(a), a)
b = tuple(a)
print(type(b), b)
a = 'azerty'
print(type(a), a)
b = tuple(a)
print(type(b), b)
```
%% Cell type:markdown id: tags:
#### Manipulation des tuples
Construire d'autres tuples par concaténation et multiplication
%% Cell type:code id: tags:
``` python
```
T1 = 'a', 'b', 'c'
print('T1 =', T1)
T2 = 'd', 'e'
print('T2 =', T2)
print('T1 + T2 =', T1 + T2)
print('T2 * 3 =', T2 * 3)
```
%% Cell type:markdown id: tags:
### Types muables et types immuables
Avant d'aller plus loin dans la revue des types, il est important de comprendre le mécanisme d'affectation en fonction du caractère muable ou immuable de l'objet.
%% Cell type:markdown id: tags:
#### Cas d'un objet muable
- Deux noms de variables différents peuvent référencer le même objet
- Si cet objet est muable, les modifications faites par l'intermédiaire d'une des variables sont visibles par toutes les autres.
%% Cell type:code id: tags:
``` python
```
a = ['spam', 'egg'] # on initialise la variable a
b = a # b référence le même objet que a
```
%% Cell type:markdown id: tags:
`a` et `b` possèdent la même référence :
%% Cell type:code id: tags:
``` python
```
print(id(a))
print(id(b))
```
%% Cell type:markdown id: tags:
`a` et `b` contiennent la même donnée :
%% Cell type:code id: tags:
``` python
```
print(a)
print(b)
```
%% Cell type:markdown id: tags:
Si on modifie la donnée de `a`, la donnée de `b` est aussi modifiée !
%% Cell type:code id: tags:
``` python
```
a.append('bacon')
print(a)
print(b)
```
%% Cell type:markdown id: tags:
#### Cas d'un objet immuable
%% Cell type:code id: tags:
``` python
```
t = 'spam', 'egg'
u = t
print(id(t))
print(id(u))
```
%% Cell type:markdown id: tags:
`t` et `u` sont deux variables qui référencent le même objet `tuple` donc leur donnée ne peut être modifiée.
Tout ce qu'on peut faire, c'est affecter une nouvelle valeur :
%% Cell type:code id: tags:
``` python
```
t = 'bacon', 'egg'
```
%% Cell type:markdown id: tags:
Dans ce cas, `t` référence un nouvel objet alors que `u` référence toujours l'objet initial :
%% Cell type:code id: tags:
``` python
```
print(id(t))
print(id(u))
```
%% Cell type:markdown id: tags:
Et bien sûr leurs données sont différentes :
%% Cell type:code id: tags:
``` python
```
print(t)
print(u)
```
%% Cell type:markdown id: tags:
> **Exercice :** analyser ce qu'il se passe dans cette série d'instructions avec [Python Tutor](http://pythontutor.com/visualize.html#code=a%20%3D%20%5B'spam',%20'egg'%5D%0Ab%20%3D%20a%0Aa.append%28'bacon'%29%0At%20%3D%20'spam',%20'egg'%0Au%20%3D%20t%0At%20%3D%20'bacon',%20'egg'&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) .
%% Cell type:markdown id: tags:
#### Un peu plus loin...
Bien que sa séquence soit immuable, si un `tuple` est constitué d'éléments muables, alors ces éléments-là peuvent être modifiés.
Illustration avec un `tuple` dont un des éléments est une `list` :
%% Cell type:code id: tags:
``` python
```
T = ('a', ['b', 'c']) # le deuxième élément est une liste donc il est muable
print('T =', T)
L = T[1]
print('L =', L)
L[0] = 'e'
print('L =', L)
print('T =', T)
```
%% Cell type:code id: tags:
``` python
```
# Ici on fait exactement la même chose...
T = ('a', ['b', 'c'])
print('T =', T)
T[1][0] = 'z'
print('T après =', T)
```
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
T[0] = 'A' # Ici, on essaye de modifier le tuple lui même...
```
%% Cell type:markdown id: tags:
> **Exercice :** analyser ce qu'il se passe dans cette série d'instructions avec [Python Tutor](http://pythontutor.com/visualize.html#code=T%20%3D%20%28'a',%20%5B'b',%20'c'%5D%29%0AT%5B1%5D%5B0%5D%20%3D%20'z'%0A&cumulative=false&heapPrimitives=nevernest&mode=edit&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) .
%% Cell type:markdown id: tags:
### Le slicing de séquences en Python
- Cela consiste à extraire une sous-séquence à partir d'une séquence.
- Le slicing fonctionne de manière similaire aux intervalles mathématiques : `[début:fin[`
- La borne de fin ne fait pas partie de l'intervalle sélectionné.
- La syntaxe générale est `L[i:j:k]`, où :
- `i` = indice de début
- `j` = indice de fin, le premier élément qui n'est pas sélectionné
- `k` = le "pas" ou intervalle (s'il est omis alors il vaut `1`)
- La sous-liste sera donc composée de tous les éléments de l’indice `i` jusqu’à l’indice `j-1`, par pas de `k`.
- La sous-liste est un nouvel objet.
%% Cell type:markdown id: tags:
Dans le sens normal (le pas `k` est positif)
- Si `i` est omis alors il vaut `0`
- Si `j` est omis alors il vaut `len(L)`
Dans le sens inverse (le pas `k` est négatif)
- Si `i` est omis alors il vaut `-1`
- Si `j` est omis alors il vaut `-len(L)-1`
%% Cell type:markdown id: tags:
Illustrons ça en créant une liste à partir d'une chaîne de caractères.
La fonction [`split()`](https://docs.python.org/3/library/stdtypes.html#str.split) découpe une chaîne de caractères en morceaux, par défaut en 'mots'.
%% Cell type:code id: tags:
``` python
```
L = 'Dans le Python tout est bon'.split()
print(L)
```
%% Cell type:markdown id: tags:
Pour commencer, on extrait de la liste ``L`` un nouvel objet liste qui contient tous les éléments de ``L`` <=> copie de liste
%% Cell type:code id: tags:
``` python
```
print(L[0:len(L):1]) # Cette notation est inutilement lourde car :
print(L[::]) # i = 0, j=len(L) et k=1 donc i, j et k peuvent être omis
print(L[:]) # on peut même ommettre le 2ème ":"
```
%% Cell type:markdown id: tags:
On extrait une sous-liste qui ne contient que les 3 premiers éléments :
%% Cell type:code id: tags:
``` python
```
print(L[0:3:1]) # Notation complète
print(L[:3:1]) # Le premier indice vaut i=0, donc on peut l'omettre
print(L[:3]) # Le pas de slicing vaut 1, donc on peut l'omettre, ainsi que le ":"
```
%% Cell type:markdown id: tags:
J'extrais une sous-liste qui exclut les trois premiers éléments :
%% Cell type:code id: tags:
``` python
```
print(L[3:len(L):1]) # Cette notation est inutilement lourde car :
print(L[3:]) # j et k peuvent être omis, ainsi que le ":"
```
%% Cell type:markdown id: tags:
Les indices peuvent être négatifs, ce qui permet traiter les derniers éléments :
%% Cell type:code id: tags:
``` python
```
# Je veux exclure le dernier élément :
print(L[0:-1:1]) # Notation complète
print(L[:-1:1]) # Le premier indice vaut i=0, donc on peut l'omettre
print(L[:-1]) # Le pas de slicing vaut 1, donc on peut l'omettre
```
%% Cell type:markdown id: tags:
On ne garde que les deux derniers éléments
%% Cell type:code id: tags:
``` python
```
print(L[-2:])
```
%% Cell type:markdown id: tags:
#### Note
``L[1]`` n'est pas équivalent à ``L[1:2]``, ni à ``L[1:]``, ni à ``L[:1]``.
Illustration :
%% Cell type:code id: tags:
``` python
```
a = L[1]
print(type(a), a) # Je récupère le deuxième élément de la liste
a = L[1:2]
print(type(a), a) # Je récupère une liste composée du seul élément L[1]
a = L[1:]
print(type(a), a) # Je récupère une liste
a = L[:1]
print(type(a), a) # Je récupère une liste
```
%% Cell type:markdown id: tags:
> **Exercice :** Retourner une liste composée des éléments de ``L`` *en ordre inverse* **avec une opération de slicing**. Toute utilisation de [``[].reverse()``](https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types) ou [``reversed()``](https://docs.python.org/3/library/functions.html#reversed) est interdite.
%% Cell type:code id: tags:
``` python
```
L = 'Dans le Python tout est bon'.split()
print(L)
# <- votre code ici
L[-1:-len(L)-1:-1]
L[::-1]
```
%% Cell type:code id: tags:
``` python
```
# Solution
L = "Dans le Python, tout est bon.".split()
# La solution simple et élégante :
print(L[::-1])
# Explications:
# Pas de bornes => valeurs par défaut => on prend tout
# Le pas est de -1 => à l'envers
# La version explicite :
print(L[-1:-len(L)-1:-1])
# Explications :
# On commence à la dernière place
# On s'arrête à la première, exprimée en indices négatifs
# Le pas est de -1 => à l'envers
# Ne pas oublier que les indices vont:
# dans le sens normal : de 0 à 5
# dans le sens contraire : de -1 à -6
# Ne pas oublier que les bornes d'un slice qui prend tout les éléments vont:
# dans le sens normal : de 0 à 6
# dans le sens contraire : de -1 à -7
# La solution "optimale" : elle utilise un iterateur et donc
# ne consomme aucune ressource tant qu'on ne l'utilise pas
print(list(reversed(L)))
# Pour le fun, voici une version fonctionelle récursive
def rev(alist):
if not alist:
return []
return alist[-1:] + rev(alist[:-1])
print(rev(L))
```
%% Cell type:markdown id: tags:
Le slicing peut être utilisé pour **modifier** une séquence **muable** grâce à l'opération d'assignation.
%% Cell type:code id: tags:
``` python
```
L = 'Dans le Python tout est bon'.split()
print(L)
L[2:4] = ['nouvelles', 'valeurs', 'et encore plus...', 1, 2, 3]
print(L)
```
%% Cell type:markdown id: tags:
Le slicing peut être utilisé sur des chaînes de caractères.
%% Cell type:code id: tags:
``` python
```
alphabet = 'abcdefghijklmnopqrstuvwxyz'
```
%% Cell type:markdown id: tags:
> **Exercice** :
> 1. Découpez l'alphabet en deux parties égales
> 2. Prenez une lettre sur deux
%% Cell type:code id: tags:
``` python
```
# Votre code ici
```
%% Cell type:code id: tags:
``` python
```
# Solution
alphabet = "abcdefghijklmnopqrstuvwxyz"
# 1.
milieu = len(alphabet) // 2
print(alphabet[:milieu])
print(alphabet[milieu:])
# 2.
print(alphabet[::2])
```
%% Cell type:markdown id: tags:
## Chaînes de caractères, le retour
Les chaînes de caractères sont des séquences **immuables** donc on les manipule comme telles.
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
immuable = 'abcdefgh'
immuable[3] = 'D'
```
%% Cell type:markdown id: tags:
Il faut construire une nouvelle chaîne de caractère. En concaténant des morceaux (slices) de la chaîne originale:
%% Cell type:code id: tags:
``` python
```
nouvelle_chaine = immuable[:3] + 'D' + immuable[4:]
print(nouvelle_chaine)
```
%% Cell type:markdown id: tags:
Ou alors en utilisant une transformation en liste, puis à nouveau en chaîne:
%% Cell type:code id: tags:
``` python
```
a = list(immuable)
print(a)
a[3] = 'D'
print(a)
print(''.join(a))
```
%% Cell type:markdown id: tags:
On peut savoir si une chaîne se trouve dans une autre
%% Cell type:code id: tags:
``` python
```
print('123' in 'azerty_123_uiop')
print('AZE' in 'azerty_123_uiop')
print('aze' in 'azerty_123_uiop')
```
%% Cell type:markdown id: tags:
La longueur d'une chaîne s'obtient avec [``len()``](https://docs.python.org/3/library/functions.html#len).
%% Cell type:code id: tags:
``` python
```
print(len(immuable))
```
%% Cell type:markdown id: tags:
> **Exercice**, dans la cellule ci-dessous:
> 1. **Insérez** le caractère `#` au milieu de la chaîne donnée.
> 2. Idem mais **coupez** la chaine en 3 parties, et insérez le caractère `@` entre chacune d'elles.
> 3. **Insérez** le caractère `|` entre chaque caractère de la chaîne.
%% Cell type:code id: tags:
``` python
```
chaine_donnee = 'azertyuioppoiuytreza'
# Votre code ici
```
%% Cell type:code id: tags:
``` python
```
# Solution
chaine_donnee = "azertyuioppoiuytreza"
milieu = len(chaine_donnee) // 2
print(chaine_donnee[:milieu] + '#' + chaine_donnee[milieu:])
intervale = len(chaine_donnee) // 3
print(chaine_donnee[:intervale] + '@' + chaine_donnee[intervale:2 * intervale + 1] + '@' + chaine_donnee[2 * intervale + 1:])
print('|'.join(chaine_donnee))
```
%% Cell type:markdown id: tags:
## Les dictionnaires
Les dictionnaires ou listes associatives sont des conteneurs où les objets ne sont **pas** ordonnés ni accessibles par un indice mais sont associés à une clé d'accès.
L'accès aux éléments se fait comme pour les listes ou tuples, avec les `[]`.
```python
dico = {cle1: valeur1, cle2: valeur2, ...}
```
Les clés peuvent avoir n'importe qu'elle valeur à condition qu'elles soient de type immuable : les listes ne peuvent pas servir de clés alors que les chaînes de caractères et les tuples le peuvent.
Dans `dico`, on accède à `valeur1` avec la syntaxe `dico[cle1]`.
%% Cell type:markdown id: tags:
### Un exemple
%% Cell type:code id: tags:
``` python
```
dic_animaux = {'ane': True, 'arbre': False, 'chat': True, 'lune': False, 'humain': True}
cle = 'chat'
valeur = dic_animaux[cle]
print(valeur)
print('{} est un animal: {}'.format(cle, valeur))
# Ou encore
print('{} est un animal: {}'.format('chat', dic_animaux['chat']))
# En utilisant les f-strings :
print(f"{'chat'} est un animal: {dic_animaux['chat']}")
```
%% Cell type:markdown id: tags:
> **Exercice** : essayez de savoir si un arbre est un animal
%% Cell type:code id: tags:
``` python
```
# Votre code ici
```
%% Cell type:code id: tags:
``` python
```
# Solution
print("l'arbre est un animal:", dic_animaux['arbre'])
```
%% Cell type:markdown id: tags:
Les différentes manières de créer des dictionnaires, en particulier grâce à la fonction interne [`dict()`](https://docs.python.org/3/library/functions.html#func-dict) :
%% Cell type:code id: tags:
``` python
```
a = {'un': 1, 'deux': 2, 'trois': 3} # Les accolades comme syntaxe
b = dict(un=1, deux=2, trois=3) # La méthode dict()
c = dict(zip(['un', 'deux', 'trois'], [1, 2, 3])) # On "zippe" deux listes
d = dict([('deux', 2), ('un', 1), ('trois', 3)]) # On transforme une liste de 2-tuples
e = dict({'trois': 3, 'un': 1, 'deux': 2})
a == b == c == d == e
```
%% Cell type:markdown id: tags:
Accéder à un élément qui n'est pas dans le dictionnaire génère une erreur. Il existe la méthode [`{}.get()`](https://docs.python.org/3/library/stdtypes.html#dict.get) ou [l'opérateur `in`](https://docs.python.org/3/library/stdtypes.html#mapping-types-dict) qui permettent d'éviter ce problème.
%% Cell type:code id: tags:
``` python
```
# Cette cellule génère une erreur
err = a['quatre']
```
%% Cell type:markdown id: tags:
Ici on utilise ``.get()`` et cela ne remonte pas d'erreur.
%% Cell type:code id: tags:
``` python
```
print(a.get('quatre')) # La valeur par défaut est 'None' lorsque .get() ne trouve pas l'élément
print(a.get('quatre', 5)) # On peut spécifier une autre valeur par défaut
```
%% Cell type:markdown id: tags:
### Un autre exemple
%% Cell type:code id: tags:
``` python
```
tup_mois = ('jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec')
tup_long = (31, (28, 29), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
dic_mois = dict(zip(tup_mois, tup_long))
mois_naissance = 'jun'
mois_naissance = 'feb'
print('Il y a {:d} jours dans votre mois de naissance'.format(dic_mois[mois_naissance]))
```
%% Cell type:markdown id: tags:
> **Exercice**:
>
> 1. Modifiez la cellule précédente pour y changer mois_naissance (les 3 premiers caractères de votre mois de naissance, en anglais). Ré-exécutez la cellule et vérifiez la réponse.
> 2. Un problème s'est glissé dans la cellule, lequel ?
> 3. Corrigez-le (il y a plusieurs manières de faire).
%% Cell type:markdown id: tags:
Les dictionnaires sont muables.
%% Cell type:code id: tags:
``` python
```
ages = {'albert': 62, 'bob': 34, 'charlie': 1, 'daphne': 67}
print(ages)
# C'est l'anniversaire de charlie, il a un an de plus...
ages['charlie'] += 1 # equivalent à : ages['charlie'] = ages['charlie'] + 1
print(ages)
print('Albert a {} ans.'.format(ages['albert']))
# Bob est parti, enlevons-le
del(ages['bob'])
print(ages)
```
%% Cell type:markdown id: tags:
- Savoir si une clé est présente dans un dictionnaire est une opération rapide. On utilise, comme pour les séquences, l'opérateur `in`.
- La fonction interne `len()` est utilisable pour savoir combien d'objets sont référencés dans le dictionnaire.
%% Cell type:code id: tags:
``` python
```
ages = {'albert': 62, 'bob': 34, 'charlie': 1, 'daphne': 67}
print('Charlie est dedans ?', 'charlie' in ages)
print('Zoé est dedans ?', 'zoé' in ages)
print('Bob est dedans ?', 'bob' in ages)
print('Il y a {:d} personnes.'.format(len(ages)))
# Bob est parti, enlevons-le
del(ages['bob'])
print('Bob est dedans ?', 'bob' in ages)
print('Il y a {:d} personnes.'.format(len(ages)))
```
%% Cell type:markdown id: tags:
On peut itérer sur les clés ou les objets référencés, ou vider un dictionnaire, en comparer deux, etc.
Pour plus d'informations sur les dictionnaires, voir [ici](https://docs.python.org/3/library/stdtypes.html#mapping-types-dict).
%% Cell type:markdown id: tags:
> **Exercice** :
>
> 1. Créez un dictionnaire qui va traduire des chiffres (de 0 à 3) écrits en toutes lettres entre deux langues.
> 1. Créez un dictionnaire qui va traduire des chiffres (de 1 à 3) écrits en toutes lettres entre deux langues.
> Par exemple :
> `trad_num['un']` $\rightarrow$ `'one'`
> 2. Modifiez ce dictionnaire, pour qu'il fonctionne dans les deux sens de traduction (Fr $\rightarrow$ En et En $\rightarrow$ Fr)
> 3. Modifiez ce dictionnaire, pour qu'il fonctionne aussi avec les chiffres sous forme d'entiers.
> Par exemple :
> `trad_num[1]` $\rightarrow$ `'un'`
%% Cell type:code id: tags:
``` python
```
# Votre code ici
```
%% Cell type:code id: tags:
``` python
```
# -- une première solution --
# Des tuples
fr = 'un', 'deux', 'trois'
en = 'one', 'two', 'three'
num = 1, 2, 3
# Des dictionnaires
trad_fr_en = dict(zip(fr, en))
trad_en_fr = dict(zip(en, fr))
trad___num = dict(zip(num, fr))
# Le dico qui fait rien
trad = {}
# Maintenant il peut tout faire
trad.update(trad_fr_en)
trad.update(trad_en_fr)
trad.update(trad___num)
# La preuve
print("'un' \t devient:", trad['un'])
print("'two' \t devient:", trad['two'])
print("3 \t devient:", trad[3])
print('trad:', trad)
# -- une solution concise --
trad_num = {'un': 'one', 'deux': 'two', 'trois': 'three'}
print(trad_num['deux']) # On teste Fr -> En
trad_num.update({valeur: cle for cle, valeur in trad_num.items()})
print(trad_num)
```
%% Cell type:markdown id: tags:
## Les ensembles
La fonction [`set()`](https://docs.python.org/3/library/functions.html#func-set) permet de créer des ensembles.
Les ensembles sont des conteneurs qui n'autorisent pas de duplication d'objets référencés, contrairement aux listes et tuples.
On peut créer des ensembles de cette façon :
```python
ensemble = set(iterable)
```
`iterable` peut être n'importe quel objet qui supporte l'itération : liste, tuple, dictionnaire, un autre set (pour en faire une copie), vos propres objets itérables, etc...
Tout comme pour les dictionnaires, l'opérateur `in` est efficace.
%% Cell type:markdown id: tags:
### Exemples
%% Cell type:code id: tags:
``` python
```
list1 = [1, 1, 2]
tupl1 = ('un', 'un', 'deux', 1, 3)
b = set(list1)
a = set(tupl1)
b = set(list1)
print(a, b)
print("La chaîne 'un' est elle dans l'ensemble ?", 'un' in a)
a.remove('un')
print("La chaîne 'un' est-elle toujours dans l'ensemble ?", 'un' in a)
print(a, b)
```
%% Cell type:markdown id: tags:
Des opérations supplémentaires sont possibles sur des ensembles. Elles sont calquées sur les opérations mathématiques :
- union
- intersection
- etc...
%% Cell type:code id: tags:
``` python
```
print('intersection :', a & b)
print('union :', a | b)
```
%% Cell type:markdown id: tags:
Pour plus d'informations sur les ensembles, voir [ici](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset)
%% Cell type:markdown id: tags:
## Fichiers
### Ouverture
L'instruction :
```python
f = open('interessant.txt', mode='r')
```
ouvre le fichier `interessant.txt` en mode lecture seule et le renvoie dans l'objet `f`.
- On peut spécifier un chemin d'accès complet ou relatif au répertoire courant
- Le caractère de séparation pour les répertoires peut être différent en fonction du système d'exploitation (`/` pour unix et `\` pour windows), voir le module [`os.path`](https://docs.python.org/3/library/os.path.html) ou mieux la bibliothèque [`pathlib`](https://docs.python.org/3/library/pathlib.html).
%% Cell type:markdown id: tags:
#### Modes d'ouverture communs
- `'r'` : lecture seule
- `'w'` : écriture seule
- `'a'` : ajout à partir de la fin du fichier
**Note :** Avec `'w'` et `'a'`, le fichier est créé s'il n'existe pas.
Pour plus d'informations sur les objets fichiers, voir [ici](https://docs.python.org/3/library/stdtypes.html#file-objects), pour la documentation de la fonction `open()`, voir [là](https://docs.python.org/3/library/functions.html#open).
%% Cell type:markdown id: tags:
### Fermeture
On ferme le fichier ``f`` avec l'instruction :
f.close()
%% Cell type:markdown id: tags:
### Méthodes de lecture
- ``f.read()`` : retourne tout le contenu de ``f`` sous la forme d’une chaîne de caractères.
%% Cell type:code id: tags:
``` python
```
f = open('exos/interessant.txt', mode='r')
texte = f.read()
f.close()
print('"texte" est un objet de type', type(texte), 'de longueur', len(texte), 'caractères:')
print(texte)
print('Contenu en raw string:')
print(repr(texte))
%pycat exos/interessant.txt
```
%% Cell type:markdown id: tags:
- ``f.readlines()`` : retourne toutes les lignes de ``f`` sous la forme d’une liste de chaînes de caractères.
%% Cell type:code id: tags:
``` python
```
f = open('exos/interessant.txt', mode='r')
lignes = f.readlines()
f.close()
print('"lignes" est un objet de type', type(lignes), 'contenant', len(lignes), 'éléments:')
print(lignes)
```
%% Cell type:markdown id: tags:
### Méthodes d'écriture
- ``f.write('du texte')`` : écrit la chaine ``'du texte'`` dans ``f``
%% Cell type:code id: tags:
``` python
```
chaine = 'Je sais écrire\n...\navec Python !\n'
# mode 'w' : on écrase le contenu du fichier s'il existe
# encoding UTF-8: on peut écrire des chaînes avec des caractères non ASCII
f = open('pas_mal.txt', mode='w')
f.write(chaine)
f.close()
%pycat pas_mal.txt
```
%% Cell type:markdown id: tags:
**Note :** du point de vue du système, rien n'est écrit dans le fichier avant l’appel de ``f.close()``
%% Cell type:markdown id: tags:
- ``f.writelines(ma_sequence)`` : écrit la séquence ``ma_sequence`` dans ``f`` en mettant bout à bout les éléments
%% Cell type:code id: tags:
``` python
```
sequence = ['Je sais ajouter\n', 'du texte\n', 'avec Python !\n']
f = open('pas_mal.txt', mode='a')
# mode 'a' : on ajoute à la fin du fichier
# encoding par défaut: uniquement des caractères ASCII
f.writelines(sequence)
f.close()
%pycat pas_mal.txt
```
%% Cell type:markdown id: tags:
> **Exercice :**
>
> 1. écrire le contenu de la liste ``mystere`` dans le fichier ``coded.txt`` puis fermer ce dernier
> 2. lire le fichier ``coded.txt`` et le stocker dans une chaine ``coded``
> 3. Décoder la chaîne ``coded`` avec les instructions suivantes:
>
>```python
>import codecs
>decoded = codecs.decode(coded, encoding='rot13')
>```
>
> 4. écrire la chaine ``decoded`` dans le fichier ``decoded.txt`` et fermer ce dernier
> 5. visualiser le contenu du fichier ``decoded.txt`` dans un éditeur de texte
%% Cell type:code id: tags:
``` python
```
mystere = ['Gur Mra bs Clguba, ol Gvz Crgref\n\n',
'Ornhgvshy vf orggre guna htyl.\n',
'Rkcyvpvg vf orggre guna vzcyvpvg.\n']
# Votre code ci-dessous
```
%% Cell type:code id: tags:
``` python
```
# Solution
mystere = ["Gur Mra bs Clguba, ol Gvz Crgref\n\n",
"Ornhgvshy vf orggre guna htyl.\n",
"Rkcyvpvg vf orggre guna vzcyvpvg.\n"]
# 1. On écrit ces chaînes de caractères dans le fichier "coded.txt"
f = open('coded.txt', mode='w')
f.writelines(mystere)
f.close()
# 2. On relit le contenu du fichier "coded.txt" que l'on vient de créer
f = open('coded.txt', mode='r')
coded = f.read()
f.close()
# 3. On décode le message mystérieux
# Cette ligne permet l'utilisation de codecs.decode(), c.f. ligne 21
import codecs
decoded = codecs.decode(coded, encoding='rot13')
# 4. On écrit le message décodé dans un autre fichier
f = open('decoded.txt', mode='w')
f.write(decoded)
f.close()
# 5. On consulte le contenu du message décodé dans le fichier "decoded.txt"
%pycat decoded.txt
```
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.