Skip to content
Snippets Groups Projects
Commit af1c7d74 authored by mathieu.schiess@edu.ge.ch's avatar mathieu.schiess@edu.ge.ch
Browse files

ajout de 2 corrige

parent efc6cb57
No related branches found
No related tags found
No related merge requests found
%% Cell type:markdown id: tags:
<div style="padding:20px;background-color:papayawhip;" >
<h3 style="color:chocolate"> <i class="fa fa-info" aria-hidden="true"> </i> &nbsp; Remarque introductive &nbsp; <i class="fa fa-info" aria-hidden="true"></h3>
<p> Ce fichier est fait pour être lu sur le site <a href="https://notebook.basthon.fr/"><img src='https://notebook.basthon.fr/assets/efede5218c9087496f16.png' style="border: 0; display:inline; margin: 0 5px; height:30px" alt="Basthon"/></a>. <br>
Si vous l'avez ouvert avec un autre programme, comme Jupyter notebook, vous riquez de rencontrer quelques bugs. <br>
Veuillez cliquez sur <a href="https://notebook.basthon.fr/">ce lien</a> et y charger ce fichier à l'aide du bouton "Ouvrir" &nbsp; <i class="fa fa-folder" aria-hidden="true"> </i>
</p>
</div>
%% Cell type:markdown id: tags:
# 5.2 Les variables, Types et entrée-sortie
%% Cell type:markdown id: tags:
## Types de Données
Python est un langage à typage dynamique, ce qui signifie que vous n'avez pas besoin de spécifier le type de données d'une variable lorsque vous la créez.
<blockquote class="alert alert-info" style="background-color:rgb(220,240,255); margin:10px 10%;">
<p><span style="font-size:1.5em"></span> C'est quoi le type d'une variable ? Exécutez la cellule ci-dessous pour voir une petite introduction sur la notion de type d'une variable</p>
</blockquote>
<iframe width="560" height="315" src="https://www.youtube.com/embed/5zA8_3YDXb4?si=3V95fi6wa24ddwW_" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
### Principaux types de données en Python
- `int` : pour les nombres entiers
- `float` : pour les nombres à virgule flottante
- `str` : pour les chaînes de caractères
- `bool` : pour les valeurs booléennes (True ou False)
```python
# Exemple de différents types de données
entier = 10
chaine = "Bonjour"
flottant = 12.85
booleen = True
%% Cell type:markdown id: tags:
<h3 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-question" aria-hidden="true"> </i> &nbsp; Quizz </h3>
Que stocke la variable `pi` dans le code suivant ?
```python
pi = 3.14159
```
<ol style="list-style-type: upper-alpha">
<li>Une chaîne de caractères</li>
<li>Un entier</li>
<li>Un nombre à virgule flottante</li>
<li>Une valeur booléenne</li>
</ol>
%% Cell type:raw id: tags:
Ma réponse:
%% Cell type:markdown id: tags:
<details>
<summary style="border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8">
Solution
</summary>
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">
C. Un nombre à virgule flottante
</div>
</details>
%% Cell type:markdown id: tags:
<h3 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-question" aria-hidden="true"> </i> &nbsp; Question </h3>
```
En informatique, `int` est l'abréviation pour
A) international
B) entier
C) interne
D) intelligent
```
</div>
%% Cell type:raw id: tags:
Ma réponse:
%% Cell type:markdown id: tags:
<details>
<summary style="border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8">
Solution
</summary>
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">
B) entier
</div>
</details>
%% Cell type:markdown id: tags:
<h3 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-question" aria-hidden="true"> </i> &nbsp; Question </h3>
Indiquez le type des variables (entier, flottant ou chaîne de caractères) permettant de stocker sur votre smartphone les informations suivantes :
- le nom d’un contact
- le numéro de téléphone d’un contact
- un SMS
- le prix d'un croissant
- le code de votre partage de connexion Wi-Fi
- le pourcentage _affiché_ de batterie restante
- ma note à la dernière épreuves de Mathématiques
</div>
%% Cell type:raw id: tags:
Mes réponses :
- le nom d’un contact :
- le numéro de téléphone d’un contact :
- un SMS :
- le prix d'un croissant :
- le code de votre partage de connexion Wi-Fi :
- le pourcentage affiché de batterie restante :
- ma note à la dernière épreuves de Mathématiques :
%% Cell type:markdown id: tags:
<details>
<summary style="border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8">
Solutions
</summary>
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">
- le nom d’un contact : Une chaîne de caractères
- le numéro de téléphone d’un contact : Une entier
- un SMS : Une chaîne de caractères
- le prix d'un croissant : Un nombre à virgule flottante
- le code de votre partage de connexion Wi-Fi : Une chaîne de caractères
- le pourcentage affiché de batterie restante : Une entier
- ma note à la dernière épreuves de Mathématiques : Un nombre à virgule flottante
</div>
</details>
%% Cell type:markdown id: tags:
## Demander à l'utilisateur d'entrer une valeur : `input`
La fonction `input('question')` permet de demander une entrée (input) à l'utilisateur.
L'utilisateur voit le texte `question` affiché à la console et doit répondre à cette question. Il termine son entrée avec la touche Enter.
La réponse de l'utilisateur est ensuite mémorisée dans une variable que nous appelons `x` dans cet exemple.
Ensuite, nous pouvons utiliser cette variable `x` dans la suite du programme, par exemple comme argument dans une fonction `print()`.
%% Cell type:code id: tags:
``` python
x = input('Entrez votre nom: ')
print('Bonjour', x)
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 1 </h3>
Ajoutez une troisième question et utilisez la réponse dans un `print()`.
%% Cell type:code id: tags:
``` python
nom = input('Entrez votre nom: ')
print('Bonjour', nom)
age = input('Entrez votre âge: ')
print('Très bien', nom, 'vous avez', age, 'ans')
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 2 </h3>
Ecrire un code qui demande à l’utilisateur son prénom dans une première question puis qui demande dans une deuxième question son nom de famille et qui écrit ensuite:<br>
`"Bienvenue Prénom Nom"`
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
## Demander un nombre
La fonction `input()` permet d'obtenir une entrée de l'utilisateur. Mais attention !
La valeur retournée est une chaine de caractères (de type string `str`). Nous pouvons le prouver avec la fonction `type()`.
%% Cell type:code id: tags:
``` python
x = input('Entrez un nombre: ')
print(type(x))
```
%% Cell type:markdown id: tags:
<div class="alert alert-block alert-info">
<b>&#9889; A retenir : </b> <br>
Une variable entrée au clavier par un <i>input</i> est toujours du type <i>str</i> c'est à dire considéré comme une chaine de caractères.
</ul>
</div>
%% Cell type:markdown id: tags:
Pour pouvoir utiliser cette valeur dans un calcul, nous devons la transformer en nombre. Pour convertir une chaine de caractères en un nombre à virgule flottante nous utilisons la fonction de conversion `float()`.
%% Cell type:code id: tags:
``` python
x = '1.5'
print(type(x)) # la variable x contient une chaîne
print(type(float(x))) # la fonction float(x) renvoie un nombre
```
%% Cell type:markdown id: tags:
### Exemple
On souhaite avoir un programme qui permet de calculer la moyenne de deux nombres qui sont fournis par l'utilisateur. Tester la proposition de programme suivante:
%% Cell type:code id: tags:
``` python
#Demande à l'utilisateur deux nombres puis calcule et affiche leur somme
nombre1 = input("Taper un premier nombre : ")
nombre2 = input("Taper un deuxième nombre : ")
moyenne = (nombre1 + nombre2)/2
print("La somme de ces deux nombres est ",moyenne)
```
%% Cell type:markdown id: tags:
On comprend le problème : pour python `nombre1` et `nombre2` sont en fait des chaines de caractères par conséquent, calculer leur moyenne n'a pas de sens !
Pour résoudre ce problème nous devons convertir `nombre1` et `nombre2` en nombre à virgule, cela se fait grâce à l'instruction `float`. Voici le programme corrigé :
%% Cell type:code id: tags:
``` python
#Demande à l'utilisateur deux nombres puis calcule et affiche leur somme
nombre1 = float(input("Taper un premier nombre : ")) #float() permet de convertir la valeur entrée en flottant
nombre2 = float(input("Taper un deuxième nombre : "))
moyenne = (nombre1 + nombre2)/2
print("La moyenne de ces deux nombres est ",moyenne)
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 3</h3>Complétez le programme pour afficher la surface du cercle.
%% Cell type:code id: tags:
``` python
print('Circle')
r = float(input('Entrez le rayon: '))
pi = 3.14
print()
print('rayon =', r)
print('diamètre =', 2 * r)
print('circonférence =', pi * 2 * r)
print('surface =', ...)
```
%% Cell type:markdown id: tags:
Nous pouvons également créer des programmes où nous demandons plusieurs valeurs à l'utilisateur. Cette fois, nous permettons seulement l'utilisation de nombres entiers, et donc transformons la chaine obtenue avec `int()` en nombre entier.
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 4 </h3>
Complétez le programme pour afficher le périmètre et la diagonale.
%% Cell type:code id: tags:
``` python
from math import sqrt
print('Rectangle')
a = float(input('Entrez la largeur: '))
b = float(input('Entrez la longueur: '))
print('surface =', a * b)
print('périmètre =', ...)
print('diagonale =', ...)
```
%% Output
Rectangle
Entrez la largeur: 7
Entrez la longueur: 0
surface = 0.0
périmètre = Ellipsis
diagonale = Ellipsis
%% Cell type:markdown id: tags:
!!! info utiliser des fonctions mathématiques comme la fonction racine carrée $\sqrt{x}$.
Pour calculer la racine carrée d'un nombre $\sqrt{x}$, il faut utiliser la fonction `sqrt` du module `math`. Pour ce faire, votre programme doit commencer par `from math import sqrt` (pour importer la fonction `sqrt` du module `math`). Pour l'utiliser, il suffit de mettre la valeur dont on veut trouver la racine en argument de la fonction `sqrt`. Par exemple, l'instruction `print(sqrt(25))` affichera 5.
!!!
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 5 </h3>
Chacun des programmes suivants devrait demander à l’utilisateur deux nombres, et écrire le produit de ces deux nombres mais il contient au moins une erreur. Corrigez chacun des programmes puis testez les.
**Programme A**
%% Cell type:code id: tags:
``` python
int(input("premier nombre: "))
int(input("deuxième nombre: "))
print(premier*deuxième)
```
%% Cell type:markdown id: tags:
**Programme B**
%% Cell type:code id: tags:
``` python
x=input("premier nombre: ")
y=input("deuxième nombre: ")
x*y
```
%% Cell type:markdown id: tags:
**Programme C**
%% Cell type:code id: tags:
``` python
x=int("premier nombre : ")
y=int("deuxième nombre: ")
z=x*y
print("z")
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 6 </h3>
Complétez le programme Python ci-dessous qui calcule la surface d'un rectangle après avoir demandé sa largeur et sa longueur.
Indication: Il faut remplacer les `_____` par ce qu'il convient
%% Cell type:code id: tags:
``` python
# Programme pour calculer la surface d'un rectangle à partir de sa longueur et de sa largeur
longueur = _____(input("Entrer la longueur du rectangle : ")) #longueur doit être un flottant utiliser la conversion !
largeur = _____(_____("Entrer la largeur du rectangle : "))
surface = _______*_________
_____("La surface du rectangle est :",___________)
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 7 </h3>
Chacun des programmes devrait demander à l’utilisateur un nombre `n`, et écrire les n premiers multiples de 100. Corriger les erreurs de chaque programme afin qu’il fonctionne.
**Programme A**
%% Cell type:code id: tags:
``` python
n = int(input("Nombre de multiples: "))
for _ in range(n):
print(x)
x+100
```
%% Cell type:markdown id: tags:
**Programme B**
%% Cell type:code id: tags:
``` python
x = int(input("Nombre de multiples: "))
n = 100
for _ in range(x):
print(x)
x = x+100
```
%% Cell type:markdown id: tags:
**Programme C**
%% Cell type:code id: tags:
``` python
x = int(input("Nombre de multiples: "))
n = 100
for _ in range(x):
print(n)
n = n+n
```
%% Cell type:markdown id: tags:
**Programme D**
%% Cell type:code id: tags:
``` python
x = int(input("Nombre de multiples:"))
for _ in range(x):
n = 100
print(n)
n = n+100
```
%% Cell type:markdown id: tags:
**Programme E**
%% Cell type:code id: tags:
``` python
x=int(input("Nombre de multiples:"))
n = 100
for _ in range (x):
n = n + 100
print(n)
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 8 </h3>
Compléter le programme Python qui demande à l’utilisateur un mot, et un nombre n et qui écrit n fois de suite le mot donné par l’utilisateur.
%% Cell type:code id: tags:
``` python
n = input(...)
mot = input(...)
for #à compléter
#à compléter
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 9 </h3>
On considère le programme suivant:
```python
from turtle import *
n = 10
angle = int(360 / n)
for k in range(n):
forward(100)
right(angle)
done()
```
1. Tester le programme ci-dessus, puis modifiez le en définissant une fonction `polygone(lg, n)` qui permet de tracer des polygones réguliers avec `n` côtés et de longueur `lg`. Le programme doit produire la même figure mais en utilisant la fonction `polygone(lg, n)`.
%% Cell type:code id: tags:
``` python
from turtle import *
n = 10
angle = int(360 / n)
for k in range(n):
forward(100)
right(angle)
done()
```
%% Cell type:markdown id: tags:
2. Modifiez le programme précédant afin d’obtenir un programme qui demande à l’utilisateur⋅trice la taille et le nombre de côtés du polygone régulier puis trace ce polygone.
Exemple d’exécution du programme:
```
Quel est la nombre de côtés de votre polygone : 8
Quel est la taille de votre polygone : 100
Quelle est la taille de votre polygone : 100
```
qui devrait générer un hexagone de côté 100:
%% Cell type:code id: tags:
``` python
# votre programme complet...
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 10 </h3>
Compléter le programme pour avoir un programme qui demande un nombre à l’utilisateur⋅trice et qui dessine un carré ayant cette longueur comme côté.
%% Cell type:code id: tags:
``` python
from turtle import *
n = 10
angle = int(360 / n)
for k in range(n):
forward(100)
right(angle)
# à compléter
done()
```
%% Cell type:markdown id: tags:
# 🟥 Fin
<div class="alert alert-danger" style="border-left:5px solid #a94442;border-radius: 5px;">
- **Ne pas Oublier de sauvegarder son travail.**
- **Pour effectuer** une sauvegarde personnelle du document obtenu :
- utilisez le menu `Fichier / Enregistrer sous…`.
- nomez le fichier `variables1.ipynb`
- choisissez de sauver votre fichier dans `Documents/1IN/Programmation/Les_variables`.
</div>
---
#### Remarque générale
Ce document c'est inspiré des notebook trouvé sur
- Les ressources pédagogiques du catalogue modulo https://modulo-info.ch/.
- Les ressources pédagogiques du [Lycée Mounier](https://info-mounier.fr/snt/python/)
Le notebook est sous license Creative Commons [BY-NC-SA](https://creativecommons.org/licenses/?lang=fr)
![Licence Creative Commons](https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png)
%% Cell type:code id: tags:
``` python
```
......
This diff is collapsed.
%% Cell type:markdown id: tags:
<div style="padding:20px;background-color:papayawhip;" >
<h3 style="color:chocolate"> <i class="fa fa-info" aria-hidden="true"> </i> &nbsp; Remarque introductive &nbsp; <i class="fa fa-info" aria-hidden="true"></h3>
<p> Ce fichier est fait pour être lu sur le site <a href="https://notebook.basthon.fr/"><img src='https://notebook.basthon.fr/assets/efede5218c9087496f16.png' style="border: 0; display:inline; margin: 0 5px; height:30px" alt="Basthon"/></a>. <br>
Si vous l'avez ouvert avec un autre programme, comme Jupyter notebook, vous riquez de rencontrer quelques bugs. <br>
Veuillez cliquez sur <a href="https://notebook.basthon.fr/">ce lien</a> et y charger ce fichier à l'aide du bouton "Ouvrir" &nbsp; <i class="fa fa-folder" aria-hidden="true"> </i>
</p> </div>
%% Cell type:markdown id: tags:
# 6 - Les Conditions, partie 1
Dans ce chapitre, nous allons voir comment un programme peut faire des choix, et comment il peut exécuter du code de façon sélective.
<blockquote class="alert alert-info" style="background-color:rgb(220,240,255); margin:10px 10%;">
<p><span style="font-size:1.5em"></span> C'est quoi une instruction conditionnelle? Exécutez la cellule ci-dessous pour voir une petite introduction sur la notion de type d'instruction conditionnelle</p>
</blockquote>
<iframe width="560" height="315" src="https://www.youtube.com/embed/c0cm031r_eo?si=Apy9aC8a9HoHcHfv" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
%% Cell type:markdown id: tags:
## I) Comparaisons
Un programme doit parfois comparer deux valeurs.
Python connait six types de comparaisons :
- plus petit (`<`),
- plus petit ou égal (`<=`),
- égal (`==`),
- différent (`!=`),
- plus grand (`>`),
- plus grand ou égal (`>=`).
Dans des formules mathématiques nous utilisons les symboles ≤, ≥ et ≠. En Python vous devez utiliser deux symboles: `<=`, `>=` et `!=` à la place.
Le résultat d'une comparaison est une valeur **booléenne**, soit `True` (vrai) soit `False` (faux).
**Remarque** Il est impossible de comparer des données de différentes nature (par exemple une chaîne de caractère avec un nombre)
%% Cell type:markdown id: tags:
<h3 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-question" aria-hidden="true"> </i> &nbsp; Quizz </h3>
Qu'affiche le programme suivant
%% Cell type:code id: tags:
``` python
print("10" > 2)
```
%% Cell type:markdown id: tags:
<details>
<summary style="border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8">
Réponse
</summary>
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8"> Une erreur car il est impossible de comparer la chaîne de caractère "10" (type str) avec le nombre 2 (type int).
</div>
</details>
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 2 </h3>
1. Remplace les `...` de chaque commentaire avec la valeur qui devrait être affichée.
*Indication: chaque print affiche un `bool` : `True` ou `False`*
%% Cell type:code id: tags:
``` python
a = 5
b = 18
c = 12.3
mot1="Hello"
mot2="World"
# L'instruction suivante va afficher ...
print(a > b)
# L'instruction suivante va afficher ...
print(b//a == 3)
# L'instruction suivante va afficher ...
print(b%a == 3)
# L'instruction suivante va afficher ...
print(a - b > 2)
# L'instruction suivante va afficher ...
print(type(c) == float)
# L'instruction suivante va afficher ...
print(mot1 != mot2)
# L'instruction suivante va afficher ...
print(mot1 < mot2)
# L'instruction suivante va afficher ...
print(mot1 > 2)
# L'instruction suivante va afficher ...
print("a" > "b")
# L'instruction suivante va afficher ...
print(mot1 > 2)
```
%% Cell type:markdown id: tags:
2. Exécute le programme ci-dessus et corrige, si besoin, les commentaires afin qu'ils correspondent aux valeurs affichées
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 2 </h3>Testez les lignes ci-dessous et ajoutez des exemples avec les autres 5 comparateurs.
%% Cell type:code id: tags:
``` python
# Variable x
x = 3
print('x =', x)
# 6 exemples de comparaisons
print('(x < 2) =', x < 2)
```
%% Cell type:markdown id: tags:
<h3 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-question" aria-hidden="true"> </i> &nbsp; Quizz </h3>
L'expression `x == 2` :
A) <input type="checkbox" > met la valeur 2 dans la variable x
B) <input type="checkbox" > compare deux valeurs
C) <input type="checkbox" > affecte la variable x avec une valeur
D) <input type="checkbox" > retourne True ou False
%% Cell type:markdown id: tags:
<details>
<summary style="border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8">
Réponse
</summary>
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">D) retourne True ou False
</div>
</details>
%% Cell type:markdown id: tags:
!!! warning
Il ne faut pas confondre l'opérateur d'affectation (`x = 2`) avec l'opérateur de comparaison (`x == 2`)
!!!
<h3 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-question" aria-hidden="true"> </i> &nbsp; Quizz </h3>
Que se passe-t-il si vous échangez les deux éléments dans `x == 2` ?
Et si vous échangez les deux éléments dans `x = 2` ?
Essayer pour voir...
%% Cell type:code id: tags:
``` python
x = 2 # affectation
x == 2 # comparaison
```
%% Cell type:raw id: tags:
Ma réponse :
%% Cell type:markdown id: tags:
<details>
<summary style="border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8">
Réponse
</summary>
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">Si on écrit 2 = x à la place de x = 2 il y aura une erreur car on ne peut affecter x à 2. Dans l'autre cas, c'est égal de tester si x est égal à 2 (x==2) ou de tester si 2 est égal à x (2==x)
</div>
</details>
%% Cell type:markdown id: tags:breakpoint
#### Ctrl+enter pour continuer ...........
%% Cell type:markdown id: tags:
## II) Conditions (`if`)
Afin d'exécuter du code de façon sélective, on utilise le mot-clé `if`.
Nous allons voir que :
- le mot-clé `if` permet une exécution conditionnelle,
- le mot-clé `if-else` permet de choisir entre deux alternatives,
- le mot-clé `elif` (else if) permet d'ajouter différentes conditions.
%% Cell type:markdown id: tags:
### Exécution conditionnelle `if`
La structure `if` ci-dessous permet d'exécuter une action seulement si `condition` est `True`.
``` python
if condition:
action
```
#### Exemple
Le programme suivant demande la moyenne générale obtenue au premier semestre est affiche `Bravo, tu peux faire un extra-muros!")` si la moyenne est supérieure ou égale à 5.3.
%% Cell type:code id: tags:
``` python
n = int(input("Quelle est ta moyenne générale au premier semestre"))
if n >= 5.3 :
print("Bravo, tu peux faire un extra-muros!")
```
%% Cell type:markdown id: tags:
<h3 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-question" aria-hidden="true"> </i> &nbsp; Quizz </h3>
En Python, `if` est suivi
A) <input type="checkbox" > d'un bloc
B) <input type="checkbox" > d'une condition
C) <input type="checkbox" > de parenthèses
D) <input type="checkbox" > d'un deux-points
%% Cell type:markdown id: tags:
<details>
<summary style="border-left:3px solid #3c763d; border-radius:2pt; width:100%; color:#3c763d; padding:6px; background-color: #dff0d8">
Réponse
</summary>
<div style="border-left:3px solid #3c763d; border-radius:2pt; color:#3c763d; padding:6px; background-color: #eff0e8">B) d'une condition (Et ensuite de D), un deux-points)
</div>
</details>
%% Cell type:markdown id: tags:
### Choix binaire `if - else`
La structure `if - else` ci-dessous permet d'exécuter une **action_1** seulement si une **condition** est vraie et une **action_2** sinon :
``` python
if condition:
action_1
else:
action_2
```
#### Exemple 1
Dans l'exemple ci-dessous, on affiche si un nombre entré est positif ou négatif :
%% Cell type:code id: tags:
``` python
n = int(input('Entrez un nombre: '))
if n > 0:
print('positif')
else:
print('négatif')
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 3 </h3>
1. Complète le programme ci-dessous qui affiche `C'est un triangle rectancle` ou `Ce n'est pas un triangle rectancle` en fonction des longeurs des côtés du triangle rentré.
1. Complètez le programme ci-dessous qui affiche `C'est un triangle rectancle` ou `Ce n'est pas un triangle rectancle` en fonction des longeurs des côtés du triangle rentré.
2. Testez votre programme pour vérifier si le triangle où a=9, b=12 et c= 15 est un triangle rectangle.
*Rappel : Selon la réciproque du théorème de Pythagore, un triangle de longeur $a$, $b$ et $c$ ($c$ le plus grand côté) est rectangle si $a^2+b^2=c^2$*
%% Cell type:code id: tags:
``` python
a = floatinput(("La longeur du côté a vaut : "))
b = floatinput(("La longeur du côté a vaut : "))
c = floatinput(("La longeur du côté a vaut : "))
a = float(input("La longeur du côté a vaut : "))
b = float(input("La longeur du côté a vaut : "))
c = float(input("La longeur du côté a vaut : "))
if ... :
print("...")
else:
print("...")
```
%% Cell type:raw id: tags:
Le triangle où a=9, b=12 et c= 15 est-il un triangle rectangle?
Réponse :
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 4 </h3>
Complétez le programme qui demande son âge à l'utilisatrice et affiche si elle est mineure ou majeure.
Complétez le programme qui demande son âge à l'utilisatrice et affiche `vous êtes majeure` si elle est mineure ou `vous êtes mineure` dans le cas contraire.
Rappel : la fonction `int` transforme la réponse textuelle du `input` en nombre entier.
*Rappel : la fonction `int` transforme la réponse textuelle du `input` en nombre entier.*
%% Cell type:code id: tags:
``` python
age = int(input("Bonjour, quel est votre âge ?"))
```
%% Cell type:markdown id: tags:breakpoint
#### Ctrl+enter pour continuer ...........
%% Cell type:markdown id: tags:
### Choix multiple (`if - elif - else`)
Le mot-clé `elif` est une contraction de **else if** et permet de continuer à tester d'autres conditions :
``` python
if condition1 :
action_1
elif condition2 :
action_2
else:
action_3
```
Dans l'exemple ci-dessous, on affiche si un nombre entré est positif, négatif ou nul :
%% Cell type:code id: tags:
``` python
n = int(input('Entrez un nombre: '))
if n > 0:
print('positif')
elif n < 0:
print('négatif')
else:
print('zéro')
```
%% Cell type:markdown id: tags:
Sans le mot-clé `elif` nous devrions mettre le bloc `if` à l'intérieur du bloc `else` en indentation.
Avec multiples conditions, les blocs se décalent de plus en plus et rendent le programme illisible, comme ci-dessous.
%% Cell type:code id: tags:
``` python
# !!! Exemple à éviter !!!!
n = int(input('Entrez un nombre: '))
if n > 0:
print('positif')
else:
if n < 0:
print('négatif')
else:
print('zéro')
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 5 </h3>
Pour chacun des programme:
1. Sans exécuter les programme, donnez la valeur des variables demandées.
2. Vérifier votre réponse en ajoutant un print à la fin des programmes et en les éxecutants.
**Programme A**
%% Cell type:code id: tags:
``` python
# Programme A
a = 7
b = 12
if a > 5:
b = b - 4
if b >= 10:
if b >= 8:
b = b + 1
```
%% Cell type:raw id: tags:
La variable b vaut :
%% Cell type:markdown id: tags:
**Programme B**
%% Cell type:code id: tags:
``` python
# Programme B
a = 7
b = 12
if a > 5:
b = b - 4
elif b >= 10:
b = b + 1
elif b >= 8:
b = b + 1
```
%% Cell type:raw id: tags:
La variable b vaut :
%% Cell type:markdown id: tags:
**Programme C**
%% Cell type:code id: tags:
``` python
# Programme C
a = 7
b = 12
if a > 5:
b = b - 4
else:
b = b + 1
```
%% Cell type:code id: tags:
``` python
La variable b vaut :
```
%% Cell type:markdown id: tags:
**Programme D**
%% Cell type:code id: tags:
``` python
# Programme D
a = 10
if a < 5:
a = 20
elif a < 100:
a = 500
else:
a = 0
```
%% Cell type:raw id: tags:
La variable a vaut :
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 6 </h3>
Les programmes suivants sont-ils valides (on ne demande pas ce qu’ils font) ? S’ils sont invalides, corrigez les.
**Programme A**
%% Cell type:code id: tags:
``` python
a = 10
if a == 5:
a = 2
```
%% Cell type:markdown id: tags:
**Programme B**
%% Cell type:code id: tags:
``` python
a = 10
elif a == 5:
a = 2
```
%% Cell type:markdown id: tags:
**Programme C**
%% Cell type:code id: tags:
``` python
a = 10
if a = 5:
a == 2
```
%% Cell type:markdown id: tags:
**Programme D**
%% Cell type:code id: tags:
``` python
a = 10
if a == 5:
a = 2
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 7 </h3>
1. Complétez le programme ci-dessous qui demande à l'utilisateur·ice les coefficients d'une équation du second degré $ax^2+bx+c=0$ et qui affiche les solutions.
2. Testez votre programme sur les équations $5x^2-5x-15=0$, $5x^2-5x+15=0$ et $10x^2-20x+10=0$.
%% Cell type:markdown id: tags:
!!! info utiliser des fonctions mathématiques comme la fonction racine carrée $\sqrt{x}$.
Pour calculer la racine carrée d'un nombre $\sqrt{x}$, il faut utiliser la fonction `sqrt` du module `math`. Pour ce faire, votre programme doit commencer par `from math import sqrt` (pour importer la fonction `sqrt` du module `math`). Pour l'utiliser, il suffit de mettre la valeur dont on veut trouver la racine en argument de la fonction `sqrt`. Par exemple, l'instruction `print(sqrt(25))` affichera 5.
!!!
%% Cell type:code id: tags:
``` python
a = float(input("Entrer le coefficient a = "))
b = float(input("Entrer le coefficient a = "))
c = float(input("Entrer le coefficient a = "))
a = ...(input("Entrer le coefficient a = "))
b = ...(input("Entrer le coefficient a = "))
c = ...(input("Entrer le coefficient a = "))
delta = ...
if ... :
x1 = ...
x2 = ...
print("Deux solutions, x1= ",x1, "; x2 = ", x2)
elif ... :
x = ...
print("...")
else :
print("...")
```
%% Cell type:raw id: tags:
Quel est l'ensemble des solution de 5x²-5x-15=0?
Réponse: S = ...
Quel est l'ensemble des solution de 5x²+5x+15=0=0?
Réponse: S = ...
Quel est l'ensemble des solution de 10x²-20x+10=0?
Réponse: S = ...
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 8 </h3>
Écrivez un programme qui demande à l'utilisateur·ice s'il faut dessiner un triangle, un cercle ou un carré, puis qui fait le bon dessin.
Écrivez un programme qui demande à l'utilisateur·ice s'il faut dessiner un triangle, un cercle ou un carré de dimension 100, puis qui fait le bon dessin.
%% Cell type:code id: tags:
``` python
from turtle import *
done()
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 9 </h3>
Définissez une fonction `temperature()` qui prend en paramètre une température entre -20 et 50 et affiche si cette température est :
* glaciale
* froide
* normale
* chaude
* bouillante
(à vous de choisir les bornes de chaque catégorie)
%% Cell type:code id: tags:
``` python
def temperature(t):
...
temp = int(input("Entrez une température entre -20 et 50 : "))
temperature(temp)
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 10 </h3>
Définissez une fonction `compare` qui prend en paramètres deux nombres `a` et `b`, puis qui dit lequel est le plus grand :
- si le premier nombre est plus grand que le deuxième, le programme affichera « Le premier ! »
- si le deuxième nombre est plus grand que le premier, le programme affichera « Le deuxième ! »
- s'ils sont égaux, le programme affichera « Ils sont égaux. ».
Testez-la avec deux nombres de votre choix.
%% Cell type:code id: tags:
``` python
# programme à compléter
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 11 </h3>
Corrigez le programme suivant :
%% Cell type:code id: tags:
``` python
age == 18
revenu == 25000
if age >= 18
if revenu < 25000
print("Vous êtes éligible à la subvention.")
elif revenu < 26000
print("Vous êtes presque éligible à la subvention, vous gagnez 1'000.- de trop.")
else:
print("Vous n'êtes pas éligible à cause de vos revenus trop élevés.")
else:
if revenu < 25000
print("Vous n'êtes pas éligible à cause de votre âge, mais le seriez si vous étiez majeur·e.")
else:
print("Vous n'êtes pas éligible à cause de vos revenus trop élevés et de votre âge.")
```
......
This diff is collapsed.
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment