Retravaille TP Python bases 2A
This commit is contained in:
parent
29cc646c5b
commit
fad0ab7300
3 changed files with 393 additions and 170 deletions
291
src/cours/CIEL2/01-revisions-python/cours/python-bases.md
Normal file
291
src/cours/CIEL2/01-revisions-python/cours/python-bases.md
Normal file
|
|
@ -0,0 +1,291 @@
|
|||
# Bases de Python
|
||||
|
||||
## Mode interactif ou script
|
||||
|
||||
### Mode interactif
|
||||
|
||||
Nous allons commencer par utiliser Python en mode interactif. Cela nous permettra de saisir des instructions, que Python va exécuter. Ouvrez le terminal vu en 5. dans la partie précédente.
|
||||
|
||||
Le mode interactif fonctionne de la manière suivante :
|
||||
1. Il y a une **invite de commande**, qui est symbolisée par les `>>>`. Comme son nom l'indique, elle est là pour vous inviter à taper une commande.
|
||||
2. Vous pouvez taper une commande et la valider avec la touche <kbd>Entrée</kbd>
|
||||
3. Il **évalue l'expression saisie** : il l'analyse et l'exécute
|
||||
4. Il affiche enfin le résultat.
|
||||
|
||||
```admonish tip title="Astuce"
|
||||
Si vous utilisez les flèches <kbd>↑</kbd> et <kbd>↓</kbd> dans l'invite de commande, vous pourrez naviguer dans l'historique des commandes tapées, et réutiliser d'anciennes commandes pour les modifier ou les réexécuter.
|
||||
```
|
||||
|
||||
### Script
|
||||
|
||||
```admonish success title='À retenir'
|
||||
Un **éditeur de texte** est différent d'un **logiciel de traitement de texte**.
|
||||
- Un éditeur de texte permet de manipuler du texte brut, sans mise en forme. Il pourra avoir des fonctionnalités de coloration automatique ou de suggestions pour vous aider à écrire dans des langages de programmation. Ex: VSCode, Notepad++, Geany, Gedit, Kate, Sublime Text (non libre)...
|
||||
- Un logiciel de traitement de texte ne peut pas être utilisé pour écrire du code : il contient de nombreuses informations de mise en forme et travaille généralement avec des fichiers binaires ou un format spécifique très éloigné du texte brut nécessaire à la programmation. Ex: Libre Office Writer, Only Office Document, Microsoft Office Word (non-libre)
|
||||
```
|
||||
|
||||
```admonish success title="À retenir"
|
||||
Un fichier contenant du code Python s'appelle un **script**. Les scripts python ont un nom se finissant par l'**extension** `.py`
|
||||
```
|
||||
|
||||
## Opérateurs, variables, types
|
||||
|
||||
### Opérateurs
|
||||
|
||||
#### Opérateurs de calcul
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : il écrira `4.5` et non pas `4,5`. Il en va de même lorsque vous écrirez des nombres en Python.
|
||||
- Opérateurs courants en python :
|
||||
|
||||
|Opérateur|Explication|
|
||||
|-|-|
|
||||
|`+`|Addition|
|
||||
|`-`|Soustraction|
|
||||
|`*`|Multiplication|
|
||||
|`/`|Division|
|
||||
|`//`|Division entière (renvoie un quotient entier)|
|
||||
|`%`|Modulo (renvoie le reste de la division euclidienne)|
|
||||
|`**`|Puissance|
|
||||
|
||||
- Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
|
||||
```
|
||||
|
||||
#### Opérateurs de comparaison
|
||||
|
||||
```admonish success title='À retenir'
|
||||
Nous avons vu dans l'activité précédente les opérateurs `==`, `<` et `>`. On les appelle les **opérateurs de comparaison**. Il en existe d'autres :
|
||||
|
||||
|Opérateur|Description|
|
||||
|---------|-----------|
|
||||
|`==`| Égal à|
|
||||
|`!=`| Différent de|
|
||||
|`<`| Strictement inférieur à|
|
||||
|`>`| Strictement supérieur à|
|
||||
|`<=`| Inférieur ou égal à|
|
||||
|`>=`| Supérieur ou égal à|
|
||||
|
||||
Attention, l'opérateur d'égalité est bien `==`, et non pas `=`. Utiliser l'opérateur d'affectation `=` pourra produire un code qui s'exécute, mais n'aura pas le résultat que vous attendez.
|
||||
|
||||
|
||||
Les **opérateurs booléens** servent à faire des opérations avec des types `bool` ou pour créer des conditions plus complexes.
|
||||
|
||||
|Opérateur| Description|
|
||||
|---------|------------|
|
||||
|`and`| Si les deux conditions sont vraies, retourne `True`, sinon `False`|
|
||||
|`or` | Si **au moins** l'une des deux conditions est vraie, retourne `True`, sinon `False`|
|
||||
|`not`| Inverse le résultat de la condition|
|
||||
|
||||
Les opérateurs booléens peuvent être chainés et combinés pour faire des conditions plus complexes.
|
||||
|
||||
Les nombres (et plein d'autres types) peuvent être considérés comme `True` ou `False` dans une condition (ou convertis avec la fonction `bool`).
|
||||
- Un entier non nul sera considéré comme `True`, un `0` sera considéré comme `False`
|
||||
- Une chaîne de caractères sera considérée comme `True`, sauf si elle est vide.
|
||||
```
|
||||
|
||||
```admonish tip title="Astuce"
|
||||
Les opérateurs `>`, `<`, `>=`, `<=` peuvent être chaînés pour faire des comparaisons d'intervalles. Par exemple, pour vérifier que la variable a est comprise entre 0 et 100, vous pouvez écrire '0 < a < 100'
|
||||
```
|
||||
|
||||
#### Opérateurs booléens
|
||||
|
||||
#### Opérateurs bit à bit
|
||||
|
||||
|
||||
### Variables
|
||||
|
||||
Que sont les variables ? C'est la base de tout programme informatique : elles vous permettent de stocker une information (un nombre, le résultat d'un calcul, une phrase sous forme de chaîne de caractères...) pour la réutiliser plus tard.
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Les variables sont une donnée de votre programme stockée dans l'ordinateur.
|
||||
- Elles sont nommées et on peut les **affecter** en écrivant `ma_variable = <contenu de ma variable>` (attention la variable est toujours à gauche, le contenu toujours à droite). Affecter signifie mettre un contenu dans la variable.
|
||||
|
||||
- Les noms des variables peuvent comporter:
|
||||
- Des caratères **alphanumériques**, c'est à dire des lettres minuscules ou majuscules et des chiffres
|
||||
- Des `_` (tiret du bas, sur la touche <kbd>8</kbd> de votre clavier)
|
||||
- Les noms des variables ne peuvent pas commencer par un chiffre
|
||||
- Les noms des variables sont **sensibles à la casse** : c'est à dire qu'une variable écrite avec des majuscules sera différente d'une variable écrite avec des minuscules (par exemple ma variable `age` sera différente de `Age`)
|
||||
- Certains mots-clés ne peuvent pas être utilisés comme des noms de variables parce qu'ils sont **réservés**, c'est à dire qu'ils ont une autre signification dans le langage.
|
||||
- En python, la **convention** veut que l'on écrive les variables sous la forme dite **snake case** : on va l'écrire avec uniquement des minuscules en remplaçant les espaces par des `_`. Par exemple, une variable représentant la date de naissance pourra s'écrire : `date_de_naissance`
|
||||
```
|
||||
|
||||
Vous verrez la plupart des mots **réservés** par la suite, et comprendrez vite pourquoi on ne peut pas les utiliser comme variables, tout en les retenant facilement, mais vous pourrez trouver la liste de ces mot-clés dans la [documentation python](https://docs.python.org/3/reference/lexical_analysis.html#keywords)
|
||||
|
||||
```admonish warning title="Important"
|
||||
Python utilise beaucoup de **conventions** dans son langage. Une convention est une règle qui n'est pas obligatoire mais que tout le monde respecte par habitude, et parce que cela permet d'avoir un code qui est facile à lire par tout le monde. Même si elles sont parfois arbitraires, elles ont en général été pensées et établies par la communauté suite à des retours d'expérience. Par ailleurs, certaines conventions permettent de donner des informations supplémentaires importantes (nous en verrons régulièrement par la suite).
|
||||
|
||||
Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vous devrez respecter les conventions que nous verrons pour prendre les bonnes habitudes, sinon je les considèrerai comme des erreurs.
|
||||
```
|
||||
|
||||
### Types
|
||||
|
||||
Les variables peuvent contenir differents types de données. Nous avons surtout vu des nombres jusqu'à maintenant, mais elles peuvent aussi contenir des **chaînes de caractères** ou d'autres types plus complexes. Nous verrons dans un premier temps les plus simples.
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Python est capable de trouver le type d'une donnée tout seul, et cette variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
|
||||
- Python possède une fonction `type` qui permet d'afficher le type de chaque variable.
|
||||
```
|
||||
|
||||
```admonish success title="À retenir"
|
||||
Voici un tableau recensant les principaux types de base de Python
|
||||
|
||||
| Type | Explication | Exemple |
|
||||
|------|-------------|---------|
|
||||
| int | Nombre entier | `1` |
|
||||
| float | Nombre décimal (à virgule "flottante") | `1.23` |
|
||||
| bool | Booléen : une valeur pouvant être soit vraie soit fausse | `True` ou `False` |
|
||||
| str | Chaîne de caractères : des caractères qui se suivent pour représenter du texte | `'Hello !'` |
|
||||
|
||||
Les chaînes de caractères peuvent s'écrire avec des guillemets simples `'` (touche <kbd>4</kbd>) (qui est aussi utilisé en apostrophe en français) ou des guillemets doubles `"` (touche <kbd>3</kbd>).
|
||||
|
||||
Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et inversement. Exemples:
|
||||
- `"J'aime les spaghettis"`
|
||||
- `'Elle a dit "Hello"'`
|
||||
```
|
||||
|
||||
|
||||
#### Conversions
|
||||
|
||||
|
||||
### Affichage et saisie de données
|
||||
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- La fonction `print` permet d'afficher des chaînes de caractères et/ou des variables.
|
||||
- Elle peut prendre plusieurs arguments, et affichera les arguments séparés par un espace
|
||||
- La fonction `input` permet de demander la personne utilisant votre programme de saisir du texte
|
||||
- Elle prend en argument optionnel une chaîne de caractère qui s'affichera avant la saisie
|
||||
- Elle renvoie ce qui a été saisi sous forme d'une chaîne de caractères. Il faut donc penser à convertir si vous avez besoin d'un autre type.
|
||||
- Le résultat de la fonction peut être immédiatement affecté à une variable.
|
||||
- Les chaînes de caratères peuvent être **formatées** : on l'écrira sous la forme `f"chaine de caractère {variable}"`, ce qui permettra de remplacer les variables entre accolades `{}` par leur valeur dans la chaîne de caractères. Le `f` avant les guillemets est important car il permet de dire à Python que la chaîne est formatée. Si vous l'oubliez, il ne cherchera pas à remplacer les variables par leur valeur.
|
||||
|
||||
Les chaînes formatées sont très utilisées en python. Elles servent à afficher des informations dynamiques en fonction de variables, mais vous aideront aussi à comprendre ce que font vos programmes et vous aider à les corriger.
|
||||
```
|
||||
|
||||
## Structures conditionnelles
|
||||
|
||||
|
||||
```admonish success title='À retenir'
|
||||
Les **structures conditionnelles** ressemblent à ceci :
|
||||
~~~python
|
||||
if condition:
|
||||
# Faire quelque chose
|
||||
elif autre_condition:
|
||||
# Faire autre chose
|
||||
else:
|
||||
# Dans tous les autres cas, faire cette chose
|
||||
~~~
|
||||
|
||||
- Elles permettent d'exécuter un code différent selon des conditions.
|
||||
- Le mot-clé `if` est celui qui indique le début d'une structure conditionnelle. Il est obligatoire.
|
||||
- Le mot-clé `elif` permet de rajouter des conditions. On peut en mettre autant que l'on veut. Il est optionnel.
|
||||
- Le mot-clé `else` permet de gérer tous les cas qui n'entrent pas dans les précédentes conditions. Il est forcément en dernier et est optionnel.
|
||||
- Il est important de ne pas oublier
|
||||
- Le symbole `:` à la fin de chaque ligne commençant par `if`, `elif` ou `else`
|
||||
- D'indenter votre code, pour indiquer à python ce qui est concerné par une condition.
|
||||
- Ne pas indenter correctement un code python est une **erreur de syntaxe**, c'est à dire que le code n'est pas valide et ne pourra pas s'exécuter
|
||||
```
|
||||
|
||||
```admonish tip title='Astuce'
|
||||
Il est possible d'imbriquer plusieurs conditions, en indentant correctement votre code de la manière suivante:
|
||||
~~~python
|
||||
if condition:
|
||||
if sous_condition:
|
||||
# Faire qqch
|
||||
elif sous_condition_2 :
|
||||
# Faire autre chose
|
||||
else:
|
||||
# Traiter les autres cas
|
||||
~~~
|
||||
```
|
||||
|
||||
## Structures répétitives
|
||||
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Les boucles permettent de répéter des instructions plusieurs fois.
|
||||
- Il y a deux formes, la boucle `while` et la boucle `for`. En pratique, en Python, on préfère utiliser la boucle `for` la majorité du temps.
|
||||
- La boucle `while` a la syntaxe suivante :
|
||||
~~~python
|
||||
while condition_est_respectee :
|
||||
# Je fais quelque chose
|
||||
~~~
|
||||
- Elle peut se lire de la manière suivante : "Tant que la condition est vraie, faire ..."
|
||||
- Dès que la condition n'est plus respectée la boucle se termine.
|
||||
- Si la condition n'est jamais respectée, le code de la boucle n'est jamais exécuté.
|
||||
- Si la condition est toujours respectée, la boucle s'exécute à l'infini.
|
||||
- Il faut donc prévoir, dans votre boucle, un moyen de faire évoluer la condition.
|
||||
- Attention au `:` et à l'indentation !
|
||||
- La boucle `for` a la syntaxe suivante :
|
||||
~~~python
|
||||
for variable in ensemble:
|
||||
# Je fais quelque chose
|
||||
~~~
|
||||
- Elle peut se lire de la manière suivante : "Pour tous les éléments dans l'ensemble, faire ..."
|
||||
- La boucle `for` va **itérer** sur un ensemble de données. Itérer signifie répéter sur chaque élément de l'ensemble en passant au suivant, dans l'ordre.
|
||||
- L'ensemble peut être une liste, une chaîne de caractères, mais également plein d'autres choses. Nous aurons un TP quasiment entier consacré à ça.
|
||||
- Attention au `:` et à l'indentation
|
||||
```
|
||||
|
||||
### For
|
||||
|
||||
#### Fonction range
|
||||
|
||||
### While
|
||||
|
||||
## Fonctions
|
||||
|
||||
Vous connaissez déjà certaines fonctions, celles que vous avez utilisées lors du précédent TP : `print`, `input`, `math.sqrt`, `range` ... Ce sont des fonctions que vous avez **appelées** mais qui existent déjà, soit par défaut dans le langage Python, soit dans une bibliothèque (`math`).
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Les fonction s'utilisent avec la syntaxe suivante : `nom_de_la_fonction(parametre_1, parametre_2, ...., parametre_n)`
|
||||
- Vous mettez le nom de la fonction, suivi de parenthèses
|
||||
- Entre les parenthèses vous mettez les paramètres séparés par des virgules
|
||||
- Si une fonction n'a pas besoin de paramètres, les parenthèses sont quand même indispensables
|
||||
|
||||
- Certaines fonctions peuvent prendre des paramètres nommés, avec la syntaxe suivante : `nom_de_la_fonction(nom_parametre=valeur_parametre)`. Les paramètres nommés sont toujours à la fin et leur ordre n'a pas d'importance.
|
||||
|
||||
- Une fonction peut renvoyer un résultat, que l'on peut alors affecter à une variable.
|
||||
- Si une fonction ne renvoie rien, alors elle renverra en réalité la valeur spéciale `None`.
|
||||
```
|
||||
|
||||
`
|
||||
|
||||
```admonish success title='À retenir'
|
||||
- Les fonctions servent à rendre votre code plus clair et mieux découpé. Elles permettent de réutiliser du code.
|
||||
- Pour déclarer une fonction en python :
|
||||
~~~python
|
||||
def nom_de_la_fonction(parametre_1, parametre_2, ..., parametre_n):
|
||||
# Instructions
|
||||
~~~
|
||||
- On utilise le mot-clé `def` suivi du nom de la fonction.
|
||||
- Entre parenthèses on ajoute les paramètres qu'il faudra fournir
|
||||
- À la fin de la ligne on met `:` (encore et toujours)
|
||||
- On passe à la ligne suivante et on indente pour écrire les instructions.
|
||||
- Les paramètres fonctionnent comme des variables : on peut les utiliser dans la fonction avec leur nom.
|
||||
- On peut définir une valeur par défaut à un paramètre : il suffit d'écrire `parametre=valeur_par_defaut` lors de la déclaration. On peut alors omettre le paramètre, qui prendra automatiquement la valeur par défaut.
|
||||
- Deux fonctions ne peuvent pas avoir le même nom, sinon, la dernière a avoir été déclarée écrase la précédente.
|
||||
```
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- L'instruction `return` permet de sortir immédiatement d'une fonction. Rien ne s'exécutera après le `return`
|
||||
- `return` permet de retourner un résultat, avec la syntaxe `return valeur`. Si aucune valeur n'est mentionnée, elle retournera `None`
|
||||
- Si `return` n'est pas mentionnée, la fonction s'exécute jusqu'au bout et sortira à la fin du bloc d'instructions en retournant `None`
|
||||
- On peut retourner plusieurs valeurs en les séparant par une virgule.
|
||||
- Ces valeurs peuvent être affectées à une seule variable sous forme d'un **tuple** (nous en parlerons au prochain TP)
|
||||
- Chaque valeur peut être affectée à une variable différente avec la syntaxe `variable_1, variable_2 ... = nom_de_la_fonction(...)`.
|
||||
```
|
||||
|
||||
```admonish tip title='Bonnes pratiques'
|
||||
- Faites des fonctions courtes qui vont à l'essentiel (20 lignes est un bon maximum)
|
||||
- Choisissez bien les noms de vos fonctions et de vos paramètres pour qu'ils soient clairs et explicites
|
||||
- Vous pouvez documenter vos fonctions à l'aide d'une **docstring** : après l'en-tête de la fonction, avant le bloc d'instructions vous pouvez écrire une chaîne de caractères qui commence par 3 `"` ou `'`.
|
||||
Exemple:
|
||||
~~~python
|
||||
def ma_fonction(arg_1, arg2):
|
||||
"""Ceci est une docstring qui vient documenter ma fonction.
|
||||
Une docstring peut prendre plusieurs lignes.
|
||||
"""
|
||||
# Bloc d'instructions
|
||||
~~~
|
||||
```
|
||||
|
|
@ -4,11 +4,10 @@ Dans ce TP nous allons revoir les bases de la programmation en python. Nous comm
|
|||
- Les variables, l'affichage d'informations et la saisie de l'utilisateurice
|
||||
- Les structures conditionnelles : `if ... elif ... else`
|
||||
- Les boucles `for` et `while`
|
||||
- Et les fonctions
|
||||
|
||||
Nous en profiterons pour ajouter quelques remarques sur les bonnes pratiques de code au fil de l'eau.
|
||||
|
||||
## 1 - Travailler avec Visual Studio Code
|
||||
## 1 - Travailler avec Visual Studio Code - 10 minutes
|
||||
|
||||
Visual Studio Code est un éditeur de texte libre édité par Microsoft, compatible avec toutes les plateformes. Il est un logiciel très utilisé en entreprise et pourra vous servir pour de nombreux langages de programmation. C'est pour cela que nous allons commencer (continuer ?) à l'utiliser, et vous vous habituerez à son fonctionnement au fil du temps.
|
||||
|
||||
|
|
@ -56,9 +55,13 @@ Lancez Visual Studio Code depuis le menu démarrer de votre machine. Vous verrez
|
|||
Nous voilà prêts à travailler.
|
||||
```
|
||||
|
||||
|
||||
## 2 - Variables, opérations, entrées-sorties et chaînes de caractères
|
||||
|
||||
```admonish warning title='Attention'
|
||||
- Pour les parties 2.1 2.2 et 2.3 on travaille dans l'interpréteur python. Il n'y a pas de fichiers à créer.
|
||||
- Pour votre compte rendu : un simple copier-coller de votre console (la commande et son résultat) suffira, sauf pour les questions d'interprétation.
|
||||
```
|
||||
|
||||
Nous allons commencer par utiliser Python en mode interactif. Cela nous permettra de saisir des instructions, que Python va exécuter. Ouvrez le terminal vu en 5. dans la partie précédente.
|
||||
|
||||
Le mode interactif fonctionne de la manière suivante :
|
||||
|
|
@ -71,67 +74,43 @@ Le mode interactif fonctionne de la manière suivante :
|
|||
Si vous utilisez les flèches <kbd>↑</kbd> et <kbd>↓</kbd> dans l'invite de commande, vous pourrez naviguer dans l'historique des commandes tapées, et réutiliser d'anciennes commandes pour les modifier ou les réexécuter.
|
||||
```
|
||||
|
||||
### 2.1 - Opérateurs
|
||||
### 2.1 - Opérateurs - 15 min
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : il écrira `4.5` et non pas `4,5`. Il en va de même lorsque vous écrirez des nombres en Python.
|
||||
- Opérateurs courants en python :
|
||||
|
||||
|Opérateur|Explication|
|
||||
|-|-|
|
||||
|`+`|Addition|
|
||||
|`-`|Soustraction|
|
||||
|`*`|Multiplication|
|
||||
|`/`|Division|
|
||||
|`//`|Division entière (renvoie un quotient entier)|
|
||||
|`%`|Modulo (renvoie le reste de la division euclidienne)|
|
||||
|`**`|Puissance|
|
||||
|
||||
- Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
|
||||
```
|
||||
|
||||
```admonish travail
|
||||
2. Dans l'invite de commande, essayez d'effectuer les opérations suivantes. Notez les expressions utilisées et leur résultat.
|
||||
1. Dans l'invite de commande, essayez d'effectuer les opérations suivantes. Notez les expressions utilisées et leur résultat.
|
||||
- 4 plus 7
|
||||
- 3 moins 12
|
||||
- 6 fois 7
|
||||
- 9 divisé par 2
|
||||
- 4,2 plus 1,5
|
||||
- 5 modulo 2
|
||||
- le quotient de la division euclidienne de 5 par 2
|
||||
- le quotient de la division euclidienne de 9 par 2
|
||||
- 2 puissance 10
|
||||
- 37 fois la somme de 13 et 24
|
||||
|
||||
3. Divisez 10 par 3. Que remarquez-vous ?
|
||||
```
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : il écrira `4.5` et non pas `4,5`. Il en va de même lorsque vous écrirez des nombres en Python.
|
||||
- Les symboles `+`, `-`, `*`, `/`... sont appelés **opérateurs** en Python
|
||||
- L'opérateur modulo `%` est souvent utilisé pour savoir si un nombre est multiple d'un autre. Il vaut mieux s'en souvenir. Il permet de calculer le reste de la division euclidienne de deux nombres. Par exemple si on divise 5 par 2 on obtient 2 et il reste 1. 1 est donc notre reste et `5 % 2` nous donnera 1.
|
||||
- Si l'on veut effectuer la division euclidiuenne d'un nombre par un autre, on peut le faire avec l'opérateur `//` qui est différent de `/`. Par exemple `5//2` nous donnera 2, alors que `5/2` nous donnera `2.5`
|
||||
- Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
|
||||
```
|
||||
|
||||
Nous allons maintenant travailler avec le module `math`. Dans l'invite de commande, écrivez :
|
||||
|
||||
~~~python
|
||||
>>> import math
|
||||
~~~
|
||||
|
||||
Nous pouvous ensuite appeler tout un tas de nouvelles fonctions liées aux mathématiques. Par exemple, si nous voulons la racine carré de 2 ('racine carrée' c'est 'square root' en anglais), nous pouvons écrire :
|
||||
```python
|
||||
>>> math.sqrt(2)
|
||||
1.4142135623730951
|
||||
```
|
||||
|
||||
Explication :
|
||||
- On appelle la fonction `sqrt` en la précédant du nom du module `math`, séparés par un point
|
||||
- Les parenthèses servent à donner les **arguments** à la fonction, ici `2` car nous voulons calculer la racine carrée de 2.
|
||||
- Python nous donne ensuite le résultat : `1.4142135623730951`
|
||||
|
||||
```admonish travail
|
||||
En utilisant la [documentation du module `math`](https://docs.python.org/3/library/math.html)
|
||||
|
||||
1. Donnez les expressions qui permettront de calculer :
|
||||
- la racine carrée de 81
|
||||
- la valeur absolue de -12 (celle-ci n'est pas dans `math` mais existe par défaut)
|
||||
- la valeur de $\pi$
|
||||
- le cosinus de $\pi$
|
||||
- la partie entière de 3.56
|
||||
2. Expliquez la différence entre les fonctions `math.floor()` et `math.ceil()`
|
||||
```
|
||||
|
||||
### 2.2 - Variables
|
||||
### 2.2 - Variables - 30 minutes
|
||||
|
||||
Que sont les variables ? C'est la base de tout programme informatique : elles vous permettent de stocker une information (un nombre, le résultat d'un calcul, une phrase sous forme de chaîne de caractères...) pour la réutiliser plus tard.
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Les variables sont une donnée de votre programme stockée dans l'ordinateur.
|
||||
- Elles sont nommées et on peut les **affecter** en écrivant `ma_variable = <contenu de ma variable>` (attention la variable est toujours à gauche, le contenu toujours à droite). Affecter signifie mettre un contenu dans la variable.
|
||||
|
||||
- Les noms des variables peuvent comporter:
|
||||
- Des caratères **alphanumériques**, c'est à dire des lettres minuscules ou majuscules et des chiffres
|
||||
- Des `_` (tiret du bas, sur la touche <kbd>8</kbd> de votre clavier)
|
||||
|
|
@ -159,22 +138,24 @@ Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vo
|
|||
>>> prix_ttc
|
||||
~~~
|
||||
|
||||
1. Modifiez la valeur de `tva` pour qu'elle prenne la valeur de 20%. Quelle valeur a `prix_ttc` ? Pourquoi ?
|
||||
1. Affectez une nouvelle valeur à `tva` pour qu'elle prenne la valeur de 20%. Quelle valeur a `prix_ttc` ? Pourquoi ?
|
||||
|
||||
1. Recalculez la valeur de `prix_ttc` pour prendre en compte la modification de `tva` (Astuce: vous pouvez utiliser <kbd>↑</kbd> pour retrouver la ligne déjà tapée). Donnez la ligne que vous avez réexécutée.
|
||||
|
||||
1. Donnez l’expression qui permet d’évaluer le prix à payer par le client lorsqu’on lui accorde une réduction de 5% sur le prix **hors taxes**.
|
||||
1. On veut accorder une réduction de 5% sur le prix hors taxe à un client. Redonnez l'expression pour calculer le nouveau `prix_ttc` en tenant compte de la réduction.
|
||||
|
||||
1. Donnez l'expression qui permet d'augmenter la TVA de 1%, quel que soit sont taux actuel.
|
||||
1. On veut augmenter la TVA de 1% sans avoir besoin de connaître son taux actuel. Ecrivez l'expression qui permet de le faire.
|
||||
```
|
||||
|
||||
### 2.3 - Types
|
||||
### 2.3 - Types - 15 minutes
|
||||
|
||||
Les variables peuvent contenir differents types de données. Nous avons surtout vu des nombres jusqu'à maintenant, mais elles peuvent aussi contenir des **chaînes de caractères** ou d'autres types plus complexes. Nous verrons dans un premier temps les plus simples.
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Python est capable de trouver le type d'une donnée tout seul, et cette variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
|
||||
- Python possède une fonction `type` qui permet d'afficher le type de chaque variable.
|
||||
- Certains types peuvent être **convertis** en d'autres, selon certaines conditions. On peut pour cela utiliser le type comme une fonction.
|
||||
- Si on veut convertir l'entier 3 (de type `int`) en `str`, on peut utiliser l'expression suivante : `str(3)` qui renverra `'3'`
|
||||
```
|
||||
|
||||
```admonish travail
|
||||
|
|
@ -183,7 +164,6 @@ Les variables peuvent contenir differents types de données. Nous avons surtout
|
|||
- 3.14
|
||||
- True
|
||||
- "<votre prénom>"
|
||||
- '85' (attention aux guillemets)
|
||||
1. Donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age` en utilisant la fonction `str` et l'entier `21`
|
||||
```
|
||||
|
||||
|
|
@ -204,7 +184,7 @@ Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et in
|
|||
- `'Elle a dit "Hello"'`
|
||||
```
|
||||
|
||||
### 2.4 - Print et input
|
||||
### 2.4 - Print et input - 15 minutes
|
||||
|
||||
Pour la suite nous allons commencer à utiliser le fichier `main.py` créé au début de ce TP. Ouvrez-le dans VSCode.
|
||||
|
||||
|
|
@ -212,12 +192,6 @@ Pour la suite nous allons commencer à utiliser le fichier `main.py` créé au d
|
|||
Un fichier contenant du code Python s'appelle un **script**. Les scripts python ont un nom se finissant par l'**extension** `.py`
|
||||
```
|
||||
|
||||
```admonish travail
|
||||
1. Écrivez un script permettant d'afficher le texte `Hello, World!` grâce à la fonction `print`
|
||||
2. Écrivez un script permettant de demander à l'utilisateurice d'entrer son âge et le stocker dans une variable. Attention, la variable devra être de type `int`.
|
||||
3. En utilisant une **chaîne de caractères formatée**, complétez le script pour afficher la phrase suivante : `Votre nom est <votre nom> et vous avez <votre âge> ans.`
|
||||
```
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- La fonction `print` permet d'afficher des chaînes de caractères et/ou des variables.
|
||||
- Elle peut prendre plusieurs arguments, et affichera les arguments séparés par un espace
|
||||
|
|
@ -225,26 +199,21 @@ Un fichier contenant du code Python s'appelle un **script**. Les scripts python
|
|||
- Elle prend en argument optionnel une chaîne de caractère qui s'affichera avant la saisie
|
||||
- Elle renvoie ce qui a été saisi sous forme d'une chaîne de caractères. Il faut donc penser à convertir si vous avez besoin d'un autre type.
|
||||
- Le résultat de la fonction peut être immédiatement affecté à une variable.
|
||||
|
||||
- Les chaînes de caratères peuvent être **formatées** : on l'écrira sous la forme `f"chaine de caractère {variable}"`, ce qui permettra de remplacer les variables entre accolades `{}` par leur valeur dans la chaîne de caractères. Le `f` avant les guillemets est important car il permet de dire à Python que la chaîne est formatée. Si vous l'oubliez, il ne cherchera pas à remplacer les variables par leur valeur.
|
||||
|
||||
Les chaînes formatées sont très utilisées en python. Elles servent à afficher des informations dynamiques en fonction de variables, mais vous aideront aussi à comprendre ce que font vos programmes et vous aider à les corriger.
|
||||
```
|
||||
|
||||
```admonish travail
|
||||
1. Écrivez un script permettant d'afficher le texte `Hello, World!` grâce à la fonction `print`
|
||||
2. Écrivez un script permettant de demander à l'utilisateurice d'entrer son âge et le stocker dans une variable. Attention, la variable devra être de type `int`.
|
||||
3. En utilisant une **chaîne de caractères formatée**, complétez le script pour afficher la phrase suivante : `Votre nom est <votre nom> et vous avez <votre âge> ans.`
|
||||
```
|
||||
|
||||
## 3 - Structures conditionnelles
|
||||
|
||||
### 3.1 - Opérateurs de comparaison et booléens
|
||||
|
||||
```admonish travail
|
||||
1. Déclarez les variables suivantes : `a = 1`, `b = 3` et `c = 4` et donnez les expressions et les résultats des opérations suivantes
|
||||
- a strictement supérieur à b
|
||||
- b égal à '3' (attention aux guillemets)
|
||||
- c inférieur ou égal à 5
|
||||
- b compris entre a et c
|
||||
- a différent de 1
|
||||
- a et b différents de c
|
||||
- a égal c ou b égal à 3
|
||||
- l'inverse de c égal à 5
|
||||
```
|
||||
### 3.1 - Opérateurs de comparaison et booléens - 20 minutes
|
||||
|
||||
```admonish success title='À retenir'
|
||||
Nous avons vu dans l'activité précédente les opérateurs `==`, `<` et `>`. On les appelle les **opérateurs de comparaison**. Il en existe d'autres :
|
||||
|
|
@ -259,8 +228,9 @@ Nous avons vu dans l'activité précédente les opérateurs `==`, `<` et `>`. On
|
|||
|`>=`| Supérieur ou égal à|
|
||||
|
||||
Attention, l'opérateur d'égalité est bien `==`, et non pas `=`. Utiliser l'opérateur d'affectation `=` pourra produire un code qui s'exécute, mais n'aura pas le résultat que vous attendez.
|
||||
```
|
||||
|
||||
|
||||
```admonish success title='À retenir'
|
||||
Les **opérateurs booléens** servent à faire des opérations avec des types `bool` ou pour créer des conditions plus complexes.
|
||||
|
||||
|Opérateur| Description|
|
||||
|
|
@ -280,7 +250,15 @@ Les nombres (et plein d'autres types) peuvent être considérés comme `True` ou
|
|||
Les opérateurs `>`, `<`, `>=`, `<=` peuvent être chaînés pour faire des comparaisons d'intervalles. Par exemple, pour vérifier que la variable a est comprise entre 0 et 100, vous pouvez écrire '0 < a < 100'
|
||||
```
|
||||
|
||||
### 3.2 - Les conditions
|
||||
```admonish travail
|
||||
1. Déclarez les variables suivantes : `a = 1`, `b = 3` et `c = 4` et donnez les expressions et les résultats des opérations suivantes
|
||||
- a strictement supérieur à b
|
||||
- b égal à '3' (attention aux guillemets)
|
||||
- b compris entre a et c
|
||||
- a et b différents de c
|
||||
```
|
||||
|
||||
### 3.2 - Les conditions - 30-45 minutes
|
||||
|
||||
```admonish success title='À retenir'
|
||||
Les **structures conditionnelles** ressemblent à ceci :
|
||||
|
|
@ -333,7 +311,7 @@ Si on pose les choses de manière structurée :
|
|||
Les termes du problème sont bien posés, prenez le temps d'y réfléchir et de bien comprendre. Un fois que vous pensez avoir bien compris, vous pouvez passer à la suite.
|
||||
|
||||
```admonish travail
|
||||
1. Commencez par dessiner un schéma permettant de bien distinguer toutes les possibilités, sous forme d'arbre, chaque embranchement représentant une condition. L'important à ce stade est de bien cerner le problème.
|
||||
1. Commencez par dessiner un schéma au brouillon permettant de bien distinguer toutes les possibilités, sous forme d'arbre, chaque embranchement représentant une condition. L'important à ce stade est de bien cerner le problème.
|
||||
1. Créez un nouveau script appelé `tp01-bissextile.py`
|
||||
1. Écrivez le code vous permettant de demander à l'utilisateurice de saisir une année, et de la stocker dans une variable. N'oubliez pas de convertir en entier votre année.
|
||||
1. Ensuite, écrivez la première condition, la plus simple pour vérifier si votre nombre est un multiple de 4 ou non. Nous ne tenons pas compte tout de suite des multiples de 100 et 400. Écrivez dans chaque branche votre `print` pour dire si l'année est bissextile ou non.
|
||||
|
|
@ -359,17 +337,7 @@ Quelques années, selon les critères :
|
|||
|1900|oui|oui|non|non|
|
||||
|2000|oui|oui|oui|oui|
|
||||
|
||||
## 4 - Structures répétitives : `for` et `while`
|
||||
|
||||
```admonish travail
|
||||
1. Donnez le code permettant d'afficher la table de multiplication par 7 en allant de 1 à 10. Utilisez une boucle `while`.
|
||||
2. Donnez le code permettant d'afficher la même table mais en utilisant cette fois une boucle `for`
|
||||
```
|
||||
|
||||
```admonish help title='Aide'
|
||||
Vous pouvez utiliser la fonction `range`, qui permet de renvoyer un **générateur** (sorte de liste dynamique) de séquence de nombres dans un intervalle. Ex: `range(1, 6)` renverra tour à tour les nombres de 1 à 5 (le dernier nombre de l'intervalle est exclu).
|
||||
```
|
||||
|
||||
## 4 - Structures répétitives : `for` et `while` - 30 minutes
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Les boucles permettent de répéter des instructions plusieurs fois.
|
||||
|
|
@ -396,91 +364,54 @@ Vous pouvez utiliser la fonction `range`, qui permet de renvoyer un **générate
|
|||
- Attention au `:` et à l'indentation
|
||||
```
|
||||
|
||||
## 5 - Fonctions
|
||||
```admonish travail
|
||||
1. Donnez le code permettant d'afficher la table de multiplication par 7 en allant de 1 à 10. Utilisez une boucle `while` et une chaîne formatée.
|
||||
2. Donnez le code permettant d'afficher la même table mais en utilisant cette fois une boucle `for`.
|
||||
|
||||
Vous connaissez déjà certaines fonctions, celles que vous avez utilisées lors du précédent TP : `print`, `input`, `math.sqrt`, `range` ... Ce sont des fonctions que vous avez **appelées** mais qui existent déjà, soit par défaut dans le langage Python, soit dans une bibliothèque (`math`).
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- Les fonction s'utilisent avec la syntaxe suivante : `nom_de_la_fonction(parametre_1, parametre_2, ...., parametre_n)`
|
||||
- Vous mettez le nom de la fonction, suivi de parenthèses
|
||||
- Entre les parenthèses vous mettez les paramètres séparés par des virgules
|
||||
- Si une fonction n'a pas besoin de paramètres, les parenthèses sont quand même indispensables
|
||||
|
||||
- Certaines fonctions peuvent prendre des paramètres nommés, avec la syntaxe suivante : `nom_de_la_fonction(nom_parametre=valeur_parametre)`. Les paramètres nommés sont toujours à la fin et leur ordre n'a pas d'importance.
|
||||
|
||||
- Une fonction peut renvoyer un résultat, que l'on peut alors affecter à une variable.
|
||||
- Si une fonction ne renvoie rien, alors elle renverra en réalité la valeur spéciale `None`.
|
||||
Résultat attendu :
|
||||
~~~
|
||||
0 * 7 = 0
|
||||
1 * 7 = 7
|
||||
2 * 7 = 14
|
||||
3 * 7 = 21
|
||||
4 * 7 = 28
|
||||
5 * 7 = 35
|
||||
6 * 7 = 42
|
||||
7 * 7 = 49
|
||||
8 * 7 = 56
|
||||
9 * 7 = 63
|
||||
10 * 7 = 70
|
||||
~~~
|
||||
```
|
||||
|
||||
Nous allons maintenant créer une fonction par nous-mêmes à partir du code de la partie précédente, permettant d'afficher la table de multiplication par 7.
|
||||
```admonish help title='Aide'
|
||||
Vous pouvez utiliser la fonction `range`, qui permet de renvoyer un **générateur** (sorte de liste dynamique) de séquence de nombres dans un intervalle. Ex: `range(1, 6)` renverra tour à tour les nombres de 1 à 5 (le dernier nombre de l'intervalle est exclu).
|
||||
```
|
||||
|
||||
## Bonus - Le jeu du plus ou moins
|
||||
|
||||
Nous allons maintenant réaliser un petit jeu où la personne qui y joue doit deviner un nombre entre 1 et 100 choisi aléatoirement par l'ordinateur. L'ordinateur renvoie l'information "Plus" quand le nombre qu'il a choisi est plus grand que celui saisi, et "Moins" dans l'autre cas.
|
||||
|
||||
Pour que l'ordinateur vous fournisse un nombre aléatoire, vous pouvez utiliser le code suivant :
|
||||
```python
|
||||
import random # On importe le module random
|
||||
|
||||
random.seed() # On initialise la génération de nombres aléatoires
|
||||
nombre_aleatoire = random.randint(1,100) # On récupère le nombre
|
||||
```
|
||||
```admonish note
|
||||
Les portions de code qui se trouvent après des `#` en python sont considérées comme des **commentaires**, c'est à dire du texte que la personne ayant écrit le code a mis pour aider les personnes lisant le code. Ce qui se trouve en commentaire est totalement ignoré par Python.
|
||||
```
|
||||
|
||||
```admonish travail
|
||||
1. Modifiez votre code pour mettre le calcul et l'affichage de la table de 7 dans une fonction `table`. Appelez cette fonction à la fin de votre script.
|
||||
1. Bon, maintenant nous avons une fonction qui fait la même chose qu'avant. Mais si on veut calculer la table par 5 ou 8, il nous faudrait pouvoir passer la table en paramètre. Modifiez votre code pour prendre en paramètre la table à afficher. Modifiez l'appel en conséquence et vérifiez que ça marche si vous passez 5 ou 8 par exemple.
|
||||
1. Ajoutez un nouveau paramètre `maximum` qui servira à déterminer le nombre de lignes à afficher. Par exemple, si `nb` vaut 5 et `maximum` vaut 20, on affichera la table de 5 avec les valeurs de 1 à 20.
|
||||
|
||||
Modifiez les appels à votre fonction en conséquence et vérifiez que tout fonctionne comme prévu.
|
||||
1. Créez un nouveau script appelé `tp01-plus-ou-moins.py`
|
||||
1. Écrivez le code permettant à l'ordinateur de générer le nombre aléatoire. Affichez-le pour vérifier que cela fonctionne.
|
||||
1. Écrivez le code permettant de demander à la personne qui joue d'entrer un nombre. N'oubliez pas les conversions
|
||||
1. Écrivez le code permettant de comparer les deux nombres et afficher "Plus", "Moins" ou "Gagné !" selon les cas. Mettez le code de votre programme à ce stade dans le compte rendu.
|
||||
1. Il faut maintenant boucler pour laisser plusieurs chances à l'utilisateur sans devoir relancer le programme à chaque fois. Écrivez une première version de votre boucle avec `while`.
|
||||
La boucle devra demander de saisir un nombre, le comparer, et afficher le texte. Si l'utilisateur a trouvé le bon nombre, le programme doit afficher "Gagné !" et s'arrêter tout seul. En revanche, le nombre aléatoire ne devra être choisi qu'une seule fois, faites donc attention.
|
||||
|
||||
6. Dans la majorité des cas on voudra probablement afficher la table jusqu'à 10. Pour nous éviter de devoir préciser `maximum` à chaque fois, nous allons mettre une valeur par défaut à `maximum` pour que la fonction affiche les 10 premières lignes si le paramètre n'est pas précisé.
|
||||
|
||||
Exécutez votre fonction avec `table(5, 20)` puis `table(7)` et vérifiez que nous avons bien la table par 5 de 1 à 20 dans le premier cas, et la table par 7 de 1 à 10 dans le second
|
||||
|
||||
7. Copiez le code suivant à la suite de votre fichier, puis exécutez-le. Quelle est la dernière ligne qui s'affiche ? À votre avis pourquoi ?
|
||||
~~~python
|
||||
def exemple():
|
||||
print("Ma première fonction d'exemple")
|
||||
|
||||
def exemple():
|
||||
print("Ma deuxième fonction d'exemple")
|
||||
|
||||
exemple()
|
||||
~~~
|
||||
|
||||
8. Créez une fonction `aire_carre` permettant de retourner l'aire d'un carré de côté passé en paramètre. Exécutez la fonction et affichez son résultat avec `print`
|
||||
|
||||
1. Modifiez la fonction pour retourner à la fois l'aire d'un carré et le périmètre d'un carré. Appelez la fonction, stockez les deux résultats dans deux variables
|
||||
|
||||
1. Expérimentez pour répondre aux questions suivantes. Donnez le code utilisé à chaque fois.
|
||||
1. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
|
||||
1. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
|
||||
1. Que retourne une fonction qui n'a pas d'instruction `return` ?
|
||||
```
|
||||
|
||||
```admonish success title='À retenir'
|
||||
- Les fonctions servent à rendre votre code plus clair et mieux découpé. Elles permettent de réutiliser du code.
|
||||
- Pour déclarer une fonction en python :
|
||||
~~~python
|
||||
def nom_de_la_fonction(parametre_1, parametre_2, ..., parametre_n):
|
||||
# Instructions
|
||||
~~~
|
||||
- On utilise le mot-clé `def` suivi du nom de la fonction.
|
||||
- Entre parenthèses on ajoute les paramètres qu'il faudra fournir
|
||||
- À la fin de la ligne on met `:` (encore et toujours)
|
||||
- On passe à la ligne suivante et on indente pour écrire les instructions.
|
||||
- Les paramètres fonctionnent comme des variables : on peut les utiliser dans la fonction avec leur nom.
|
||||
- On peut définir une valeur par défaut à un paramètre : il suffit d'écrire `parametre=valeur_par_defaut` lors de la déclaration. On peut alors omettre le paramètre, qui prendra automatiquement la valeur par défaut.
|
||||
- Deux fonctions ne peuvent pas avoir le même nom, sinon, la dernière a avoir été déclarée écrase la précédente.
|
||||
```
|
||||
|
||||
```admonish success title="À retenir"
|
||||
- L'instruction `return` permet de sortir immédiatement d'une fonction. Rien ne s'exécutera après le `return`
|
||||
- `return` permet de retourner un résultat, avec la syntaxe `return valeur`. Si aucune valeur n'est mentionnée, elle retournera `None`
|
||||
- Si `return` n'est pas mentionnée, la fonction s'exécute jusqu'au bout et sortira à la fin du bloc d'instructions en retournant `None`
|
||||
- On peut retourner plusieurs valeurs en les séparant par une virgule.
|
||||
- Ces valeurs peuvent être affectées à une seule variable sous forme d'un **tuple** (nous en parlerons au prochain TP)
|
||||
- Chaque valeur peut être affectée à une variable différente avec la syntaxe `variable_1, variable_2 ... = nom_de_la_fonction(...)`.
|
||||
```
|
||||
|
||||
```admonish tip title='Bonnes pratiques'
|
||||
- Faites des fonctions courtes qui vont à l'essentiel (20 lignes est un bon maximum)
|
||||
- Choisissez bien les noms de vos fonctions et de vos paramètres pour qu'ils soient clairs et explicites
|
||||
- Vous pouvez documenter vos fonctions à l'aide d'une **docstring** : après l'en-tête de la fonction, avant le bloc d'instructions vous pouvez écrire une chaîne de caractères qui commence par 3 `"` ou `'`.
|
||||
Exemple:
|
||||
~~~python
|
||||
def ma_fonction(arg_1, arg2):
|
||||
"""Ceci est une docstring qui vient documenter ma fonction.
|
||||
Une docstring peut prendre plusieurs lignes.
|
||||
"""
|
||||
# Bloc d'instructions
|
||||
~~~
|
||||
```
|
||||
Mettez le code de votre programme à ce stade dans le compte rendu.
|
||||
1. Ecrivez une nouvelle version de votre boucle, en utilisant `for` cette fois. L'utilisateur aura maximum 10 essais, et s'il dépasse le jeu affichera "Perdu !" avant de s'arrêter.
|
||||
Mettez le code final de votre programme dans le compte rendu.
|
||||
```
|
||||
|
|
@ -20,6 +20,7 @@
|
|||
- [Une application web complète avec Python](./CIEL1/07-appli-web/appli-web.md)
|
||||
- [BTS CIEL - 2e année](./CIEL2/ciel2.md)
|
||||
- [Révisions Python](./CIEL2/01-revisions-python/python-revisions.md)
|
||||
- [Cours](./CIEL2/01-revisions-python/cours/python-bases.md)
|
||||
- [TP1 - Bases de Python](./CIEL2/01-revisions-python/tp/tp1_bases.md)
|
||||
- [TP1b - Mise en pratique](./CIEL2/01-revisions-python/tp/tp1bis_mise_en_pratique.md)
|
||||
- [Python objet](./CIEL2/02-python-objet/python-objet.md)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue