Skip to content
Commits on Source (4)
Hide whitespace changes
Inline Side-by-side
notebooks/Python-1/01-Introduction-Python-Nombres.ipynb
View file @ cff260a5
%% Cell type:markdown id: tags:
# 1. Introduction à Python
## 1.0 Les «notebooks»
La page que vous consultez est un «notebook» (cahier). C’est un outil permettant de réunir des notes et du code. Il est très utilisé en science des données.
On écrit le code dans des «cells» (cellules). Pour faire fonctionner le code, on choisit une cellule et on clique sur le bouton **▶**.
Le texte est formaté en [«markdown»](https://fr.wikipedia.org/wiki/Markdown), un langage de balisage (un peu comme le wikicode, pour les connaisseurs). On utilise des astérisques pour mettre des mots en gras, comme sur Slack ou WhatsApp: `**un texte en gras**` devient **un texte en gras**.
## 1.1 Les nombres
%% Cell type:markdown id: tags:
En Python, on peut faire des calculs comme sur une calculette:
%% Cell type:code id: tags:
``` python
2 + 2
```
%% Output
4
%% Cell type:code id: tags:
``` python
30 / 100
```
%% Output
0.3
%% Cell type:markdown id: tags:
Pour les nombres à virgule, on doit utiliser des points (notation anglaise). Si on met une virgule, Python croit qu’on lui donne deux nombres différents:
%% Cell type:code id: tags:
``` python
# Correct
5.2
```
%% Output
5.2
%% Cell type:code id: tags:
``` python
# Python n’a pas compris
5,2
```
%% Output
(5, 2)
%% Cell type:markdown id: tags:
Désormais, on utilisera beaucoup l’instruction `print()`, une fonction qui sert à afficher des résultats. On en reparlera, pour le moment essayez simplement:
%% Cell type:code id: tags:
``` python
print(2 + 2)
```
%% Output
4
%% Cell type:markdown id: tags:
`print()` vous permet d’afficher autant de lignes que vous le souhaitez. Voici un rappel des opérations mathématiques que vous avez essayées dans «Les bases de Python»:
%% Cell type:code id: tags:
``` python
print(5 + 4)
print(5 - 4)
print(5 * 4)
print(5 / 4)
```
%% Output
9
1
20
1.25
%% Cell type:markdown id: tags:
On avait aussi vu ces deux opérateurs:
%% Cell type:code id: tags:
``` python
print(5 ** 2) # exposant
print(10 % 3) # modulo (reste)
```
%% Output
25
1
%% Cell type:markdown id: tags:
Le module Python «math» permet de faire des opérations plus complexes, comme la racine carrée. Un «module» est un ensemble d’instructions qu’on peut importer dans un projet. Il en existe des centaines. Certains servent à faire des statistiques, d’autres à dessiner des graphiques, à analyser du texte, à faire de la reconnaissance faciale, etc.
%% Cell type:code id: tags:
``` python
import math
```
%% Cell type:code id: tags:
``` python
# Racine de 10
# (Si on commence une ligne par un "#", cette ligne est un «commentaire»:
# elle n’est pas exécutée)
math.sqrt(10)
```
%% Output
3.1622776601683795
%% Cell type:markdown id: tags:
# Exercice
* Combien font 3588 divisé par 11,3?
* Quelle est la racine carrée de 345?
%% Cell type:code id: tags:
``` python
3588 / 11.3
```
%% Output
317.5221238938053
%% Cell type:code id: tags:
``` python
math.sqrt(345)
```
%% Output
18.57417562100671
%% Cell type:code id: tags:
``` python
```
......
notebooks/Python-1/02-Introduction-Python-Variables.ipynb
View file @ cff260a5
%% Cell type:markdown id: tags:
# 1. Introduction à Python
## 1.2 Les variables
%% Cell type:markdown id: tags:
<strong>Les variables</strong> sont un concept important dans la programmation.
<br>Vous pouvez vous représenter une variable comme une sorte de conteneur, dans lequel on peut mettre par exemple un nombre pour le réutiliser plus tard. (Vous vous rappelez de la touche M+ sur les calculettes?)<br>
En Python, on peut donner une valeur à une variable en écrivant:
`NomVariable = 5`
Les noms de variable doivent respecter certaines conditions: ils ne doivent pas commencer par un chiffre et ne doivent pas être un mot «réservé», c’est-à-dire déjà utilisé pour autre chose. Par exemple, une variable ne peut pas porter le nom «`if`» (si…) qu’on utilise pour écrire: «si telle condition est remplie».
Voici un exemple de variable:
%% Cell type:code id: tags:
``` python
pageNumber = 5
```
%% Cell type:markdown id: tags:
Une variable peut contenir le résultat d’un calcul:
%% Cell type:code id: tags:
``` python
result = 5 + 6
```
%% Cell type:markdown id: tags:
On peut utiliser cette valeur plus loin dans le programme, par exemple pour l’afficher:
%% Cell type:code id: tags:
``` python
print(result)
```
%% Output
11
%% Cell type:markdown id: tags:
On peut aussi faire des calculs avec une variable:
%% Cell type:code id: tags:
``` python
print(result * result)
```
%% Output
121
%% Cell type:code id: tags:
``` python
# Calculer une moyenne
age = 21
age2 = 18
print((age + age2) / 2)
```
%% Output
19.5
%% Cell type:code id: tags:
``` python
# On peut également sauvegarder le résultat dans une variable avant de l’afficher
average_age = (age + age2) / 2
```
%% Cell type:code id: tags:
``` python
print(average_age)
```
%% Output
19.5
%% Cell type:markdown id: tags:
## Exercice
Résolvez le problème suivant avec des variables:
* Un nombre indéterminé de personnes se trouve dans un train.
* Au premier arrêt, **19** personnes descendent
* **17** personnes montent
* On a désormais **63** personnes dans le train
* Combien de personnes étaient dans le train au départ?
[Tiré d’un exemple de Watson!](https://www.watson.ch/wissen/populärkultur/943887508-matheaufgabe-fuer-7-jaehrige-bringt-alle-zum-verzweifeln-kannst-du-sie-loesen-)
%% Cell type:code id: tags:
``` python
nombre_final = 63
nombre_final - 17 + 19
```
%% Cell type:markdown id: tags:
%% Output
65
%% Cell type:code id: tags:
``` python
# Ou, plus détaillé:
descendent = 19
montent = 17
nombre_final = 63
nombre_depart = nombre_final - montent + descendent
print(nombre_depart)
```
%% Output
65
%% Cell type:markdown id: tags:
### Pour aller plus loin
Si chaque développeur a une manière différente de nommer ses variables, ça devient vite incompréhensible. Pour éviter ce problème, on fixe en général des règles, les «conventions de nommage» (naming conventions).
En principe, chaque nom variable doit être explicite. Par exemple, on évite d’écrire `a = b*c` si les variables correspondent à `salaire_mensuel = heures_travaillees * salaire_horaire`.
On se retrouve avec des variables composées de deux ou trois mots. Et on ne peut pas les séparer par un espace. Du coup, certains développeurs écriront salaire_mensuel, d’autres salaireMensuel, ou encore SalaireMensuel!
En Python, il existe un ensemble de recommandations sur la manière d’écrire son code, appelé [PEP 8](https://www.python.org/dev/peps/pep-0008/). Ce guide conseille de [séparer les mots par des underscores](https://www.python.org/dev/peps/pep-0008/#method-names-and-instance-variables), comme `salaire_mensuel`.
%% Cell type:code id: tags:
``` python
```
......
notebooks/Python-1/03-Introduction-Python-Strings.ipynb
View file @ cff260a5
%% Cell type:markdown id: tags:
# Chaînes de caractères (*Strings*)
Python peut travailler avec des chaînes de caractères, qu’on appelle en anglais **strings**.
Vous pouvez employer n’importe quelle séquence de caractères entre guillemets simples ou guillemets doubles. Mais on doit commencer et terminer avec le même type de guillemets.
` "Hello" ` est une chaîne de caractères, ` "Hello World" ` aussi, ou encore ` "123.2" ` et ` '!Attention!' `
%% Cell type:markdown id: tags:
On peut afficher une chaîne de caractères avec `print()`:
%% Cell type:code id: tags:
``` python
print("Bonjour")
```
%% Output
Bonjour
%% Cell type:markdown id: tags:
... Et on peut les enregistrer dans une variable:
%% Cell type:code id: tags:
``` python
name = "Roger"
```
%% Cell type:code id: tags:
``` python
print(name)
```
%% Output
Roger
%% Cell type:markdown id: tags:
### Additionner des chaînes de caractères
Vous vous rappelez de ce qui se passe?
%% Cell type:code id: tags:
``` python
print("Salut" + "Roger")
```
%% Output
SalutRoger
%% Cell type:code id: tags:
``` python
print("Salut " + name)
```
%% Output
Salut Roger
%% Cell type:markdown id: tags:
## Exercice
%% Cell type:markdown id: tags:
Essayez d’additionner une chaîne de caractères et un nombre. Vous vous rappelez de la solution?
%% Cell type:code id: tags:
``` python
# votre code ici
```
%% Cell type:code id: tags:
``` python
```
%% Cell type:code id: tags:
``` python
```
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
### Transformer un nombre en chaîne de caractères
On a donc deux possibilités pour transformer un chiffre en chaîne de caractères.
1.) On peut l’écrire entre guillemets:
%% Cell type:code id: tags:
``` python
print("Roger a " + "40" + " ans")
```
%% Output
Roger a 40 ans
%% Cell type:markdown id: tags:
Si le nombre est déjà stocké dans une variable, on ne peut pas utiliser les guillemets. Mais il y a cette autre solution:
2.) Utiliser l’instruction `str()`
%% Cell type:code id: tags:
``` python
age = 42
print("Roger a " + str(age) + " ans")
```
%% Output
Roger a 42 ans
%% Cell type:markdown id: tags:
**Attention au fait qu’on ne peut pas faire de calculs avec `"40"` ou `str(40)`.**
%% Cell type:markdown id: tags:
## Exercice
* Regardez le nombre d’habitants en Suisse au 31 décembre de l’année dernière [sur cette page de l’OFS](https://www.bfs.admin.ch/bfs/fr/home/statistiques/population/effectif-evolution.assetdetail.23104093.html)
* Enregistrez ce nombre dans la variable `pop_2021`.
* Enregistrez le nombre d’habitants au 31 décembre 2001 dans la variable `pop_2001`.
* Enregistrez l’augmentation du nombre d’habitants en pourcent dans `increase`.
* Affichez la phrase suivante avec `print()`: "La Suisse compte *pop_2021* millions d’habitants. Il y a vingt ans, elle en comptait *pop_2001*. Cela représente une augmentation de *increase*%."
#### Rappel: calcul du pourcentage d’augmentation:
```
Augmentation = Nouvelle valeur - Ancienne valeur
Pourcentage d’augmentation = 100 x Augmentation / Ancienne valeur
```
Exemple:
```
Ancien prix: 1000.-
Nouveau prix: 1200.-
Augmentation: 200.-
Pourcentage d’augmentation: 100 x 200 / 1000 = 20%
```
%% Cell type:code id: tags:
``` python
pop_2021 = 8.74
pop_2001 = 7.26
increase = 100 * (pop_2021 - pop_2001) / pop_2001
print(
f"""La Suisse compte {pop_2021} millions d’habitants.
Il y a vingt ans, elle en comptait {pop_2001}.
Cela représente une augmentation de {round(increase, 1)}%."""
)
```
%% Output
La Suisse compte 8.74 millions d’habitants.
Il y a vingt ans, elle en comptait 7.26.
Cela représente une augmentation de 20.4%.
%% Cell type:code id: tags:
``` python
```
%% Cell type:code id: tags:
``` python
```
......
notebooks/Python-1/04-Introduction-Python-Listes.ipynb
View file @ cff260a5
%% Cell type:markdown id: tags:
# Listes
Jusqu’ici, nous n’avons enregistré qu’un élément dans nos variables (un nombre ou une chaîne de caractères).
%% Cell type:code id: tags:
``` python
student1 = "Monique"
student2 = "Régis"
student3 = "Éric"
student4 = "Eudes"
```
%% Cell type:markdown id: tags:
### Créer une liste
**Les listes** peuvent contenir plusieurs éléments. On crée une liste comme suit:
**NomListe = [Element1, Element2, Element3]**
C’est un exemple, mais une liste peut contenir autant d’éléments qu’on veut.
Essayez:
%% Cell type:code id: tags:
``` python
students = ["Marie", "Frédérique", "Kevin", "Roger"]
```
%% Cell type:code id: tags:
``` python
notes = [4, 3, 2, 1]
```
%% Cell type:markdown id: tags:
Les listes peuvent aussi être affichées avec `print()`.
%% Cell type:code id: tags:
``` python
print(students)
```
%% Output
['Marie', 'Frédérique', 'Kevin', 'Roger']
%% Cell type:markdown id: tags:
Une liste peut contenir des éléments de différents types, comme des chiffres et des chaînes de caractères. Mais c’est déconseillé! On apprendra bientôt des structures faites pour ce genre de cas.
%% Cell type:markdown id: tags:
### Choisir un élément dans une liste
Vous pouvez accéder à un élément précis dans une liste. Chaque élément de la liste porte un numéro, en commençant par zéro. On appelle cela l’**index**. Voici comment ça s’utilise concrètement:
%% Cell type:code id: tags:
``` python
print(students[0])
```
%% Output
Marie
%% Cell type:code id: tags:
``` python
print(students[1])
```
%% Output
Frédérique
%% Cell type:code id: tags:
``` python
print(students[2])
```
%% Output
Kevin
%% Cell type:code id: tags:
``` python
print(students[3])
```
%% Output
Roger
%% Cell type:markdown id: tags:
<hr>
Qu’est-ce qui se passe si on demande l’élément -1?
%% Cell type:code id: tags:
``` python
# A compléter
```
%% Cell type:markdown id: tags:
On peut manipuler les éléments d’une liste comme on le fait avec des variables. Les règles en matière de types sont les mêmes: il faut tenir compte du fait que ce soient des entiers, des chaînes de caractères, ou d’autres types de données que nous allons bientôt découvrir.
%% Cell type:code id: tags:
``` python
print(students[0] + " et " + students[3])
```
%% Output
Marie et Roger
%% Cell type:code id: tags:
``` python
# Calculer la moyenne des notes
print((notes[0] + notes[1] + notes[2] + notes[3]) / 4)
```
%% Output
2.5
%% Cell type:markdown id: tags:
### Ajouter un élément à une liste
L’instruction `append` permet d’ajouter un élément à une liste. A la différence de `print`, cette instruction se met derrière la variable qu’on souhaite modifier, et on les relie par un point. Comme suit:
`NomListe.append(NouvelElément)`
%% Cell type:code id: tags:
``` python
students.append("Elisabeth")
```
%% Cell type:markdown id: tags:
Regardons si l’instruction a fonctionné!
%% Cell type:code id: tags:
``` python
print(students)
```
%% Output
['Marie', 'Frédérique', 'Kevin', 'Roger', 'Elisabeth']
%% Cell type:markdown id: tags:
### Enlever un élément
Exactement comme on peut ajouter un élément, on peut enlever le dernier élément de la liste avec `pop()`:
**NomListe.pop()**
%% Cell type:code id: tags:
``` python
students.pop()
print(students)
```
%% Output
['Marie', 'Frédérique', 'Kevin', 'Roger']
%% Cell type:markdown id: tags:
`pop()` renvoie un résultat. Et ce résultat, c’est l’élément qui a été enlevé. Voici ce que ça donne quand on donne la valeur de `pop()` à une variable:
%% Cell type:code id: tags:
``` python
print("La liste avant pop():", students)
removed = students.pop()
print("On a enlevé l’élément", removed)
print("La liste, désormais:", students)
```
%% Output
La liste avant pop(): ['Marie', 'Frédérique', 'Kevin', 'Roger']
On a enlevé l’élément Roger
La liste, désormais: ['Marie', 'Frédérique', 'Kevin']
%% Cell type:markdown id: tags:
Vous avez remarqué? J’ai utilisé `print()` avec des virgules. Dans ce cas, on n’a plus besoin de se préoccuper de convertir les types de variables, et Python ajoute automatiquement des espaces! Mais la fonction `str()` reste utile dans de nombreux cas.
%% Cell type:markdown id: tags:
### Demander la longueur d’une liste
L’instruction `len()` renvoie la valeur d’une liste. Elle s’utilise comme suit:
`len(NomListe)`
%% Cell type:code id: tags:
``` python
print(len(students))
```
%% Output
3
%% Cell type:markdown id: tags:
## Exercice
- Enregistrez le nom de 3-4 participants du cours, en commençant par vous-mêmes.
- Ajoutez l’un des instructeurs.
- Ajoutez votre âge, ou un nombre au hasard.
- Maintenant, retirez ce nombre.
- Affichez la liste.
%% Cell type:code id: tags:
``` python
students = ["Marie", "Frédérique", "Kevin", "Roger"]
students.append("Fanny")
students.append(49)
students.pop()
print(students)
```
%% Output
['Marie', 'Frédérique', 'Kevin', 'Roger', 'Fanny']
......
notebooks/Python-1/05-Introduction-Python-Donnees.ipynb
View file @ cff260a5
%% Cell type:markdown id: tags:
# Convertir des données - chaînes de caractères et nombres
La conversion de données est probablement ce que vous ferez le plus. Il sera pratique de les apprendre dès maintenant.
%% Cell type:markdown id: tags:
### Transformer un «string» en nombre entier
La commande `int()` transforme une valeur (nombre décimal ou chaîne de caractères) en nombre entier. Elle renvoie une erreur si la conversion est impossible.
%% Cell type:code id: tags:
``` python
a = "5"
b = "6"
print(int(a) + int(b))
```
%% Output
11
%% Cell type:code id: tags:
``` python
int("Roger")
```
%% Output
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
/var/folders/3m/31wc9z155djdbz0tpyg168lh0000gp/T/ipykernel_88365/913713571.py in <cell line: 1>()
----> 1 int("Roger")
ValueError: invalid literal for int() with base 10: 'Roger'
%% Cell type:markdown id: tags:
Les nombres décimaux sont ramenés à l’entier inférieur. Pour arrondir à l’entier le plus proche, on utilise l’instruction `round`.
%% Cell type:code id: tags:
``` python
int(3.7)
```
%% Output
3
%% Cell type:code id: tags:
``` python
round(3.7)
```
%% Output
4
%% Cell type:markdown id: tags:
### Transformer une chaîne de caractères en nombre décimal
En anglais, un nombre à virgule flottante est appelé floating-point number. En programmation, pour faire plus court, c’est un **float**. Et voici l’équivalent de int() pour ce type de nombres:
`float()`
%% Cell type:code id: tags:
``` python
a = "5.5"
b = "6.6"
print(float(a) + float(b))
```
%% Output
12.1
%% Cell type:markdown id: tags:
### Transformer un nombre en chaîne de caractères
En anglais, la chaîne de caractères est un **character string**. En Python, ce type de données est abrégé en `str`.
%% Cell type:code id: tags:
``` python
age = 77
print("J’ai " + str(age) + " ans")
```
%% Output
J’ai 77 ans
%% Cell type:markdown id: tags:
## Exercice
- Enregistrez le nombre Pi, avec 4 décimales, dans une variable.
- Multipliez-le par 2.
- Transformez-le en chaîne de caractères et affichez: "Le double de Pi vaut (valeur)"
%% Cell type:markdown id: tags:
# Convertir des données – listes et chaînes de caractères
On peut transformer les éléments d’une liste en une seule chaîne de caractères.
%% Cell type:markdown id: tags:
### «Joindre» des éléments d’une liste
L’instruction **join()**, appliquée à une chaîne de caractères, lie les éléments d’une liste par ces caractères:
`string.join(liste)`
%% Cell type:code id: tags:
``` python
students = ["Max", "Jeanne", "Hervé", "Franziska"]
print(", ".join(students))
```
%% Output
Max, Jeanne, Hervé, Franziska
%% Cell type:code id: tags:
``` python
# Pour rendre l’opération un peu plus claire…
print(" // ainsi que… // ".join(students))
```
%% Output
Max // ainsi que… // Jeanne // ainsi que… // Hervé // ainsi que… // Franziska
%% Cell type:code id: tags:
``` python
students_as_string = ", ".join(students)
print("Les étudiants suivants étudient chez nous: " + students_as_string)
```
%% Output
Les étudiants suivants étudient chez nous: Max, Jeanne, Hervé, Franziska
%% Cell type:code id: tags:
``` python
students = ["Max", "Monika", "Erik", "Franziska"]
print(" - ".join(students))
```
%% Output
Max - Monika - Erik - Franziska
%% Cell type:markdown id: tags:
### Diviser une chaîne de caractère en une liste
C’est maintenant qu’on commence à s’amuser. Si vous devez parfois préparer des listes de centaines de noms pour un journal, une brochure, etc. cette commande peut vous gagner des heures.
L’instruction **split()** – en anglais couper, diviser – coupera votre *string* sur la base des caractères que vous demandez. Exemple:
`string.split(", ")`
%% Cell type:code id: tags:
``` python
newStudents = "Rodolphe, Michelle, Erika, Jacques"
```
%% Cell type:code id: tags:
``` python
# Par défaut, Python utilise l’espace
print(newStudents.split())
```
%% Output
['Rodolphe,', 'Michelle,', 'Erika,', 'Jacques']
%% Cell type:markdown id: tags:
Mais on peut être plus précis:
%% Cell type:code id: tags:
``` python
print(newStudents.split(", "))
```
%% Output
['Rodolphe', 'Michelle', 'Erika', 'Jacques']
%% Cell type:code id: tags:
``` python
print(newStudents.split("e"))
```
%% Output
['Rodolph', ', Mich', 'll', ', Erika, Jacqu', 's']
%% Cell type:markdown id: tags:
On peut combiner les différentes instructions qu’on a apprises.
%% Cell type:code id: tags:
``` python
# Comptons le nombre de mots de cette phrase
sentence = "Je suis une phrase qui contient des mots"
print(len(sentence.split()))
```
%% Output
8
%% Cell type:markdown id: tags:
## Exercice 1
- Choisissez un article de 20 minutes
- Collez-le dans un "string"
- Découpez l’article en mots
- Comptez les mots et enregistrez-le dans une variable
- Affichez «L’article compte x mots» en utilisant votre variable
%% Cell type:code id: tags:
``` python
# Résumé wikipedia de L’Œuvre
text = """Claude Lantier est le fils de Gervaise Macquart et d’Auguste Lantier (voir L'Assommoir, roman où l’on apprend qu’il a été amené à l’âge de huit ans à Plassans par un vieux monsieur séduit par la qualité de ses dessins). Il apparaît aussi dans Le Ventre de Paris. Il est ici l’ami d’enfance du romancier Sandoz, personnage dans lequel Zola a mis beaucoup de lui-même. Avec Sandoz et d’autres peintres ou sculpteurs, Claude combat pour imposer une nouvelle forme de peinture, bien éloignée des canons néo-classiques qui ont la faveur des expositions officielles. Si certains d’entre eux réussissent finalement à s’imposer, Lantier va pour sa part d’échec en échec, demeurant incompris du public et souvent de ses propres amis.
Le roman est aussi une histoire d’amour et d’amitié. Claude Lantier a rencontré un soir de pluie, sous le porche de son immeuble, une jeune femme prénommée Christine, avec qui il partagera sa vie et ses échecs. Ils vont habiter à la campagne, où Claude trouve d’abord le soulagement. Ils ont un enfant, mais celui-ci, hydrocéphale, mourra à l’âge de douze ans. Entre-temps, le couple est revenu vivre à Paris, où Claude retrouve à la fois ses amis et le sentiment de son échec. Il finit par se détacher de sa femme pour passer son temps dans un grand hangar où il a entrepris une œuvre gigantesque, une toile qu’il laissera inachevée et devant laquelle il se pendra.
"""
```
%% Cell type:code id: tags:
``` python
words = text.split(" ")
word_count = len(words)
print("L’article compte " + str(word_count) + " mots")
```
%% Output
L’article compte 235 mots
%% Cell type:markdown id: tags:
## Exercice 2
- Demandez son e-mail à votre voisin
- Notez une variante de l’e-mail, et pas l’e-mail exact. Ça ne se retrouvera pas sur Internet, mais on reste prudents par principe
- Extrayez le nom d’utilisateur de l’e-mail. Par exemple, si c’est rogerdupont@gmail.com, le nom d’utilisateur sera rogerdupont. Pensez aux listes et au fait de choisir un élément de la liste
%% Cell type:code id: tags:
``` python
email = "antoine.falogalo@antoine.net"
email.split("@")[0]
```
%% Output
'antoine.falogalo'
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
## Exercice 3
Voici une lise d’e-mails dans des variables séparées, (`mail1`, `mail2`, `mail3`). Nous voulons en faire une liste pour ajouter plus facilement des clients.
Mettez donc `mail1`, `mail2` et `mail3` dans la liste `clients` et comptez le nombre de clients de la liste à l’aide d’une instruction en Python.
%% Cell type:code id: tags:
``` python
mail1 = "zarah.zauber@zauberberg.fr"
mail2 = "thomas.giannoni@gmail.com"
mail3 = "regis.noto@bluewin.ch"
clients = []
```
%% Cell type:code id: tags:
``` python
# votre code ici
clients = [mail1, mail2, mail3]
print(len(clients))
```
%% Output
3
%% Cell type:code id: tags:
``` python
```
%% Cell type:code id: tags:
``` python
```
%% Cell type:code id: tags:
``` python
```
......

This GitLab is a part of renkulab.io