Bienvenue au cours de Programmation en sciences!

Lors de ce cours, nous allons apprendre les bases de la programmation. À la fin du cours, vous serez en mesure d'écrire des programmes pour faire des calculs scientifiques, analyser des données, créer des simulations physiques, et plus encore!

Table des matières

Qu'est-ce que la programmation?

Les programmes peuvent prendre toutes sortes de formes : une page web, un jeu vidéo, une application mobile ou même le logiciel qui fait fonctionner un robot. Peu importe leur apparence, ils suivent tous le même principe : ils exécutent des instructions dans un certain ordre. Un programme c'est en quelque sorte une recette pour que l'ordinateur accomplisse une tâche. L'écriture de ces instructions, c’est ce qu’on appelle la programmation.

Pour donner ces instructions à l’ordinateur, on utilise un langage de programmation. C'est un langage qui comprend un ensemble de mot-clés et de symboles qui ont un sens pour l'ordinateur. Le code c'est l'ensemble des instructions du programme dans un langage de programmation spécifique. Dans ce manuel, nous allons apprendre à programmer en utilisant le langage Python, un langage populaire dont le code est simple à lire et à comprendre.

Voici un premier exemple de programme :

print("Bonjour!")
print("Bienvenue au cours de programmation.")

Afficher un résultat

Les programmes peuvent afficher du texte ou le résultat d'un calcul à l'écran. C'est avec print qu'on demande à l’ordinateur d'afficher quelque chose.

Par exemple, voici un programme qui calcule le nombre de cheveux humains sur une tête typique :

print("Nombre de cheveux moyen par cm² :", 200)
print("Superficie moyenne d'un cuir chevelu en cm² :", 1000)
print("Nombre de cheveux sur une tête typique :", 200 * 1000)

L'exécution de ce programme va afficher à la console le texte suivant :

Nombre de cheveux moyen par cm² : 200
Superficie moyenne d'un cuir chevelu en cm² : 1000
Nombre de cheveux sur une tête typique : 200000

Exercice 1

Maintenant utilisez l'environnement de développement à droite pour modifier le programme afin qu'il calcule le nombre de cheveux pour toutes les personnes sur la planète, en supposant que la population mondiale est 8 milliards.

Une fois le programme modifié, cliquez sur le bouton (Exécuter) de l'environnement de développement pour voir le résultat de son exécution. Quand on clique sur Exécuter, le programme redémarre du début. On peut donc exécuter le programme autant de fois qu'on le veut.

print("Nombre de cheveux moyen par cm² :", 200)
print("Superficie moyenne d'un cuir chevelu en cm² :", 1000)
print("Nombre de cheveux sur une tête typique :", 200 * 1000)

print("Nombre de cheveux moyen par cm² :", 200)
print("Superficie moyenne d'un cuir chevelu en cm² :", 1000)
print("Population mondiale estimée :", 8000000000)
print("Nombre de cheveux dans le monde :",
      200 * 1000 * 8000000000)

Exercice 2

Il est possible d'utiliser print pour afficher du texte qui représente une image.

Utilisez print pour afficher la forme pyramidale suivante à la console :

   #
  ###
 #####
#######

print("   #")
print("  ###")
print(" #####")
print("#######")

print("               __")
print("              / _)")
print("     _.----._/ /")
print("    /         /")
print(" __/ (  | (  |")
print("/__.-'|_|--|_|")

Les dessins avec la tortue

Les programmes ne servent pas seulement à faire des calculs : ils peuvent aussi vous permettre de dessiner ! Une façon amusante de le faire est d'utiliser une tortue. Imaginez une petite tortue qui se promène sur une feuille de papier quadrillé. Lorsqu'elle se déplace, elle laisse une trace derrière elle et dessine des lignes partout où elle passe.

Dans l'image ci-dessous, la tortue a dessiné un carré. Le petit triangle rouge montre où se trouve la tortue en ce moment et dans quelle direction elle regarde - comme une flèche indiquant le chemin qu'elle suivra si on la fait avancer !

Ce dessin a été créé par le programme suivant :

fd(50)

rt(90)
fd(50)

rt(90)
fd(50)

rt(90)
fd(50)

Mouvement de la tortue

Voici les instructions pour déplacer la tortue :

• fd(n) : avancer de n pixels
• bk(n) : reculer de n pixels
• rt(n) : tourner à droite de n degrés
• lt(n) : tourner à gauche de n degrés

On peut aussi faire des déplacements en diagonale avec fd et bk:

• fd(x, y) : avancer de x et se déplacer lattéralement de y à gauche
• bk(x, y) : reculer de x et se déplacer lattéralement de y à droite

Parfois, il est utile d'exécuter un programme lentement, une instruction à la fois. Débutez l'exécution du programme ci-dessous en cliquant sur (Exécuter le premier pas), puis continuez avec (Exécuter le prochain pas).

lt(45)
fd(100)

rt(45)
bk(100)

fd(100, -50)
bk(70, 20)

Trait de la tortue

On peut changer le trait utilisé par la tortue avec ces instructions :

• pensize(n) : dessiner des traits d'une largeur de n pixels
• pencolor(couleur) : changer la couleur du trait

On peut aussi cacher ou montrer la tortue, et effacer un dessin :

• ht() : cacher la tortue
• st() : montrer la tortue
• clear() : effacer le dessin et réinitialiser la tortue

Voici un exemple qui utilise ces instructions pour dessiner une tour colorée.

lt(90)
bk(60)

pencolor(1, 0, 0)
pensize(60)
fd(60)

pencolor("green")
pensize(40)
fd(40)

pencolor(1, 0, 1)
pensize(30)
fd(30)

ht()

Positionner la tortue

Pour se déplacer sans laisser de trait on utilise hop(). Le déplacement qui vient après hop() bougera la tortue sans laisser de trait.

Par exemple, on peut utiliser hop() suivi d'un déplacement pour positionner la tortue au bon endroit au début d'un dessin.

hop()
fd(50, 50)

fd(0, -100)
bk(100)
fd(0, 100)
fd(100)

Exercice 3

Utilisez la tortue pour dessiner un triangle rectangle dont la longueur de la base est 120 pixels et la hauteur est 90 pixels comme celui-ci :

fd(120)
fd(0, 90)
bk(120, 90)
ht()

Exercice 4

Utilisez la tortue pour dessiner le drapeau de la France :

Les dimensions de ce drapeau sont de 150 pixels de large par 100 pixels de haut. Chaque bande de couleur mesure 50 pixels de large.

hop()
bk(75)

pensize(100)

pencolor("blue")
fd(50)

pencolor("white")
fd(50)

pencolor("red")
fd(50)

ht()

Les erreurs

Il est normal de faire des erreurs lorsqu'on écrit un programme. Lorsqu'une erreur survient, le programme arrête, l'environnement de développement affiche un message d'erreur et la position de l'erreur dans le code est surlignée. Voici quelques exemples d'erreurs. Portez attention au message d'erreur!

Une parenthèse fermante a été oubliée :

print("Bonjour!"

On a mal écrit print.

pint("Bonjour!")

On a oublié d'indiquer la distance d'un trait en utilisant l'instruction fd de la tortue.

fd()

Exercice 5

Le programme dans votre environnement de développement doit imprimer la facture d'un restaurant, mais le code contient des erreurs. Exécutez le programme et lisez attentivement les messages d'erreurs. Corrigez les erreurs jusqu'à ce que le programme affiche :

Menu du jour
-------------------------
Soupe du jour ....  4.50$
Sandwich .........  6.75$
Café .............  2.00$
-------------------------
Total ............ 13.25$

print("Menu du jour")
print( ------------------------- )
print("Soupe du jour ....  4.50$")
print("Sandwich .........  6.75$")
print("Café .............  2.00$")
prnit("-------------------------")
print("Total ............ 13.25$"

print("Menu du jour")
print("-------------------------")
print("Soupe du jour ....  4.50$")
print("Sandwich .........  6.75$")
print("Café .............  2.00$")
print("-------------------------")
print("Total ............ 13.25$")

Exercice 6

Le programme dans votre environnement de développement doit dessiner une pyramide rouge de six étages comme ci-dessous. Malheureusement ce programme contient des erreurs. Corrigez les erreurs jusqu'à ce que le programme complète son dessin.

rt(90)
pencolor("rouge")
pensize(15)
fd(15)
pensize(45)
fd(15)
pensize(75)
fd(15)
pensize(105)
ht(15)
pensize(135)
fd(15)
pensize(165)
fd(15)
ht()

rt(90)
pencolor("red")
pensize(15)
fd(15)
pensize(45)
fd(15)
pensize(75)
fd(15)
pensize(105)
fd(15)
pensize(135)
fd(15)
pensize(165)
fd(15)
ht()

La console

Les programmes que nous avons vu jusqu'à présent étaient enregistrés dans des fichiers. Parfois, on veut tester de petits segments de code, par exemple pour apprendre ou pour trouver des erreurs.

Pour exécuter de petits segments de code, on peut utiliser la console. Dans l'environnement de développement à droite, la fenêtre contenant >>> est appelée la console. Les caractères >>> sont appelés l'invite de commande (prompt en anglais).

Écrivez du code après l'invite de commande, puis appuyez sur la touche Entrée pour l'exécuter. Essayez d'exécuter les instructions suivantes et observez le résultat :

• 1+2
• print("bonjour!")
• fd(100)

Exercice 7

Utilisez la console pour calculer le nombre de secondes dans une année commune, c'est à dire une année qui n'est pas bissextile.

Exercice 8

À quelle couleur correspond l'instruction pencolor(1, 0, 1)?

• Ⓐ █ rouge
• Ⓑ █ vert
• Ⓒ █ bleu
• Ⓓ █ magenta
• Ⓔ █ jaune

Résumé

Exercice 9

Affichez à la console l’aire et le périmètre d’un rectangle de largeur 120 et de hauteur 80. Utilisez deux print, le premier pour afficher l'aire et le second pour le périmètre.

# Aire
print(120 * 80)

# Périmètre
print(2 * (120 + 80))

Exercice 10

En utilisant des appels à print, affichez à la console ce carré fait de # autour d’un espace vide :

#########
#       #
#       #
#       #
#########

print("#########")
print("#       #")
print("#       #")
print("#       #")
print("#########")

Exercice 11

Pour convertir une température de Celsius à Fahrenheit, on utilise la formule suivante.

°F = (°C × 9/5) + 32

Avec la tortue, dessinez le graphique de cette fonction dans le plan cartésien. L'axe des x doit représenter la température en Celsius et l'axe des y, les Fahrenheit. Vous devez dessiner l'axe des x et l'axe des y en noir, et la courbe de la fonction en rouge pour l'intervalle allant de -100°C à 100°C comme ceci :

# Tracer les axes
hop()
fd(-100, 0)
fd(200)
hop()
fd(-100, -100)
fd(0, 200)

# Tracer la fonction °F = (°C × 9/5) + 32

# On place la tortue à l'origine de la fonction (y=32)
hop()
fd(0, -100)
hop()
fd(0, 32)

# Tracer la ligne de la fonction
pencolor("red")
fd(100, 9 / 5 * 100)
bk(200, 9 / 5 * 200)

ht()

Exercice 12

Utilisez la tortue pour dessiner un hexagone régulier dont chaque côté mesure 50 pixels. Le centre de l'hexagone doit se trouver aux coordonnées (0, 0).

hop()         # Centrer l'hexagone
fd(0, 50)
rt(30)

fd(50)        # Dessiner le côté #1

rt(60)        # Dessiner le côté #2
fd(50)

rt(60)        # Dessiner le côté #3
fd(50)

rt(60)        # Dessiner le côté #4
fd(50)

rt(60)        # Dessiner le côté #5
fd(50)

rt(60)        # Dessiner le côté #6
fd(50)

ht()

Exercice 13

Utilisez la tortue pour reproduire le dessin suivant. Les côtés des carrés rouge et vert sont de 130 pixels. Les côtés du carré bleu sont de 92 pixels.

hop(); bk(65)

pensize(130)
pencolor("red")
fd(130)

hop(); bk(65)
lt(45)
hop(); bk(65)
pencolor(0, 1, 0)
fd(130)

hop(); bk(65)
lt(45)
hop(); bk(46)
pensize(92)
pencolor("blue")
fd(92)

ht()

Exercice 14

Utilisez la tortue pour reproduire le dessin suivant.

hop(); bk(70)

pensize(140)
pencolor(0.95,0.95,0)
fd(140)

hop(); bk(70)
lt(22.5)
hop(); bk(70)
fd(140)

hop(); bk(70)
lt(22.5)
hop(); bk(70)
fd(140)

hop(); bk(70)
lt(22.5)
hop(); bk(70)
fd(140)

ht()

Exercice 15

Utilisez la tortue pour dessiner le drapeau de la Suisse :

Ce drapeau est un carré de 100 × 100 pixels.

Les dimensions de la croix au centre du drapeau sont de 60 × 60 pixels.

L'épaisseur des bandes formant la croix est de 20 pixels.

# Positionner la tortue
hop()
bk(50)

# Fond rouge
pencolor("red")
pensize(100)
fd(100)

# Bande horizontale pour la croix
hop()
bk(80)
pencolor("white")
pensize(20)
fd(60)

# Bande verticale pour la croix
hop()
bk(30, -30)
rt(90)
fd(60)

ht()

Exercice 16

Utilisez la tortue pour dessiner le drapeau de la Norvège :

Ce drapeau est de dimensions 220 × 160 pixels. Les dimensions des parties sont inscrites dans le dessin ci-dessus.

# Positionner la tortue
hop()
bk(110)

# Dessiner le fond rouge
pencolor("red")
pensize(160)
fd(220)

# Dessiner la croix blanche
pencolor("white")
pensize(40)
bk(220)
fd(80)
lt(90)
fd(80)
bk(160)
fd(80)

# Dessiner la croix bleue
pencolor("blue")
pensize(20)
fd(80)
bk(160)
fd(80)
rt(90)
bk(80)
fd(220)

ht()

Exercice 17

Le programme dans votre environnement de développement doit dessiner le drapeau de la Suède, mais contient des erreurs. Corrigez les erreurs jusqu'à ce que le programme complète son dessin.

# Positionner la tortue
hop()
bk(80)

# Fond bleu
pensize(0, 0.29, 0.53)
pencolor(100)
fd(160)

# Barre jaune horizontale
pencolor(1, 0.8, 0)
pensize(20)
bk(160

# Barre jaune verticale
hop()
fd(60, -50)
fd(0 100)

ht()

# Positionner la tortue
hop()
bk(80)

# Fond bleu
pencolor(0, 0.29, 0.53)
pensize(100)
fd(160)

# Barre jaune horizontale
pencolor(1, 0.8, 0)
pensize(20)
bk(160)

# Barre jaune verticale
hop()
fd(60, -50)
fd(0, 100)

ht()

Exercice 18

Utilisez la console pour calculer le nombre de grains de sable sur les plages à travers le monde.

On suppose les faits suivants :

• Il y a 500 000 kilomètres de rivages.
• Un tier des rivages est couvert de sable.
• Un rivage sablonneux a en moyenne 30 mètres de largeur et 2 mètres de profondeur.
• Il y a environ 10 milliards de grains de sable par mètre cube.

>>> 500000 * 1000 / 3 * 30 * 2 * 10000000000
1e+20

Exercice 19

La vitesse de la lumière est d'exactement 299 972 458 m/s.

Depuis la Terre, on dirige un laser vers un miroir réfléchissant se trouvant sur la Lune. On calcule que la faisceau laser prend 2.6 secondes pour faire l'aller-retour Terre-Lune.

À l'aide de la console, calculez la distance entre la Terre et la Lune.

>>> 299972458 / 1000 * 2.6 / 2
389964.19539999997

Les opérations arithmétiques

On écrire un programme qui fait des calculs en utilisant les opérations mathématiques comme +, -, /. En Python on utilise * pour la multiplication et ** pour les exposants. On peut aussi utiliser des parenthèses pour regrouper des expressions.

Python utilise l'ordre des opérations habituelle: parenthèses, exposants, multiplication/division, addition/soustraction.

Par exemple, voici un programme qui calcule les fonds dans un compte d'épargne avec un taux d'intérêt composé.

print("Montant initial:", 100)
print("Taux d'intérêt:", 0.05)
print("Périodes composant une année:", 3)
print("Nombre d'années écoulées:", 10)
print("Montant actuelle:", 100 * (1 + 0.05 / 3) ** (10 * 3))

Les types de nombres

Pour faire des calculs, on peut utiliser des nombres entiers (par exemple 42, ou 2026) ou des nombres décimaux (3.14, ou 9.81), aussi appelés nombres flottants.

Pour rendre les calculs plus lisibles, on peut utiliser le séparateur _ pour écrire de grands entiers. Par exemple, 1000000 peut être écrit 1_000_000.

On peut aussi écrire des nombres flottants avec la notation scientifique. Par exemple, pour représenter 6.02 × 10²³ on écrit 6.02e23.

print("Masse de la Lune:", 7.3e22)
print("Masse de la Terre:", 6e24)
print("Distance:", 389_964_000)
print("Constante gravitationnelle:", 6.67e-11)
print("Force d'attraction en newtons:")
print(6.67e-11 * 7.3e22 * 6e24 / 389_964_000 ** 2)

Exercice 1

La masse d'un proton est d'environ 1.672 × 10⁻²⁷ kg, celle d'un électron est environ 9.109 × 10⁻³¹ kg.

On peut approximer la masse d'un atome d'hydrogène en additionnant la masse d'un proton et d'un électron.

En se rappellant qu'une mole contient 6.02 × 10²³ particules, écrivez un programme estimant la masse d'un mole d'atomes d'hydrogène.

Le programme doit utiliser print pour afficher les masses d'un proton, d'un électron, d'un atome d'hydrogène et d'une mole d'atomes d'hydrogène.

print("Masse d'un proton:", 1.672e-27)
print("Masse d'un électron:", 9.109e-31)
print("Masse d'un atome d'hydrogène:", 1.672e-27 + 9.109e-31)
print("Masse d'une mole d'hydrogène:", (1.672e-27 + 9.109e-31) * 6.02e23)

Les variables

Un programme a souvent besoin de réutiliser une valeur ou le résultat d'un calcul. Pour éviter d'avoir à réécrire le calcul plusieurs fois, on peut sauvegarder son résultat dans une variable.

Pour assigner une valeur à une variable on utilise le symbole =.

x = 100
print(x)

En plus de permettre de réutiliser des résultats, les variables aident à organiser le code et à le rendre plus lisible.

proton = 1.672e-27
neutron = 1.675e-27

# carbone-12 (6 protons, 6 neutrons)
numero_atomique = 6
isotope = 12
nombre_neutrons = isotope - numero_atomique
mole = 6.02e23

masse_atome = numero_atomique * proton + nombre_neutrons * neutron
masse_molaire = mole * masse_atome

print("Masse d'un atome de carbone-12:", masse_atome)
print("Masse d'une mole de carbone-12:", masse_molaire)

Noms de variables

Le nom d'une variable peut être composé de lettre, de chiffre, et du caractère _. Il ne peut pas commencer par un chiffre.

Par exemple, ces noms sont valides:

temperature_exterieure = 23.5
prix_en_2026 = 299
distance_terre_lune = 389_964

Mais ceux-ci sont invalides:

3_petits_chats = 3
prix_en_$ = 2.99

Puisque les espaces ne sont pas permis dans les noms de variables, on utilise souvent le caractère _ pour séparer les mots. Ce style de nom s'appelle le snake_case.

Exercice 2

Parmis les noms de variable suivants, lesquels sont valides?

• Ⓐ resultats_experience4
• Ⓑ pression_ambiante
• Ⓒ x
• Ⓓ T
• Ⓔ Toutes ces réponses
• Ⓕ Aucune de ces réponses

Exercice 3

Parmis les noms de variable suivants, lesquels sont invalides?

• Ⓐ _
• Ⓑ 10degres_celsius
• Ⓒ température
• Ⓓ PROPORTION_DES_COTES
• Ⓔ Toutes ces réponses
• Ⓕ Aucune de ces réponses

Répéter un calcul avec différentes valeurs

En plus de faciliter la modification d'un paramètre dans un programme, les variables permettent de répéter un même calcul avec différentes valeurs.

Par exemple, ce programme affiche les nombres de 1 à 5.

print(1)
print(2)
print(3)
print(4)
print(5)
print("fin!")

On peut simplifier le programme en répétant la même instruction print(nombre) où la variable nombre prend les valeurs de 1 à 5.

for nombre in 1, 2, 3, 4, 5:
    print(nombre)
print("fin!")

C'est ce qu'on appelle une boucle. Une boucle indique un nom de variable (après le mot-clé for) et les valeurs que prendra cette variable (après le in). Le code a répéter est indenté, c'est à dire qu'on utilise quatre espaces avant chaque instruction à répéter.

Exercice 4

Utilisez un boucle for pour dessiner un rectangle avec la tortue. Le programme doit commencer par deux variables qui permettent de facilement modifier la largeur et la hauteur du rectangle.

Par exemple, pour une largeur de 150 et un hauteur de 100, votre programme doit faire le dessin suivant:

for cote in 150, 100, 150, 100:
    fd(cote)
    rt(90)

largeur = 150
hauteur = 100

hop()
bk(largeur / 2, -hauteur / 2)

for cote in largeur, hauteur, largeur, hauteur:
    fd(cote)
    rt(90)

ht()

La fonction d'arrondissement

Pour arrondir un nombre on utilise round, qui arrondi à l'entier le plus proche.

print(round(3.14))
print(round(9.81))

On peut aussi ajouter un deuxième paramètre à round pour choisir à quelle précision arrondir. Par exemple, arrondir à deux chiffres après la virgule:

print(round(3.14159265, 2))

Exercice 5

Pour une expérience, une boîte de Petri contient une population initiale de 2000 de bactéries. À chaque heure, la population de bactéries augmente de 75%.

Écrivez un programme qui affiche la population à chaque heure lors des cinq premières heures de l'expérience. Puisqu'il ne peut y avoir qu'un nombre entier de bactéries, assurez-vous que la valeur affichée soit un entier.

population = population_initiale * 1.75 ** heures

population_initiale = 2_000

for heures in 0, 1, 2, 3, 4, 5:
    population = population_initiale * 1.75 ** heures
    print("Après", heures, "h, la population est de", round(population))

La fonction valeur absolue

La valeur absolue d'un nombre est sa valeur sans tenir compte de son signe. Pour trouver la valeur absolue d'un nombre, on utilise abs.

print(abs(-123))
print(abs(-3.14))
print(abs(2026))

Exercice 6

La fonction valeur absolue est fréquemment utilisée en statistiques pour calculer l'écart moyen. L'écart moyen mesure à quel point des données sont dispersées autour de la moyenne.

Dans un ensemble de données, on peut calculer l'écart d'un seul point $x$ à la moyenne $\bar{x}$ avec:

Où $|...|$ est la fonction valeur absolue.

L'écart moyen est la moyenne de tous les écarts.

Par exemple, on peut regarder la moyenne d'un groupe d'étudiants pour savoir si un examen a été bien réussi. On peut également regarder l'écart moyen pour savoir si les notes varient beaucoup d'une personne à l'autre.

Écrivez un programme qui calcule la moyenne et l'écart moyen des notes d'examen d'un petit groupe ayant obtenu les notes 93, 67, 87, et 71.

note1 = 93
note2 = 67
note3 = 87
note4 = 71

# Complétez le programme

note1 = 93
note2 = 67
note3 = 87
note4 = 71

moyenne = (note1 + note2 + note3 + note4) / 4

ecart_moyen = (abs(note1 - moyenne) +
               abs(note2 - moyenne) +
               abs(note3 - moyenne) +
               abs(note4 - moyenne)) / 4

print("Moyenne:", moyenne)
print("Écart moyen:", ecart_moyen)

note1 = 93
note2 = 67
note3 = 87
note4 = 71

moyenne = (note1 + note2 + note3 + note4) / 4

ecart_moyen = 0
for note in note1, note2, note3, note4:
    ecart_moyen = ecart_moyen + abs(note - moyenne) / 4

print("Moyenne:", moyenne)
print("Écart moyen:", ecart_moyen)

Les minimum et maximum

On utilise min et max pour trouver le minimum ou le maximum de deux valeurs.

print(min(2.71, 3.14))
print(max(2**3, 3**2))

On utilise souvent min et max pour borner le résultat d'un calcul. Si, par exemple, on veut que le résultat d'un calcul soit borné entre 0 et 100, on peut écrire max(0, min(100, resultat)).

resultat1 = 3 * 25 + 40
print("Résultat #1:", resultat1)
print("Résultat #1 borné:", max(0, min(100, resultat1)))

resultat2 = -3 * 25 + 15
print("Résultat #2:", resultat2)
print("Résultat #2 borné:", max(0, min(100, resultat2)))

Exercice 7

La batterie d'un téléphone cellulaire est initialement chargée à 10%. On branche le téléphone qui commence à se recharger de 2% chaque minute. Lorsqu'elle atteint 100%, la batterie est pleine et sa charge ne change plus.

Écrivez un programme qui affiche la charge de la batterie après un certain temps de chargement. Le programme doit commencer par la définition d'une variable temps qui représente le nombre de minutes de chargement.

temps = 0

# Complétez le programme

# Paramètres
temps = 0
charge_initial = 10
taux_de_chargement = 2

# Calcul et affichage du chargement
charge = min(100, taux_de_chargement * temps + charge_initial)
print("Charge:", charge, "%")

Les fonctions mathématiques

On peut calculer avec des fonctions mathématiques en utilisant la bibliothèque mathématique de Python. Une bibliothèque, c'est un ensemble de fonctions similaires rassemblées ensemble.

La bibliothèque mathématique de Python s'appelle math. On écrit math.fonction pour utiliser une de ses fonctions. Voici quelques exemples:

Exercice 8

Une boîte de 5 kg repose sur un plan incliné. Son poids peut être décomposé en deux composantes : la force normale, et la force du plan.

La force normale est la force du plan sur l'objet, en réaction à la gravité. Elle est perpendiculaire au plan.

La force du plan est la composante de la force gravitationnelle qui fait glisser l'objet. Elle est parallèle au plan.

Écrivez un programme qui dessine le diagramme de forces du plan incliné avec la tortue. Le programme doit commencer par une déclarer deux variables pour paramétrer l'angle du plan et la masse de la boîte.

Dessinez la force normale en bleue, et la force du plan en vert. Utilisez l'amplitude de la force (en Newtons) comme longueur des trait représentant chaque force.

# Paramètres
angle = 30
masse = 5
cote_boite = 40
acceleration_gravitationnelle = 9.81
angle_radian = angle / 180 * math.pi

# Calcul des composantes de la force
force_gravitationnelle = masse * acceleration_gravitationnelle
force_normale = force_gravitationnelle * math.cos(angle_radian)
force_plan = force_gravitationnelle * math.sin(angle_radian)

# Dessin de la pente
lt(angle)
fd(100)
bk(200)
fd(100)
lt(90)

# Dessin de la boite
pensize(cote_boite)
pencolor(1, 0, 0)
fd(cote_boite)

# Dessin force normale
pensize(2)
pencolor(0, 0, 1)
fd(force_normale)

# Dessin force parallèle au plan
hop(); bk(force_normale + cote_boite / 2)
lt(90)
hop(); fd(cote_boite / 2)

pensize(2)
pencolor(0, 1, 0)
fd(force_plan)

La division entière et le modulo

Une division peut être décomposée en une partie entière et un reste. Par exemple, dans la division $13÷5$ , la partie entière est $2$ et le reste est $3$ , parce que $13=2\times 5+3$ .

La division entière calcule la partie entière d'une division. Elle est aussi appelée quotient. En Python, on l'écrit avec le symbol //.

Le modulo est une opération qui calcule le reste d'une division. En Python, on l'écrit avec le symbol %.

dividende = 13
diviseur = 5

print(dividende, "÷", diviseur)
print("partie entière:", dividende // diviseur)
print("reste:", dividende % diviseur)
print("division:", dividende / diviseur)

Exercice 9

Si aujourd'hui est un lundi, quel jour sera-t-il dans 63410 jours?

Utilisez la console ou écrivez un programme faisant les calculs nécessaires pour obtenir la réponse.

• Ⓐ dimanche
• Ⓑ lundi
• Ⓒ mardi
• Ⓓ mercredi
• Ⓔ jeudi
• Ⓕ vendredi
• Ⓖ samedi

>>> (1 + 63_410) % 7
    5

dimanche = 0
lundi = 1
mardi = 2
mercredi = 3
jeudi = 4
vendredi = 5
samedi = 6

aujourdhui = lundi
nombre_de_jours = 63410

print((aujourdhui + 63410) % 7)

Les fonctions de hasard

Certains programmes ont besoin de générer des nombres aléatoires, par exemple un jeu vidéo, un simulation de mutations génétiques, ou un programme de cryptographie.

Pour générer un nombre flottant aléatoire entre 0.0 (inclus) et 1.0 (exclus), on utilise random().

print("Trois nombres aléatoires de 0.0 à 1.0")
for nombre in 1, 2, 3:
    print(random())

On peut aussi générer un nombre entier aléatoire avec randint(a, b) qui génère un nombre de a à b (inclus).

print("Trois entiers aléatoires de 1 à 100")
for nombre in 1, 2, 3:
    print(randint(0, 100))

Exercice 10

Écrivez un programme qui affiche un nombre flottant entre 0.0 (inclus) et 100.0 (exclus) au hasard.

maximum = 100
nombre = random() * maximum
print(nombre)

Exercice 11

Écrivez un programme qui affiche un nombre entier pair entre 0 (inclus) et 100 (inclus) au hasard.

nombre = randint(0, 50) * 2
print(nombre)

Résumé

Les opérations arithmétiques.

Les fonctions de la bibliothèque math. Les fonctions trigonométriques sont en radians.

Les fonctions de hasard.

Exercice 12

Un contenant de 150 litres se fait remplir à un débit de 2 litres par seconde. Puisque le contenant peut contenir au maximum 150 litres, la quantité d'eau dans le contenant sera toujours de 0 à 150.

Écrivez un programme calculant la quantité d'eau dans ce contenant après un certain nombre de secondes.

Le programme doit commencer par une variable temps qui est le temps en secondes depuis qu'on a commencé le remplissage. Ce temps peut prendre une valeur négative, représentant la période avant que le remplissage commence.

Votre programme doit afficher le niveau d'eau dans la console et dessiner le contenant et son niveau d'eau avec la tortue.

Utilisez votre créativité pour le dessin! Pour vous inspirer, voici un exemple d'à quoi il pourrait ressembler pour un temps écoulé de 30 secondes.

max(0, min(taille_contenant, quantite_eau))

# Modifiez le temps et relancez le programme
temps = 30 # secondes

# Paramètres de la simulation
hauteur_contenant = 150 # 1 pixel = 1L
debit_eau = 2 # L / seconde

# Calcul d'un niveau d'eau
quantite_eau = debit_eau * temps
niveau_eau = max(0, min(hauteur_contenant, quantite_eau))

print("Après", temps, "secondes, le niveau d'eau est de", niveau_eau, "L")

# Dessin du contenant
hop()
lt(90)
bk(hauteur_contenant / 2)
pensize(104)
fd(hauteur_contenant + 2); bk(hauteur_contenant)
pensize(100)
pencolor(1, 1, 1)
fd(hauteur_contenant); bk(hauteur_contenant)

# Dessin du niveau d'eau
pencolor(0.72, 0.83, 1)
fd(niveau_eau)

ht()

Exercice 13

La loi de Snell permet de calculer l'angle de réfraction d'un rayon de lumière changeant de milieu.

Où $n_1$ et $n_2$ sont les indices de réfraction des milieux dans lesquels se propage les rayons initial et réfracté, et ${\theta }_1$ et ${\theta }_2$ sont les angles de réfraction de ces rayons.

Vous devez utilise la loi de Snell pour simuler et dessiner un rayon réfracté par un panneau de verre en utilisant la tortue.

Pour pouvoir paramétrer la simulation, le programme doit commencer par la déclaration de trois variables qui représentent:

1. l'indice de réfraction du milieu initial
2. l'indice de réfraction du panneau
3. l'angle d'incidence du rayon entrant dans le panneau

Dessinez un panneau de verre allant de $x=0$ à $x=100$ dans le plan de la tortue. Dessinez ensuite la trajectoire du rayon traversant le panneau.

Par exemple avec $n_1=1$ , $n_2=3$ et ${\theta }_1={30}^{\circ }$ , votre programme doit générer le dessin suivant:

# Changez ces variables pour paramétrer le dessin
# Les indices de réfraction doivent être plus grands ou égaux à 1.0
indice_refract1 = 1.0 
indice_refract2 = 3.0
angle1_degre = 30
profondeur_milieu2 = 100

# === CALCULS ===

# Calcul des angles
angle1_radian = angle1_degre / 180 * math.pi
angle2_radian = math.asin(indice_refract1 * math.sin(angle1_radian) / indice_refract2)
angle2_degre = angle2_radian / math.pi * 180

# Calcul de la distance parcourue par le rayon dans le milieu
distance_milieu2 = profondeur_milieu2 / math.cos(angle2_radian)

# === DESSIN ===

# Dessin du panneau de verre
pencolor(0.72, 0.83, 0.91)
pensize(500)
fd(profondeur_milieu2); bk(profondeur_milieu2)

# Dessin du rayon avant le panneau de verre
pencolor(1, 0, 0)
pensize(1)
rt(angle1_degre)
bk(100); fd(100)

# Dessin du rayon dans le panneau de verre
lt(angle1_degre); rt(angle2_degre)
fd(distance_milieu2)

# Dessin du rayon sortant du panneau de verre
lt(angle2_degre); rt(angle1_degre)
fd(100)

Exercice 14

Une année commune (qui n'est pas bissextile) contient 31_536_000 secondes.

Écrivez un programme qui commence par définir une variable "seconde" qui contiendra un entier de 0 à 31_536_000 (exclus).

Le programme doit calculer le jour, et l'heure (incluant les minutes) correspondant à cette seconde précise de l'année.

Par exemple, si seconde = 31_535_999 (dernière seconde de l'année), alors le programme affichera:

Jour: 365
Heure: 23 : 59

seconde = 31_535_999

# Complétez le programme

seconde = 31_535_999

# Calcul du nombre de secondes par intervalles
sec_par_minute = 60
sec_par_heure = 60 * sec_par_minute
sec_par_jour = 24 * sec_par_heure

# Nombre de jours complets écoulés
jour = seconde // sec_par_jour + 1 # On compte les jours à partir de 1

# Nombre de secondes écoulées dans ce jour
seconde_du_jour = seconde % sec_par_jour

# Nombre d'heures complètes écoulées
heure = seconde_du_jour // sec_par_heure

# Nombre de secondes écoulées dans cette heure
seconde_de_lheure = seconde_du_jour % sec_par_heure

# Nombre de minutes écoulées dans cette heure
minute = seconde_de_lheure // sec_par_minute

print("Jour:", jour)
print("Heure:", heure, ":", minute)

Exercice 15

Écrivez un programme qui commence par déclarer une variable "nombre" qui contient un nombre entier plus grand que zéro.

Le programme doit afficher au hasard un multiple du nombre entre 0 et 100 (inclus).

Par exemple, si nombre = 24, le programme génèrera un nombre au hasard parmi 0, 24, 48, 72, et 98.

nombre = 24

# Complétez le programme

nombre = 24
multiple = 100 // nombre
resultat = randint(0, multiple) * nombre
print(resultat)

Exercice 16

Utilisez la tortue pour dessiner le drapeau de la République d'Artsakh.

Les dimensions de ce drapeau sont de 240 pixels de large par 120 pixels de haut. Chacun des neufs rectangles blancs mesure un sixième de la largeur du drapeau.

Les couleurs exactes de ce drapeau peuvent être dessinées avec pencolor(0.83, 0, 0.06) (rouge), pencolor(0.15, 0.19, 0.63) (bleu), et pencolor(0.99, 0.66, 0) (orange).

# Paramètres du drapeau
largeur = 240
hauteur = 120
largeur_blanc = largeur / 6
hauteur_blanc = hauteur / 9

# Positionner la tortue
hop()
rt(90)
bk(hauteur / 2)

# Bande rouge
pensize(largeur)
pencolor(0.83, 0, 0.06)
fd(hauteur / 3)

# Bande bleue
pencolor(0.15, 0.19, 0.63)
fd(hauteur / 3)

# Bande jaune
pencolor(0.99, 0.66, 0)
fd(hauteur / 3)

# Repositionner la tortue au centre
hop()
bk(hauteur / 2)
lt(90)

# Rectangles blancs
pencolor(1, 1, 1)
pensize(math.ceil(hauteur_blanc)) # On arrondit le nb de pixels vers le haut

for rectangle in 1, 2, 3, 4, 5, 6, 7, 8, 9:
    y = (5 - rectangle) * hauteur_blanc
    x = abs(5 - rectangle) * largeur_blanc / 2

    # Déplacement à la position du rectangle
    hop(); fd(x, y)
    fd(largeur_blanc)

    # Retour au centre
    hop(); bk(x + largeur_blanc, y)

ht()

Les entrées avec input

On peut utiliser input pour demander à l'utilisateur de fournir des informations au programme.

nom = input("Quel est votre nom? ")
age = input("Quel est votre âge? ")

print("Nom:", nom)
print("Âge:", age)

Conversion de type avec int() et float()

La fonction input retourne toujours une texte, même si l'utilisateur entre un nombre.

Si le programme a besoin d'un nombre, on doit convertir le texte en nombre avec int(x) pour un entier ou float(x) pour un nombre flottant.

Lorsqu'on débogue un programme, il est souvent utile d'afficher le type d'une variable avec la fonction type.

valeur_texte = input("Entrez un nombre: ")
print("Valeur et type avant conversion:", valeur_texte, type(valeur_texte))

valeur_int = int(valeur_texte)
print("Valeur et type après int():", valeur_int, type(valeur_int))

valeur_float = float(valeur_texte)
print("Valeur et type après float():", valeur_float, type(valeur_float))

Exercice 1

Écrivez un programme qui demande à l'utilisateur d'entrer son nom et son âge. Le programme doit afficher un message du type "Bonjour <nom>, vous avez <âge> ans."

nom = input("Quel est votre nom? ")
age = input("Quel est votre âge? ")
print("Bonjour", nom, "! Vous avez", age, "ans.")

Exercice 2

Écrivez un programme qui demande à l'utilisateur d'entrer deux nombres entiers.

Le programme doit afficher la somme, et le produit des deux nombres.

nombre1 = int(input("Entrez le premier nombre entier: "))
nombre2 = int(input("Entrez le deuxième nombre entier: "))

somme = nombre1 + nombre2
produit = nombre1 * nombre2 
print("Somme:", somme)
print("Produit:", produit)

Exercice 3

Le programme dans votre environnement de développement demande à l'utilisateur d'entrer deux nombres flottants et affiche leur moyenne.

Il contient toutefois des erreurs. Corrigez le programme pour qu'il fonctionne correctement.

nombre1 = input("Entrez le premier nombre: ")
nombre2 = input("Entrez le deuxième nombre: ")
moyenne = (nombre1 + nombre2) / 2
print("Moyenne:", moyenne)

nombre1 = float(input("Entrez le premier nombre: "))
nombre2 = float(input("Entrez le deuxième nombre: "))
moyenne = (nombre1 + nombre2) / 2
print("Moyenne:", moyenne)

Instructions conditionnelles

Un programme peut prendre des décisions et exécuter des instructions seulement si une condition est remplie.

On utilise le mot-clé if pour indiquer une condition à tester. Si la condition est vraie, les instructions sous le if sont exécutées.

Par exemple, on peut demander à l'utilisateur d'entrer "oui" ou "non" pour confirmer une action.

solde = 1000
retrait = 200

confirmer = input("Confirmer?: ")

if confirmer == "oui":
    solde = solde - retrait
    print("Retrait effectué, il reste", solde, "$ dans le compte.")

if confirmer == "non":
    print("Retrait annulé, il reste", solde, "$ dans le compte.")

Exercice 4

Écrivez un programme qui demande à l'utilisateur d'entrer son nom.

Si l'utilisateur entre son nom, le programme doit afficher "Bonjour <nom> !" où <nom> est le nom entré.

Si l'utilisateur n'entre rien (ou appuie sur Annuler), le programme doit afficher "Bonjour personne inconnue!".

nom = input("Entrez votre nom: ")

if nom != "":
    print("Bonjour", nom, "!")

if nom == "":
    print("Bonjour personne inconnue!")

Instructions conditionnelles avec else

On peut aussi utiliser le mot-clé else pour indiquer des instructions à exécuter si la condition d'un if est fausse.

Par exemple, on peut demander à l'utilisateur de confirmer une action, et exécuter l'action seulement s'il répond "oui". Sinon, on annule l'action.

solde = 1000
retrait = 200

confirmer = input("Confirmer?: ")

if confirmer == "oui":
    solde = solde - retrait
    print("Retrait effectué, il reste", solde, "$ dans le compte.")
else:
    print("Retrait annulé, il reste", solde, "$ dans le compte.")

Exercice 5

Écrivez un programme qui demande à l'utilisateur d'entrer un mot de passe. Si le mot de passe est correct, le programme doit afficher "Accès accordé!". Sinon, le programme doit afficher "Accès refusé...".

Le mot de passe est "python123", gardez le secret!

mot_de_passe = input("Entrez le mot de passe: ")

if mot_de_passe == "python123":
    print("Accès accordé!")
else:
    print("Accès refusé...")

Instructions conditionnelles avec elif

Si la condition d'un if est fausse, on peut utiliser le mot-clé elif (contraction de else if) pour tester une autre condition.

Seul les instructions sous le premier if ou elif dont la condition est vraie seront exécutées.

Par exemple, on peut demander à l'utilisateur de confirmer une action et exécuter des instructions différentes si la réponse est "oui", "non", ou une réponse invalide.

solde = 1000
retrait = 200

confirmer = input("Confirmer?: ")

if confirmer == "oui":
    solde = solde - retrait
    print("Retrait effectué, il reste", solde, "$ dans le compte.")
elif confirmer == "non":
    print("Retrait annulé, il reste", solde, "$ dans le compte.")
else:
    print("Entrée invalide, le retrait est annulé.")

Exercice 6

Écrivez un programme qui demande trois entrées à l'utilisateur: une opération ("+", "-", "*", ou "/"), et deux nombres flottants.

Le programme doit effectuer l'opération demandée sur les deux nombres et afficher le résultat. Si l'opération n'est pas reconnue, le programme doit afficher "Opération invalide".

operation = input("Entrez une opération (+, -, *, /): ")
nombre1 = float(input("Entrez le premier nombre: "))
nombre2 = float(input("Entrez le deuxième nombre: "))

if operation == "+":
    resultat = nombre1 + nombre2
    print("Résultat:", resultat)
elif operation == "-":
    resultat = nombre1 - nombre2
    print("Résultat:", resultat)
elif operation == "*":
    resultat = nombre1 * nombre2
    print("Résultat:", resultat)
elif operation == "/":
    resultat = nombre1 / nombre2
    print("Résultat:", resultat)
else:
    print("Opération invalide")

Les opérations de comparaison

Les opérations de comparaison permettent de comparer deux valeurs.

a = 10
b = 20

if a == b:
    print(a, "est égal à", b)
elif a < b:
    print(a, "est plus petit que", b)
else:
    print(a, "est plus grand que", b)

Voici les opérateurs de comparaison:

Les opérateurs de comparaison peuvent comparer des nombres ou des textes. Si les valeurs sont des types, l'ordre alphabétique est utilisé pour les comparer.

Les valeurs booléennes: True et False

Les opérations de comparaison retournent des valeurs booléennes: True (vrai) ou False (faux).

Ces valeurs peuvent être stockées dans des variables et manipulées comme n'importe quelle autre valeur.

a = 10
b = 20

resultat = a < b
print("a < b:", resultat)

On peut aussi créer des valeurs booléennes directement en utilisant les mots-clés True et False. On peut même vérifier leur type avec type.

booleen = True
print("Un booléen:", booleen)
print("Type d'un booléen:", type(booleen))

Exercice 7

Écrivez un programme qui demande à l'utilisateur d'entrer un notes en pourcentage (entre 0 et 100).

Le programme doit afficher la lettre correspondante selon l'échelle suivante:

note = int(input("Entrez votre note (0-100): "))

if note == 100:
    print("A+")
elif note >= 90:
    print("A")
elif note >= 80:
    print("B")
elif note >= 70:
    print("C")
elif note >= 60:
    print("D")
else:
    print("E")

Exercice 8

Écrivez un programme qui demande à l'utilisateur d'entrer un nombre entier.

Le programme doit afficher "pair" si le nombre est pair, et "impair" sinon.

nombre = int(input("Entrez un nombre entier: "))

if nombre % 2 == 0:
    print("pair")
else:
    print("impair")

Exercice 9

Écrivez un programme qui dessine le drapeau du Libéria en utilisant la tortue.

Les dimensions de ce drapeau sont de 285 de largeur et 150 de hauteur.

Pour dessiner une étoile, utilisez l'instruction regpoly(-5) de la tortue. La taille de l'étoile dépend de la valeur donnée à pensize avant d'appeler regpoly. Pour ce drapeau, utilisez un cinquième de la hauteur comme taille.

Les couleurs utilisées sont pencolor(0.68, 0.18, 0.21) (rouge), et pencolor(0.06, 0.15, 0.4) (bleu).

# dimensions du drapeau
largeur = 285
hauteur = 150

hauteur_ligne = hauteur / 11

# dessiner les 11 lignes
rt(90)
hop()
bk(hauteur / 2)
pensize(largeur)

for ligne in 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11:
    if ligne % 2 == 1:
        pencolor(0.68, 0.18, 0.21)
    else:
        pencolor(1, 1, 1)
        
    fd(hauteur_ligne)

# dessiner le carré bleu
hop()
bk(hauteur_ligne * 8.5, largeur / 2)

lt(90)
carre = 5 * hauteur_ligne
pencolor(0.06, 0.15, 0.4)
pensize(5 * hauteur_ligne)
fd(carre)
bk(carre / 2)

# dessiner l'étoile blanche
pencolor(1, 1, 1)
rt(18)
pensize(carre / 5)
regpoly(-5)

ht()

Les opérations logiques: `and` et `or`

Les opérateurs logiques or (ou) et and (et) permettent de combiner des expressions booléennes.

L'opération test1 or test2 retourne True si au moins une des expressions est vraie.

print("True  or True  =", True or True)   # True
print("True  or False =", True or False)  # True
print("False or True  =", False or True)  # True
print("False or False =", False or False) # False

L'opération test1 and test2 retourne True si les deux expressions sont vraies.

print("True  and True  =", True and True)   # True
print("True  and False =", True and False)  # False
print("False and True  =", False and True)  # False
print("False and False =", False and False) # False

Les opérations logiques: `not`

L'opérateur logique not (non) retourne True si l'expression est fausse, et False si l'expression est vraie.

print("not True  =", not True)   # False
print("not False =", not False)  # True

Exercice 10

Dans une ville, le transport en commun est gratuit pour les enfants de moins de 12 ans et pour les aînés de 65 ans et plus. Les autres personnes doivent payer le tarif régulier de 2.50$.

Écrivez un programme qui demande à l'utilisateur d'entrer son âge. Le programme doit afficher "Gratuit!" si l'utilisateur peut utiliser le transport en commun gratuitement, et "Tarif régulier: 2.50$" sinon.

age = int(input("Entrez votre âge: "))

if age < 12 or age >= 65:
    print("Gratuit!")
else:
    print("Tarif régulier: 2.50$")

Exercice 11

Écrivez un intelligence artificielle très simple qui conseille à un humain s'il doit prendre un parapluie.

Le programme doit poser deux questions à l'utilisateur:

• Est-ce qu'il pleut?
• Est-ce que tu veux rester au sec?

Si l'utilisateur répond "non" à l'une des deux questions, le programme doit afficher "Pas besoin de parapluie.".

Si l'utilisateur répond "oui" aux deux questions, le programme doit afficher "Prends un parapluie.".

Par exemple, si l'utilisateur répond "non" à la première question, le programme doit afficher "Pas besoin de parapluie." sans poser la deuxième question.

if input("Est-ce qu'il pleut?") == "non":
    print("Pas besoin de parapluie.")
elif input("Est-ce que tu veux rester au sec?") == "non":
    print("Pas besoin de parapluie.")
else:
    print("Prends un parapluie.")

if (input("Est-ce qu'il pleut?") == "oui" and
    input("Est-ce que tu veux rester au sec?") == "oui"):
    print("Prends un parapluie.")
else:
    print("Pas besoin de parapluie.")

Résumé

Entrées avec input.

Conversion de type.

Opérateurs de comparaison.

Opérateurs logiques.

Instructions conditionnelles.

if note >= 90:
    print('A')

elif note >= 80:
    print('B')

else:
    print('C')

Instructions de la tortue

Exercice 12

Si un nombre se trouve entre 8 et 120 inclusivement, alors il est toujours premier s'il n'est pas divisible par 2, 3, 5, ou 7.

Écrivez un programme qui demande à l'utilisateur d'entrer un nombre entier entre 8 et 120.

Le programme doit afficher "Premier" si le nombre est premier. Sinon, le programme doit afficher "Divisible par n", où n est le plus petit des nombres 2, 3, 5, ou 7 par lequel le nombre est divisible.

Si le nombre entré n'est pas entre 8 et 120, le programme doit afficher "Je ne sais pas...".

nombre = int(input("Entrez un nombre entier entre 8 et 120: "))

if nombre < 8 or nombre > 120:
    print("Je ne sais pas...")
elif nombre % 2 == 0:
    print("Divisible par 2")
elif nombre % 3 == 0:
    print("Divisible par 3")
elif nombre % 5 == 0:
    print("Divisible par 5")
elif nombre % 7 == 0:
    print("Divisible par 7")
else:
    print("Premier")

Exercice 13

Un programme de virement bancaire vérifie si le solde du compte est suffisant pour effectuer un virement et s'assure que le montant entré est valide, c'est-à-dire un nombre positif.

Écrivez un programme qui commence par la définition d'une variable solde contenant le solde du compte (par exemple 1000$).

Le programme doit demander à l'utilisateur d'entrer le montant du virement.

Si le montant est négatif, le programme doit afficher "Montant invalide.".

Si le montant est supérieur au solde, le programme doit afficher "Fonds insuffisants.".

Autrement le programme affiche "Virement effectué." et met à jour le solde du compte.

Dans tous les cas, le programme doit afficher le solde restant après la tentative de virement.

solde = 1000
montant = float(input("Entrez le montant du virement: "))

if montant < 0:
    print("Montant invalide.")
elif montant > solde:
    print("Fonds insuffisants.")
else:
    solde = solde - montant
    print("Virement effectué.")

print("Solde restant:", solde, "$")

Exercice 14

On peut trouver les zéro de $a{x}^2+bx+c$ avec l'équation des zéros d'une fonction quadratique.

Il y a trois possibilités selon le signe du terme $(b^2-4ac)$ , appelé le discriminant:

1. Positif: il y a deux zéros réels distincts.
2. Égal à zéro: il y a un seul zéro réel.
3. Négatif: il n'y a pas de zéro réel.

Écrivez un programme qui commence par la définition des variables a, b, et c. Le programme doit afficher le ou les zéros réels de l'équation quadratique, ou "aucun" s'il n'y en a pas.

a = 1
b = -3
c = 2

# Complétez le programme

a = 1
b = -3
c = 2

discriminant = b**2 - 4 * a * c

if discriminant > 0:
    racine1 = (-b + math.sqrt(discriminant)) / (2 * a)
    racine2 = (-b - math.sqrt(discriminant)) / (2 * a)
    print(racine1, racine2)
elif discriminant == 0:
    racine = -b / (2 * a)
    print(racine)
else:
    print("aucun")

Exercice 15

Une année bissextile contient un jour supplémentaire (29 février) pour compenser le fait que la Terre ne met pas exactement 365 jours pour faire le tour du Soleil.

Une année est bissextile si:

• elle est divisible par 4 (bissextile)
• sauf si elle est divisible par 100 (non bissextile)
• à moins qu'elle soit divisible par 400 (bissextile)

Voici quelques exemples:

• 2026 n'est pas bissextile (non divisible par 4)
• 2028 est bissextile (divisible par 4)
• 2100 n'est pas bissextile (divisible par 100)
• 2000 était bissextile (divisible par 100, mais aussi par 400)

Écrivez un programme qui demande à l'utilisateur d'entrer une année (un entier), puis affiche "Année bissextile" si l'année est bissextile, et "Année non bissextile" sinon.

annee = int(input("Entrez une année: "))

if (annee % 4 == 0 and annee % 100 != 0) or (annee % 400 == 0):
    print("Année bissextile")
else:
    print("Année non bissextile")

Exercice 16

La vitesse de libération d'un corps céleste, par exemple une planète comme la Terre, est la vitesse minimale qu'un objet doit atteindre pour s'échapper de son attraction gravitationnelle. On utilise l'équation suivante pour calculer la vitesse de libération en mètres par seconde:

où $G$ est la constante gravitationnelle, $M$ est la masse du corps céleste, $R$ est son rayon (en mètres), et $h$ est l'altitude de l'objet (en mètres). Le résultat $v$ est la vitesse de libération en mètres par seconde.

La constante gravitationnelle est 6.674e-11. La masse de la Terre est 5.972e24 kg et son rayon est d'environ 6.378e6 m.

Écrivez un programme qui servira de système de bord à une fusée. Le programme doit demander deux entrées à l'astronaute aux commandes:

• l'altitude de la fusée en kilomètres
• la vitesse de la fusée en km/s

Le système de bord doit déterminer si la fusée peut s'échapper de l'attraction gravitationnelle de la Terre. Il doit afficher "C'est parti!" si la fusée peut s'échapper, et "Encore un peu de puissance..." sinon.

G = 6.674e-11
masse_terre = 5.972e24 # kg
rayon_terre = 6.378e6 # m

# Complétez le programme

G = 6.674e-11
masse_terre = 5.972e24 # kg
rayon_terre = 6.378e6 # m

altitude = float(input("Altitude de la fusée (km): ")) * 1000  # m
vitesse_fusee = float(input("Vitesse de la fusée (km/s): ")) * 1000  # m/s

liberation = math.sqrt((2 * G * masse_terre) / (rayon_terre + altitude)) # m/s

if vitesse_fusee >= liberation:
    print("C'est parti!")
else:
    print("Encore un peu de puissance...")

Exercice 17

Un robot botanique arrose automatiquement les plantes dans un champs. Le robot possède trois senseurs:

• un capteur d'humidité du sol (0 à 100%)
• un capteur de température (en °C)
• un capteur de lumière (en lux, une unité de luminosité)

Pour s'assurer que les plantes poussent bien, le robot doit arroser si:

• l'humidité du sol est inférieure à 30%
• la température est supérieure à 20°C
• la lumière ambiante est supérieure à 50 000 lux

Toutefois, si l'humidité du sol tombe sous 10%, le robot doit arroser peu importe la température et la lumière.

Écrivez un programme qui commence par la définition de trois variables: humidite, temperature, et lumiere. Le programme doit afficher "Arroser les plantes" si le robot doit arroser, et "Ne pas arroser" sinon.

humidite = 25
temperature = 22
lumiere = 25000

# Complétez le programme

humidite = 25
temperature = 22
lumiere = 25000

if (humidite < 30 and temperature > 20 and lumiere > 50_000) or humidite < 10:
    print("Arroser les plantes")
else:
    print("Ne pas arroser")

Exercice 18

Écrivez un programme qui choisit un nombre entier aléatoire de 1 à 6 représentant le lancer d'un dé.

Utilisez la tortue pour dessiner le face du dé correspondant au nombre choisi.

Par exemple, si le nombre est 3, le programme doit dessiner ce dé:

if nombre == 1:
    # dessiner la face 1
elif nombre == 2:
    # dessiner la face 2
elif nombre == 3:
    # dessiner la face 3
...

nombre = randint(1, 6)

cote = 80
coord_point = cote / 2
point = cote / 4

regpoly(4, cote)  # dessiner le carré du dé

pensize(point)

# point au centre
if nombre == 1 or nombre == 3 or nombre == 5:
    regpoly()

if nombre >= 2:
    # points en haut à gauche
    hop(); bk(coord_point, -coord_point)
    regpoly()

    # points en bas à droite
    hop(); fd(2*coord_point, -2*coord_point)
    regpoly()
    hop(); bk(coord_point, -coord_point)

if nombre >= 4:
    # points en haut à droite
    hop(); fd(coord_point, coord_point)
    regpoly()
    hop(); bk(2*coord_point, 2*coord_point)

    # points en bas à gauche
    regpoly()
    hop(); fd(coord_point, coord_point)

if nombre == 6:
    # points au milieu à gauche
    hop(); bk(coord_point)
    regpoly()

    # points au milieu à droite
    hop(); fd(2*coord_point, 0)
    regpoly()
    hop(); bk(2*coord_point, 0)

ht()

Exercice 19

Utilisez la tortue pour dessiner le drapeau de la Grèce.

Les dimensions de ce drapeau sont de 240 pixels de large par 160 pixels de haut. La teinte de bleue utilisée est obtenue avec pencolor(0.18, 0.36, 0.66).

largeur = 240
hauteur = 160

hauteur_ligne = hauteur / 9

rt(90)
hop(); bk(hauteur / 2)
pensize(largeur)

# Dessin des neuf lignes
for ligne in 1, 2, 3, 4, 5, 6, 7, 8, 9:
    if ligne % 2 == 0:
        pencolor(1, 1, 1)
    else:
        pencolor(0.18, 0.36, 0.66)
    
    fd(hauteur_ligne)

# Placement pour le carré
hop()
bk(hauteur_ligne * 6.5,  largeur / 2)
lt(90)

cote_carre = 5 * hauteur_ligne

# Dessin du carré
pencolor(0.18, 0.36, 0.66)
pensize(cote_carre)
fd(cote_carre)

# Dessin de la croix blanche
pencolor(1, 1, 1)
pensize(hauteur_ligne)
bk(cote_carre)
fd(cote_carre / 2)
rt(90)
fd(cote_carre / 2)
bk(cote_carre)

ht()

Retiré

Ce chapitre a été retiré de cet échantillon.

Retiré

Ce chapitre a été retiré de cet échantillon.

Retiré

Ce chapitre a été retiré de cet échantillon.

Retiré

Ce chapitre a été retiré de cet échantillon.

Retiré

Ce chapitre a été retiré de cet échantillon.

Retiré

Ce chapitre a été retiré de cet échantillon.