|
|
|
|
|
|
|
## B) Atelier 1 : un graphique simple, avec un axe des x et un axe des y
|
|
|
|
|
|
|
|
### B1) découverte des instructions de base dans la console
|
|
|
|
En séance, on fera les premiers pas dans la console. Si vous préférez, ou si vous préférez garder une trace, vous pourrez créer un fichier *.py ou un notebook (attention aux petites différences).
|
|
|
|
|
|
|
|
#### Premier contact : variables et listes ; essayez
|
|
|
|
En python, on ne déclare pas les variables ; par contre, elles ont bien un type.
|
|
|
|
Python se débrouille pour comprendre ce que vous affectez à la variable et va assigner le bon type.
|
|
|
|
|
|
|
|
**Règles de nommage** : peu de choses sont interdites en Python, mais un nom de variable doit commencer par une lettre (:robot: 6Po n'est pas un nom valide) et bien sûr certains noms sont réservés : **if**, **for**...
|
|
|
|
:warning: certains noms de méthode ou de classe sont cependant utilisables, ce qui pose problème car en nommant votre variable **max** ou **list** vous surchargez la méthode ou la classe correspondante, qui du coup n'est plus accessible ! Normalement vous devriez vous en rendre compte avec la coloration syntaxique : si le mot change de couleur c'est qu'il est reconnu par Python...
|
|
|
|
|
|
|
|
**Principales conventions** :
|
|
|
|
rien n'est obligatoire en Python, mais il est fortement recommandé de respecter les conventions suivantes pour faciliter la lecture d'autres codes, notamment :
|
|
|
|
* noms de **variables** : en snake-case, les mots sont en minuscules et reliés par des underscore qui le font ressembler à un animal articulé : ma_variable_peut_avoir_un_nom_assez_long
|
|
|
|
* noms de **classes** : en camel-case, les mots commencent par une capitale et sont collés, ce qui crée des bosses dans le nom : MaClasseQuiFaitUnTrucSympa. Les instances de classe seront écrites en snake-case : ma_premiere_classe = MaClasseQuiFaitUnTrucSympa()
|
|
|
|
* noms de **constantes** : en majuscule : COEFFICIENT, CODE_LACUNE. :warning: ce n'est qu'une convention donc en pratique vous pouvez modifier vos constantes en cours de programme...
|
|
|
|
* (il y en a d'autres)
|
|
|
|
|
|
|
|
|
|
|
|
```python
|
|
|
|
a = 10 # assignation, sans préciser le type, Python comprendra : "duck typing"
|
|
|
|
type(a) # réponse = int (typage réalisé par Python en fonction de l'entrée)
|
|
|
|
```
|
|
|
|
Python comprend quel type est affecté à un nom de variable, on parle de "duck typing" : quand vous entendez un canard vous savez que c'est un canard ...
|
|
|
|
Pour travailler avec une collection d'éléments, il existe plusieurs structures en Python.
|
|
|
|
On va utiliser dans un premier temps le **conteneur** le plus "basique", la **liste**.
|
|
|
|
```python
|
|
|
|
une_liste_vide = list() # on crée une _instance_ de la classe _liste_
|
|
|
|
une_autre_liste_vide = [] # les CROCHETS suffisent à signaler à Python que vous avez créé une liste
|
|
|
|
ma_liste = [1, 2, 5, 10, 50] # une liste, définie comme telle par ses CROCHETS, avec ses éléments
|
|
|
|
|
|
|
|
ma_liste[1] # une liste est INDEXABLE* ; le résultat peut vous surprendre : Python commence l'indexation à ZERO, eh oui
|
|
|
|
|
|
|
|
12 in ma_liste # quel est le type de la réponse renvoyée ?
|
|
|
|
ma_liste[2]= 12 # je peux changer un élément de la liste ; c'est possible car une liste est MUTABLE*
|
|
|
|
ma_liste.append(100) # j'ajoute un élément à la liste ; c'est possible car une liste est MUTABLE*
|
|
|
|
ma_liste_non_recommandee = [1, 2, 5, 10, "camembert" , 50.5, (8,12), ma_liste]
|
|
|
|
```
|
|
|
|
Le conteneur liste est un fourre-tout. Pour du calcul matriciel, on préférera la structure de numpy.array (objet array du module numpy).
|
|
|
|
On verra d'autres conteneurs par la suite : tuples et dictionnaires.
|
|
|
|
|
|
|
|
En Python, pas de 'begin" ni de 'end' ni d'accolades pour délimiter les blocs : on définit des **blocs de code** par la seule indentation : le bloc est annoncé par ":" et les lignes appartenant au bloc sont indentées de 4 espaces (ou une tabulation) par rapport à la ligne qui annonce le bloc.
|
|
|
|
C'est une habitude à prendre, et votre environnement de développement vous aidera beaucoup (sous PyCharm : on peut utiliser indifféremment 4 espaces ou une tabulation, et pour réajuster des blocs il y a Edit/Indent ou /Unindent).
|
|
|
|
```python
|
|
|
|
for element in ma_liste: # une liste est ITERABLE* ; tous les conteneurs sont itérables
|
|
|
|
print(element) # indentation de 4 espaces, on est dans le bloc de code
|
|
|
|
print("fini") # l'indentation a cessé, on a quitté le bloc
|
|
|
|
```
|
|
|
|
|
|
|
|
#### On en sait assez pour tracer !
|
|
|
|
### B1. Un graphe super simple.
|
|
|
|
Reportez vous au besoin à la partie A pour les notions de base en Python nécessaires pour le tout début.
|
|
|
|
On va utiliser le module pyplot de matplotlib ; il faut donc déclarer que l'on va l'utiliser, autrement dit on va l'**importer** d'abord.
|
|
|
|
L'usage est d'importer matplotlib.pyplot avec l'alias **"plt"** ; cela économise quelques frappes, et comme tout le monde fait comme ça vous pourrez plus facilement échanger du code.
|
|
|
|
|
| ... | ... | |
