Skip to content
Snippets Groups Projects
Commit 9018a7b7 authored by SCHIESS Mathieu's avatar SCHIESS Mathieu
Browse files

Ajout d'une version alternative du NB sur les conditions

parent 571c2d71
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:
# 6 - Les Conditions
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.
%% 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")
```
%% 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) d'un bloc
B) d'une condition
C) de parenthèses
D) d'un deux-points
```
%% 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">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é.
*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 : "))
if ... :
print("...")
else:
print("...")
```
%% 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.
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:
### 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:
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
```
%% 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: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 = "))
delta = ...
if ... :
x1 = ...
x2 = ...
print("Deux solutions, x1= ",x1, "; x2 = ", x2)
elif ... :
x = ...
print("...")
else :
print("...")
```
%% 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.
%% Cell type:code id: tags:
``` python
from turtle import *
done()
```
%% Cell type:markdown id: tags:breakpoint
#### Ctrl+enter pour continuer ...........
%% Cell type:markdown id: tags:
## 🚦 Attention aux branchements conditionnels ! 🚦
Lorsqu'on utilise une structure conditionnelle avec `if`, `elif`, `else`, **le programme sort du bloc dès qu'il trouve une condition vraie et que les instructions sous la condition sont exécutée**. C'est comme un **aiguillage de train** :
- Le train (le programme) avance sur la voie principale (le `if`).
- **Si** l'aiguillage (la condition `if`) est activé (vrai), le train dévie immédiatement sur cette voie et **ne teste pas les autres aiguillages** (`elif`, `else`).
- **Sinon**, il continue tout droit vers la prochaine condition `elif`, puis éventuellement jusqu'au `else` s'il n'a trouvé aucun aiguillage actif.
### 🚩 Exemple pour bien comprendre :
```python
x = 10
if x > 5:
print("Condition 1 : x est plus grand que 5")
elif x > 3:
print("Condition 2 : x est plus grand que 3")
else:
print("Condition 3 : aucune des conditions précédentes n'est vraie")
%% Cell type:markdown id: tags:
### ✅ Ce qui se passe :
- `x = 10` La première condition `x > 5` est **vraie**, donc le message de la **Condition 1** s'affiche.
- **Les autres conditions (`elif` et `else`) ne sont pas vérifiées du tout.**
- Ensuite, le programme **poursuit son exécution après le bloc `if - elif - else`**, en continuant avec les instructions suivantes.
### ⚠️ Piège à éviter :
Ne pensez pas que le programme va **tester toutes les conditions** à l'intérieur du bloc. **Dès qu'une condition est vraie, il exécute les instructions associées puis sort du bloc conditionnel**, sans vérifier les autres conditions.
### 🎯 Astuce :
Si vous avez besoin de **tester plusieurs conditions indépendamment**, utilisez plusieurs `if` séparés au lieu de `elif` :
%% Cell type:code id: tags:
``` python
x = 10
if x > 5:
print("x est plus grand que 5")
if x > 3:
print("x est aussi plus grand que 3")
```
%% Output
x est plus grand que 5
x est aussi plus grand que 3
%% 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>
Jean-Raoul a un hygiène de vie très stricte. Ils se pèse tous les matins
- S’il pèse moins de 100 kilos, durant la journée, il ne boit que du coca.
- S’il pèse entre 100 et 120 kilos, durant la journée, il ne boit que de jus d'orange.
- S’il pèse entre 100 et 200 kilos, durant la journée il ne boit que de l’eau.
Sa femme lui a écris un programme pour qui sache quoi boire
```python
poids = float(input("Que est ton poids? "))
print("Aujourd'hui tu peux boire du", end=" ")
if poids < 100:
print("coca")
if poids < 120:
print("jus d'orange")
if poids < 200:
print("eau")
```
1. Testez le programme avec les poids suivants : 78, 109, 130. Il y a un problème ?
2. Corrigez le programme.
%% Cell type:code id: tags:
``` python
poids = float(input("Que est ton poids? "))
print("Aujourd'hui tu peux boire du", end=" ")
if poids < 100:
print("coca")
if poids < 120:
print("jus d'orange")
if poids < 200:
print("eau")
```
%% Output
Que est ton poids? 80
Aujourd'hui tu peux boire du coca
jus d'orange
eau
%% Cell type:markdown id: tags:breakpoint
#### Ctrl+enter pour continuer ...........
%% Cell type:markdown id: tags:
## III) Les opérateurs `and`, `or` et `not`
En plus des comparateurs, les opérateurs `and`, `or` et `not` permettent de manipuler plusieurs conditions :
* `X and Y` Les deux conditions doivent être vraies pour que l'expression soit vraie.
* `X or Y` Une des deux conditions doit être vraies pour que l'expression soit vraie.
* `not X` La condition X doit être fausse pour que l'expression soit vraie.
Testez le code suivant :
%% Cell type:code id: tags:
``` python
nombre = 15
if nombre > 10 and nombre < 20:
print("Le nombre est entre 10 et 20.")
if nombre == 5 or nombre == 15:
print("Le nombre est soit 15 soit 20.")
if not nombre > 15:
print("Le nombre n'est pas supérieur à 15.")
```
%% Cell type:markdown id: tags:
<h6 style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-warning" aria-hidden="true"> </i> &nbsp; Note </h6>
En python, pour le premier cas :
``` python
if nombre > 10 and nombre < 20:
print("Le nombre est entre 10 et 20.")
```
on peut aussi écrire :
``` python
if 10 < nombre < 20:
print("Le nombre est entre 10 et 20.")
```
%% 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>
Un client de boite de nuit est décrit par trois variables : son genre (“Masculin” ou “Féminin”), sa tenue (“Bien sapé”, “Mal sapé”) et son portefeuille (“Épais”, “Mince”).
Les conditions pour rentrer en boîte de nuit sont les suivantes:
- Un client pauvre mais bien sapé peut entrer.
- Les clientes entrent toujours,
- Un client pauvre et mal sapé n’entre pas.
1. Compléter les programme ci-dessous afin d'avoir une programme qui affiche `peut rentrer` ou `ne peut pas rentrer` en fonction du cas.
2. Testez le programme dans tous les cas évoqués.
%% Cell type:code id: tags:
``` python
genre = input("Quel est votre genre (masculin/féminin) : ")
tenue = input("Quel est votre tenue (bien sapé/mal sapé) : ")
tenue = input("Quel est votre portefeuille (epais/mince) : ")
# à 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>
%% Cell type:markdown id: tags:
Écrire un programme qui traduit chacune des situations ci-après. Chaque programme commence par créer une variable pour chaque âge.
**Situation 1 :** Si Camille est plus âgée qu’Antoinette ou que Bernard et si Antoinette est plus jeune que Bernard, on affiche l’âge d’Antoinette, mais si Antoinette a le même âge ou est plus âgée que Bernard, on affiche l’âge de Bernard.
Sinon on affiche l’âge de Camille.
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
**Situation 2:** Si Bernard et Camille ont le même âge, on affiche l’âge de la plus jeune des trois personnes.
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:breakpoint
#### Ctrl+enter pour continuer ...........
%% Cell type:markdown id: tags:
## Exercices récapitulatifs
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 12 </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 13 </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 14 </h3>
<b style="color:chocolate;background-color:papayawhip;" > <i class="fa fa-warning" aria-hidden="true"> </i> &nbsp; Rappel : L'opérateur modulo (%) calcule le reste de la division entière. En conséquence, x % y vaut 0 quand x est divisible par y. <i class="fa fa-warning" aria-hidden="true"> </i> </b>
Écrivez un petit programme qui demande à l'utilisateur·ice un nombre et indique s'il est pair (divisible par 2) ou pas.
%% 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 15 </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.")
```
%% Cell type:markdown id: tags:
<h3 style="color:teal;background-color:azure;" > <i class="fa fa-pencil" aria-hidden="true"> </i> &nbsp; Exercice 16 </h3>
Écris une fonction bissextile dont l'argument est une année n, qui dit si cette année est bissextile (c'est-à-dire qu'elle comporte un 29 février).
Une année est bissextile dans l'un des cas suivants :
- c'est un multiple de 4 qui n'est pas un multiple de 100,
- c'est un multiple de 400.
Le programme doit afficher « Année bissextile » ou « Année non bissextile » suivant le cas.
%% 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 - Quizz </h3>
Créez un quiz avec des questions à choix multiple sur un sujet de culture générale, dans le style des quiz sur le site Kahoot.
- Complétez pour avoir 4 questions
- Ajoutez le calcul du score
%% Cell type:code id: tags:
``` python
print('Quiz sur le thème : ....')
score = 0
# Question 1
print()
question = "Quel est le nom du cowboy dans Toy Story ?"
solution = 'Woody'
reponse = input(question)
if reponse == solution:
...
else:
...
# Question 2
print()
...
print('Votre score est', ...)
```
%% Cell type:markdown id: tags:
---
#### Remarque générale
Ce document est une adaptation d'un ressource pédagogique tiré du catalogue modulo https://modulo-info.ch/. Il 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)
Notebook sur les print
----------------------
- Ajouter un info sur la diff " vs ', comment afficher les caractères spéciaux "\" par exemple, ou "\n"...
- Ajouter un dessin de division de nombre pour comprendre les opérations % et //
- Expliquer le end=
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