-
Notifications
You must be signed in to change notification settings - Fork 45
/
05_rappels_types.qmd
648 lines (462 loc) · 18.9 KB
/
05_rappels_types.qmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
---
title: "Quelques rappels sur les principes de base de Python"
date: 2020-07-09T15:00:00Z
draft: false
weight: 50
slug: "rappels2A"
type: book
description: |
Rappels d'éléments essentiels en Python: les règles de syntaxes, les classes,
les méthodes, etc.
image: python_dict.jpg
categories:
- Tutoriel
- Rappels
---
::: {.cell .markdown}
```{python}
#| echo: false
#| output: 'asis'
#| include: true
#| eval: true
import sys
sys.path.insert(1, '../../') #insert the utils module
from utils import print_badges
#print_badges(__file__)
print_badges("content/getting-started/05_rappels_types.qmd")
```
:::
[`pandas`](http://pandas.pydata.org/) et [`numpy`](http://www.numpy.org/) sont
essentiels pour manipuler les données.
Néanmoins, il est nécessaire de ne pas faire l'impasse sur les fondements
du langage `Python`. Une bonne compréhension des éléments structurants le
langage entraîne une plus grande productivité et liberté.
Ce chapitre est inspiré du matériel qui était proposé
par [Xavier Dupré](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/notebooks/td2_eco_rappels_1a.html?highlight=rappel),
le précédent professeur de ce cours.
Voir aussi [Essential Cheat Sheets for Machine Learning and Deep Learning Engineers](https://startupsventurecapital.com/essential-cheat-sheets-for-machine-learning-and-deep-learning-researchers-efb6a8ebd2e5).
## Les quelques règles de `Python`
`Python` est un peu susceptible et protocolaire, plus formaliste que ne l'est `R`.
Il y a ainsi quelques règles à respecter :
*Règle 1:* **L'indentation est primordiale** : un code mal indenté provoque une erreur.
L'indentation indique à l'interpréteur où se trouvent les
séparations entre des blocs d'instructions. Un peu comme des points dans un
texte.
Si les lignes ne sont pas bien alignées, l'interpréteur ne sait plus à quel
bloc associer la ligne. Par exemple, le corps d'une fonction doit être indenté
d'un niveau ; les éléments dans une clause logique (`if`, `else`, etc.) également.
*Règle 2:* On commence à compter à 0, comme dans beaucoup de langages
(`C++`, `java`...). `Python` diffère dans ce domaine de `R` où on commence
à compter à 1.
Le premier élément d'une liste est ainsi, en `Python`, le 0-ème.
*Règle 3:* Comme dans une langue naturelle, les marques de
ponctuation sont importantes :
* Pour une liste : `[]`
* Pour un dictionnaire : `{}`
* Pour un tuple : `()`
* Pour séparer des éléments `:` ,
* Pour commenter un bout de code : `#`
* Pour aller à la ligne dans un bloc d'instructions : `\`
* Les majuscules et minuscules sont importantes
* Par contre l'usage des `'` ou des `"` est indifférent.
Il faut juste avoir les mêmes début et fin.
* Pour documenter une fonction ou une classe _""" mon texte de documentation """_
## Les outputs de `Python` : l'opération, le `print` et le `return`
Quand Python réalise des opérations, il faut lui préciser ce qu'il doit en faire :
* est-ce qu'il doit juste faire l'opération,
* afficher le résultat de l'opération,
* créer un objet avec le résultat de l'opération ?
::: {.cell .markdown}
```{=html}
<div class="alert alert-info" role="alert">
<h3 class="alert-heading"><i class="fa-solid fa-comment"></i> Note</h3>
```
Dans l'environnement `Jupyter Notebook`, le dernier élement d'une cellule
est automatiquement affiché (`print`), qu'on lui demande ou non de le faire.
Ce comportement est particulièrement pratique pour afficher des figures
générées via `matplotlib` ou `seaborn`.
Ce comportement
n'est pas le cas dans un éditeur classique comme `VisualStudio`,
`Spyder` ou `PyCharm`. Pour afficher un résultat dans la console,
il faut utiliser
`print` ou la commande consacrée (par exemple `plt.show()`
pour afficher la dernière figure générée par `matplotlib`)
```{=html}
</div>
```
:::
### Le `print`
```{python}
# on calcule : dans le cas d'une opération par exemple une somme
2+3 # Python calcule le résultat mais n'affiche rien dans la sortie
# le print : on affiche
print(2+3) # Python calcule et on lui demande juste de l'afficher
# le résultat est en dessous du code
```
```{python}
# le print dans une fonction
def addition_v1(a,b) :
print(a+b)
resultat_print = addition_v1(2,0)
print(type(resultat_print))
# dans la sortie on a l'affichage du résultat, car la sortie de la fonction est un print
# en plus on lui demande quel est le type du résultat. Un print ne renvoie aucun type, ce n'est ni un numérique,
# ni une chaine de charactères, le résultat d'un print n'est pas un format utilisable
```
Le résultat de l'addition est affiché
car la fonction `addition_v1` effectue un `print`
Par contre, l'objet créé n'a pas de type, il n'est pas un chiffre,
ce n'est qu'un affichage.
### Le `return`
Pour créer un objet avec le résultat de la fonction, il faut utiliser __`return`__
```{python}
# le return dans une fonction
def addition_v2(a,b) :
return a+b
resultat_return = addition_v2(2,5) #
print(type(resultat_return))
## là on a bien un résultat qui est du type "entier"
```
Le résultat de `addition_v2` n'est pas affiché comme dans `addition_v1`
Par contre, la fonction `addition_v2` permet d'avoir un objet de type `int`,
un entier donc.
## Les types de base : variables, listes, dictionnaires...
`Python` permet de manipuler différents types de base. Nous en
verrons des extensions dans la suite du cours (`np.array` par exemple)
qui, d'une manière ou d'une autre, s'appuient sur ces types de base.
On distingue deux types de variables : les __immuables__ (*immutables*)
qui ne peuvent être
modifiés et les __modifiables__ (*mutables*)
### Les variables immuables
Les variables immuables ne peuvent être modifiées
- `None` : ce type est une convention de programmation pour dire que la valeur n'est pas calculée
- `bool` : un booléen
- `int` : un entier
- `float` : un réel
- `str` : une chaine de caractères
- `tuple` : un vecteur
```{python}
i = 3 # entier = type numérique (type int)
r = 3.3 # réel = type numérique (type float)
s = "exemple" # chaîne de caractères = type str
n = None # None signifie que la variable existe mais qu'elle ne contient rien
# elle est souvent utilisée pour signifier qu'il n'y a pas de résultat
a = (1,2) # tuple
print(i,r,s,n,a)
```
Si on essaie de changer le premier élément de la chaine de caractères `s` on va avoir un peu de mal.
Par exemple si on voulait mettre une majuscule à _"exemple"_,
on aurait envie d'écrire que le premier élément de la chaine `s` est "E" majuscule
Mais `Python` ne va pas nous laisser faire, il nous dit que les objets "chaine de caractère" ne peuvent être modifiés
```{python}
#| error: true
s[0] = "E" # déclenche une exception
```
Tout ce qu'on peut faire avec une variable immuable,
c'est la réaffecter à une autre valeur : elle ne peut pas être modifiée.
Pour s'en convaincre, utilisons la fonction `id()` qui donne un identifiant à chaque objet.
```{python}
print(s)
id(s)
```
```{python}
s = "autre_mot"
id(s)
```
On voit bien que `s` a changé d'identifiant : il peut avoir le même nom, ce n'est plus le même objet
### Les types modifiable : listes et dictionnaires
Heureusement, il existe des variables modifiables comme les listes et les dictionnaires.
#### Les listes - elles s'écrivent entre `[ ]`
Les listes sont des élements très utiles, notamment quand vous souhaitez faire des boucles.
Pour faire appel aux élements d'une liste, on donne leur position dans la liste : le 1er est le 0, le 2ème est le 1 ...
```{python}
ma_liste = [1,2,3,4]
print("La longueur de ma liste est de", len(ma_liste))
print("Le premier élément de ma liste est :", ma_liste[0])
print("Le dernier élément de ma liste est :", ma_liste[3])
print("Le dernier élément de ma liste est :", ma_liste[-1])
```
Pour effectuer des boucles sur les listes, la méthode la plus lisible
est d'utiliser les `list comprehension`. Cette approche consiste
à itérer les éléments d'une liste à la volée.
Par exemple, si on reprend [cet exemple](https://www.w3schools.com/python/python_lists_comprehension.asp),
un code qui repose sur les `list comprehension` sera le suivant:
```{python}
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [x for x in fruits if "a" in x]
print(newlist)
```
Le même code, ne reposant pas sur les compréhensions de liste, sera beaucoup
moins concis et ainsi inutilement verbeux:
```{python}
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []
for x in fruits:
if "a" in x:
newlist.append(x)
print(newlist)
```
#### Les dictionnaires - ils s'écrivent entre accolades `{}`
Un dictionnaire associe à une clé un autre élément, appelé une valeur : un chiffre, un nom, une liste, un autre dictionnaire etc.
Le format d'un dictionnaire est le suivant: `{Clé : valeur}`. Il s'agit
d'un objet très pratique pour la recherche, beaucoup plus que les listes
qui ne permettent pas de stocker de l'information diverse de manière
hiérarchisée.
#### Dictionnaire avec des valeurs int
On peut par exemple associer à un nom, un nombre
```{python}
mon_dictionnaire_notes = { 'Nicolas' : 18 , 'Pimprenelle' : 15}
# un dictionnaire qui à chaque nom associe un nombre
# à Nicolas, on associe 18
print(mon_dictionnaire_notes)
```
#### Dictionnaire avec des valeurs qui sont des listes
Pour chaque clé d'un dictionnaire, il ne faut pas forcément garder la même forme de valeur
Dans l'exemple, la valeur de la clé "Nicolas" est une liste, alors que celle de "Philou" est une liste de liste
```{python}
mon_dictionnaire_loisirs = \
{ 'Nicolas' : ['Rugby','Pastis','Belote'] ,
'Pimprenelle' : ['Gin Rami','Tisane','Tara Jarmon','Barcelone','Mickey Mouse'],
'Philou' : [['Maths','Jeux'],['Guillaume','Jeanne','Thimothée','Adrien']]}
```
Pour accéder à un élément du dictionnaire, on fait appel à la clé et non plus à la position, comme c'était le cas dans les listes.
C'est beaucoup plus pratique pour rechercher de l'information:
```{python}
print(mon_dictionnaire_loisirs['Nicolas']) # on affiche une liste
```
```{python}
print(mon_dictionnaire_loisirs['Philou']) # on affiche une liste de listes
```
Si on ne veut avoir que la première liste des loisirs de Philou, on demande le premier élément de la liste
```{python}
print(mon_dictionnaire_loisirs['Philou'][0]) # on affiche alors juste la première liste
```
On peut aussi avoir des valeurs qui sont des `int` et des `list`
```{python}
mon_dictionnaire_patchwork_good = \
{ 'Nicolas' : ['Rugby','Pastis','Belote'] ,
'Pimprenelle' : 18 }
```
### A retenir
- L'indentation du code est importante (4 espaces et pas une tabulation)
- Une __liste__ est entre [] et on peut appeler les positions par leur place
- Un __dictionnaire__, clé x valeur, s'écrit entre {} et on appelle un élément en fonction de la clé
## Questions pratiques :
<!-- KA : Attention, les box d'exercices ne s'affichent pas ni sur les notebook jupyters téléchargés, , ni sur le site. -->
::: {.cell .markdown}
```{=html}
<div class="alert alert-success" role="alert">
<h3 class="alert-heading"><i class="fa-solid fa-pencil"></i> Exercice</h3>
```
1. Quelle est la position de 7 dans la liste suivante
```{python}
liste_nombres = [1,2,7,5,3]
```
2. Combien de clés a ce dictionnaire ?
```{python}
dictionnaire_evangile = {"Marc" : "Lion", "Matthieu" : ["Ange","Homme ailé"] ,
"Jean" : "Aigle" , "Luc" : "Taureau"}
```
3. Que faut-il écrire pour obtenir _"Ange"_ en résultat à partir du `dictionnaire_evangile` ?
```{=html}
</div>
```
:::
```{python}
#| include: false
#| eval: false
# Question 1
liste_nombres.index(7)
```
```{python}
#| include: false
#| eval: false
# Question 2
# 4 clefs
print(len(dictionnaire_evangile.keys()))
```
```{python}
#| include: false
# Question 3
dictionnaire_evangile["Matthieu"][0]
```
## Effectuer des opérations sur les objets de base `Python`
Maintenant qu'on a vu quels objets existent en `Python`,
nous allons
voir comment nous en servir.
Pour comprendre comment modifier un objet, il convient
de distinguer deux concepts, développés plus amplement
dans le chapitre dédié: les __attributs__ et les __méthodes__ :
- Les _attributs_ décrivent la structure interne d'un objet. Par exemple,
la taille d'un objet, sa langue, etc.
Nous n'allons pas trop développer ce concept ici. Le chapitre dédié au sujet
permettra de plus développer ce concept.
- Les __méthodes__ correspondent à des actions qui s'appliqueront à l'objet et s'adaptent à sa structure.
La même méthode (par exemple `append`) fonctionnera ainsi de manière différente selon le type d'objet.
### Premiers exemples de méthodes
Avec les éléments définis dans la partie 1
(les listes, les dictionnaires) on peut faire appel à des méthodes qui sont directement liées à ces objets.
#### Une méthode pour les listes
Pour ajouter un élément (`item`) dans une liste : on va utiliser la méthode _`.append()`_
```{python}
ma_liste = ["Nicolas","Michel","Bernard"]
ma_liste.append("Philippe")
print(ma_liste)
```
#### Une méthode pour les dictionnaires
Pour connaitre l'ensemble des clés d'un dictionnaire, on appelle la méthode _`.keys()`_
```{python}
mon_dictionnaire = {"Marc" : "Lion", "Matthieu" : ["Ange","Homme ailé"] ,
"Jean" : "Aigle" , "Luc" : "Taureau"}
print(mon_dictionnaire.keys())
```
### Connaitre les méthodes d'un objet
Pour savoir quelles sont les méthodes d'un objet vous pouvez :
- taper `help(mon_objet)` ou `mon_objet?` dans la console `Python`
- taper mon_objet. + touche tabulation dans la console `Python` ou dans le `Notebook`.
`Python` permet la complétion, c'est-à-dire que vous pouvez faire appaître la liste
des méthodes possibles.
## Les opérations et méthodes classiques des listes
### Créer une liste
Pour créer un objet de la classe `list`, il suffit de le déclarer. Ici on affecte à __`x`__ une liste
```{python}
x = [4, 5] # création d’une liste composée de deux entiers
x = ["un", 1, "deux", 2] # création d’une liste composée de 2 chaînes de caractères
# et de deux entiers, l’ordre d’écriture est important
x = [3] # création d’une liste d’un élément, sans la virgule,
x = [ ] # crée une liste vide
x = list () # crée une liste vide
```
### Un premier test sur les listes
Si on veut tester la présence d'un élément dans une liste, on l'écrit de la manière suivante :
```{python}
# Exemple
x = "Marcel"
l = ["Marcel","Edith","Maurice","Jean"]
print(x in l)
#vrai si x est un des éléments de l
```
### `+`: une méthode pour concaténer deux listes
On utilise le symbole `+`
```{python}
t = ["Antoine","David"]
print(l + t) #concaténation de l et t
```
### Pour trouver certains éléments d'une liste
Pour chercher des élements dans une liste, on utilise la position dans la liste.
```{python}
l[1] # donne l'élément qui est en 2ème position de la liste
```
```{python}
l[1:3] # donne les éléments de la 2ème position de la liste à la 4ème exclue
```
### Quelques fonctions des listes
Les listes embarquent ainsi nativement un certain nombre de méthodes
qui sont pratiques. Cependant, pour avoir certaines informations
sur une liste, il faut parfois plutôt passer par
des fonctions natives comme les suivantes:
```{python}
longueur = len(l) # nombre d’éléments de l
minimum = min(l) # plus petit élément de l, ici par ordre alphabétique
maximum = max(l) # plus grand élément de l, ici par ordre alphabétique
print(longueur,minimum,maximum)
```
```{python}
del l[0 : 2] # supprime les éléments entre la position 0 et 2 exclue
print(l)
```
### Les méthodes des listes
On les trouve dans l'aide de la liste.
On distingue les méthodes et les méthodes spéciales : visuellement,
les méthodes spéciales sont celles qui précédées et suivis de deux caractères de soulignement,
les autres sont des méthodes classiques.
```{python}
help(l)
```
### A retenir et questions
A retenir :
- Chaque objet `Python` a des attributs et des méthodes
- Vous pouvez créer des classes avec des attributs et des méthodes
- Les méthodes des listes et des dictionnaires qui sont les plus utilisées :
- `list.count()`
- `list.sort()`
- `list.append()`
- `dict.keys()`
- `dict.items()`
- `dict.values()`
::: {.cell .markdown}
```{=html}
<div class="alert alert-success" role="alert">
<h3 class="alert-heading"><i class="fa-solid fa-pencil"></i> Exercice 2</h3>
```
1. Définir la liste allant de 1 à 10, puis effectuez les actions suivantes :
* triez et affichez la liste
* ajoutez l’élément 11 à la liste et affichez la liste
* renversez et affichez la liste
* affichez l’élément d’indice 7
* enlevez l’élément 9 et affichez la liste
* affichez la sous-liste du 2e au 3e éléments inclus ;
* affichez la sous-liste du début au 2e élément inclus ;
* affichez la sous-liste du 3e élément à la fin de la liste ;
2. Construire le dictionnaire des 6 premiers mois de l'année avec comme valeurs le nombre de jours respectif.
* Renvoyer la liste des mois
* Renvoyer la liste des jours
* Ajoutez la clé du mois de Juillet
```{=html}
</div>
```
:::
```{python}
#| include: false
#| eval: false
# Correction
## liste des nombres de 1 à 10
liste = list(range(1, 11))
## triez et affichez la liste
liste.sort()
print(liste)
## ajoutez l’élément 11 à la liste et affichez la liste
liste.append(11)
print(liste)
## renversez et affichez la liste
liste.sort(reverse=True)
print(liste)
## affichez l’élément d'indice 7
print(liste[7])
## enlevez l’élément 9 et affichez la liste
liste.remove(9)
print(liste)
## affichez la sous-liste du 2e au 3e éléments inclus ;
print(liste[1:3])
## affichez la sous-liste du début au 2e élément inclus ;
print(liste[:2])
## affichez la sous-liste du 3e élément à la fin de la liste ;
print(liste[2:])
```
```{python}
#| include: false
#| eval: false
# Correction
## Construire le dictionnaire des 6 premiers mois de l'année avec comme valeurs le nombre de jours respectif.
mon_dictionnaire_mois = { 'Janvier' : 31 , 'Fevrier' : 28, 'Mars' : 31, 'Avril' : 30, 'Mai' : 31, 'Juin' : 30}
## Renvoyer la liste des mois
print(list(mon_dictionnaire_mois.keys()))
## Renvoyer la liste des jours
print(list(mon_dictionnaire_mois.values()))
## Ajoutez la clé du mois de Juillet
mon_dictionnaire_mois['Juillet']=31
print(mon_dictionnaire_mois)
```
## Passer des listes, dictionnaires à `pandas`
Supposons que la variable 'data' est une liste qui contient nos données.
Une observation correspond à un dictionnaire qui contient le nom, le type, l'ambiance et la note d'un restaurant.
Il est aisé de transformer cette liste en dataframe grâce à la fonction 'DataFrame'.
```{python}
import pandas
data = [{"nom": "Little Pub", "type" : "Bar", "ambiance": 9, "note": 7},
{"nom": "Le Corse", "type" : "Sandwicherie", "ambiance": 2, "note": 8},
{"nom": "Café Caumartin", "type" : "Bar", "ambiance": 1}]
df = pandas.DataFrame(data)
print(data)
df
```