Programmation
#0 - L’environnement
Quel environnement ?
- Local vs server
- en local sur votre ordinateur pour le dev
- Operating System
- Windows
- Linux
- Environnement spécifique au language
- outils / logiciels qui permettent la compilation du code
- IDE
- un logicil où on écrit les lignes de code
- un IDE universel
- VSCODE
- un IDE universel
- un logicil où on écrit les lignes de code
Front-end vs Back-end
1 - Les languages
#0 - Règles de gestion et algorithme
Toute programmation doit commencer par les règles de gestion (on peut faire un schéma) et un algorithme.
#2 - Python
Faire du Python sur internet :
Avec Jypyter
Avec Google Colab
Installer Python en local
- Windows
- https://www.python.org/downloads/, vérifier la compatibilité avec votre OS ;)
Écrire et exécuter un programme
Avec IDLE
- Chercher l’application IDLE dans le champ de recherche
- >>> est l’invite de commande
- Ecrire le programme et le sauvegarder
- File / New File
- Ecrire
print("hello")
- Ecrire
- File / save
- File / New File
- Exécuter le programme
- Run / Run module
- Pour ouvrir le Shell
- Run / Python shell
- un icone sur le bureau avec ton programme est créé
Un exercice pour un exemple
Énoncé
- Imaginons que tu creuses dans le fond du jardin et que tu y trouves un sac contenant 20 pièces d'or.
- Le lendemain, tu te faufiles à la cave pour les placer dans la machine a dupliquer a vapeur de ton génial inventeur de grand-père (par chance, les 20 pièces y rentrent parfaitement). Tu entends un sifflement et quelques bruits bizarres et quelques heures plus tard, en sortent 10 nouvelles pièces étincelantes.
- Combien de pièces aurais-tu dans ton coffre à trésor si tu faisais cela chaque jour pendant un an ?
- Sur le papier, les formules pour le calculer ressembleraient à ceci :
10 × 365 = 3 650 fabriquées sur une année
20 + 3 650 = 3 670 pièces
- Sur le papier, les formules pour le calculer ressembleraient à ceci :
- Et maintenant, que se passe-t-il si un corbeau découvre ton trésor et entre chaque semaine dans ta chambre pour voler 3 pièces?
- Au bout d'une année de ce jeu-là, combien te resterait-il de pièces ?
- Sur le papier, les formules pour le calculer ressembleraient à ceci :
3 x 52 = 156 pièces volées sur une année
3670 - 156 = 3514 pièces restantes
- Sur le papier, les formules pour le calculer ressembleraient à ceci :
- Maintenant imaginons qu’au bout de 6 mois tu places un épouvantail devant ta fenêtre. Le corbeau a plus de difficulté pour voler tes pièces. Il ne peut en voler que 2 part semaine.
- Combien de pièce te resterait-il si une moitié de l’année tu n’as pas d’épouvantail et l’autre moitié de l’année, tu as un épouvantail
- Sur le papier, les formules pour le calculer ressembleraient à ceci :
3 x 26 = 78 pièces volées pour les 6 mois sans épouvantail
2 x 26 = 52 pièces volées pour les 6 mois avec épouvantail
3670 - 78 - 52 = 3540 pièces restantes
- Sur le papier, les formules pour le calculer ressembleraient à ceci :
- Écris l’algorithme qui consiste à calculer le nombre de pièce restante
- d’abord afficher le nombre de pièce restante au bout d’un an
- ensuite pour chaque semaine de l’année, sous la forme
- “Semaine numéro 1 = 97 pièces restantes / 80 pièces fabriquées / 3 pièces volées”
- !! attention 52 semaines à 7 jours donne 364 et non 365
- Ensuite écris le programme en Python à partir de l’algorithme
Résultat
PROGRAMME fabriquer_pieces
VAR
pieces_trouvees : ENTIER
pieces_magiques : ENTIER
pieces_volees : ENTIER
nombre_de_pieces : ENTIER
semaine : ENTIER
DEBUT
ECRIRE ("Veuillez entrer le nombre de pièces trouvées : ")
pieces_trouvees <- LIRE()
ECRIRE ("Veuillez entrer le nombre de pièces fabriquées par jours avec la machine de grand-père : ")
pieces_magiques <- LIRE()
ECRIRE ("Veuillez entrer le nombre de pièces volées chaque semaine sans épouvantail : ")
pieces_volees <- LIRE()
nombre_de_pieces = (pieces_trouvees) + (pieces_magiques * 365) - (pieces_volees * 26) - ((pieces_volees - 1) * 26)
ECRIRE ("Le nombre de pièces restante à la fin de l'année = ", nombre_de_pieces)
nombre_de_pieces = pieces_trouvees
POUR i ALLANT de 1 à 52 AU PAS DE 1
FAIRE
SI semaine = 1
ALORS
nombre_de_pieces = nombre_de_pieces + ((pieces_magiques * 7)+10) - pieces_volees
ECRIRE ("semaine numéro ", semaine, " = ", nombre_de_pieces, " pièces restantes / ", (pieces_magiques * 7)+10, " pièces fabriquées / ",pieces_volees, " pièces volées")
SINON
SI semaine > 2 ET semaine < 27
ALORS
nombre_de_pieces = nombre_de_pieces + ((pieces_magiques * 7)) - pieces_volees
ECRIRE ("semaine numéro ", semaine, " = ", nombre_de_pieces, " pièces restantes / ", (pieces_magiques * 7), " pièces fabriquées / ",pieces_volees, " pièces volées")
SINON
nombre_de_pieces = nombre_de_pieces + ((pieces_magiques * 7)) - (pieces_volees - 1)
ECRIRE ("semaine numéro ", semaine, " = ", nombre_de_pieces, " pièces restantes / ", (pieces_magiques * 7), " pièces fabriquées / ",(pieces_volees-1), " pièces volées")
FINSI
FINSI
FINPOUR
FIN
print("-------------------")
print("PROGRAMME DE JULIE")
print("-------------------")
# On demande le nombre de pièces trouvées au départ
pieces_trouvees = int(input("Veuillez entrer le nombre de pièces trouvées : "))
print("La variable \"pieces_trouvees\" est égale à = ",pieces_trouvees)
# On demande le nombre de pièces fabriquées par jours avec la machine de grand-père
pieces_magiques = int(input("Veuillez entrer le nombre de pièces fabriquées par jours avec la machine de grand-père : "))
# pour répéter 25 fois un caractère
espaces = ' ' * 5
print(f"{espaces}La variable \"pieces_magiques\" est égale à = {pieces_magiques} pièces")
# On demande le nombre de pièces volées chaque semaine sans épouvantail
pieces_volees = int(input("Veuillez entrer le nombre de pièces volées chaque semaine sans épouvantail : "))
print("La variable \"pieces_volees\" est égale à = ",pieces_volees)
# calcul du nombre de pièces restantes
nombre_de_pieces = pieces_trouvees + pieces_magiques * 365 - pieces_volees * 52
print("La variable \"nombre_de_pieces\" est égale à =",nombre_de_pieces)
# on a mis un épouvantail devant la fenêtre, alors 1 corbeau est effrayé et il n'y a plus que 2 vol de pièces par semaine
print("La variable \"pieces_volees\" est égale à =",pieces_volees)
# calcul du nombre de pièces restantes avec 6 mois à 3 pièces volées et 6 mois à 2 pièces volées
nombre_de_pieces = (pieces_trouvees) + (pieces_magiques * 365) - (pieces_volees * 26) - ((pieces_volees - 1) * 26)
# On va afficher le nombre de pièces restantes par semaine
nombre_de_pieces = pieces_trouvees
print(f"{espaces}La variable \"nombre_de_pieces\" est égale à = {nombre_de_pieces} pièces")
for semaine in range(1, 53):
if semaine == 1:
nombre_de_pieces = nombre_de_pieces + ((pieces_magiques * 7)+10) - pieces_volees
print(f"Semaine numéro(1) {semaine} = {nombre_de_pieces} pièces restantes / {(pieces_magiques * 7)+10} pièces fabriquées / {pieces_volees} pièces volées")
elif semaine > 1 and semaine < 27:
nombre_de_pieces = nombre_de_pieces + ((pieces_magiques * 7)) - pieces_volees
print(f"Semaine numéro(2 à 26) {semaine} = {nombre_de_pieces} pièces restantes / {pieces_magiques * 7} pièces fabriquées / {pieces_volees} pièces volées")
else:
nombre_de_pieces = nombre_de_pieces + ((pieces_magiques * 7)) - (pieces_volees - 1)
print(f"Semaine numéro(27 à 52) {semaine} = {nombre_de_pieces} pièces restantes / {pieces_magiques * 7} pièces fabriquées / {pieces_volees-1} pièces volées")
print("La variable \"nombre_de_pieces\", après avoir installé un épouvantail, est égale à = ",nombre_de_pieces)
print("-------------------")
print("FIN DU PROGRAMME DE JULIE")
print("-------------------")
Turtle
Dessin à inventer
import turtle # bibliothèque turtle
# Taille du canva & placer le canva sur l'écran
turtle.setup(width=500, height=500, startx=0, starty=0) #taille et placement de la fenêtre
espace_dessin = turtle.Turtle() #appel de la fonction "Turtle" du module "turtle" pour créer un canevas (espace vide dans lequel on dessine)
# Lever le stylo pour éviter de dessiner pendant le déplacement
# espace_dessin.penup()
# Cacher la tortue pour ne pas voir la fleche
#espace_dessin.hideturtle()
# La tortue commence au centre (0, 0) d'un plan cartésien x-y
# Le point (x, y) en haut à gauche est (-width/2, height/2)
# espace_dessin.goto(-turtle.window_width()//2, turtle.window_height()//2)
# Redescendre le stylo pour commencer à dessiner
# espace_dessin.pendown()
# definir la vitesse de la tortue de 1 à 10
espace_dessin.speed(1)
# Épaisseur du trait de 1 à 10
espace_dessin.width(5)
# couleur mode
# Configurer le mode de couleur pour accepter des valeurs de 0 à 255
turtle.colormode(255) # permet d'utiliser les valeurs RGB entre 0 et 255.
# le dessin commence à (0,0) selon x,y
espace_dessin.forward(50) # forward : se déplace en face d'elle d'une distance en pixel
espace_dessin.left(90) # Tourne la tortue à gauche d'une valeur en degrés
espace_dessin.forward(50)
espace_dessin.write("Un rond violet", font=("Arial", 24, "normal"))
espace_dessin.begin_fill()
espace_dessin.fillcolor(123, 104, 238)
espace_dessin.circle(20)
espace_dessin.end_fill()
espace_dessin.forward(50)
espace_dessin.pencolor("pink")
espace_dessin.circle(20,90)
espace_dessin.forward(50)
espace_dessin.dot(10,"red")
espace_dessin.penup() # lever le crayon
espace_dessin.goto(150,150) # se déplacer à une coordonnée
espace_dessin.pendown() #reposer le crayon
#espace_dessin.colormode(n) # Initialise le format RGB, n est l'intensité maximale
espace_dessin.pencolor("blue") #color name
espace_dessin.forward(10)
espace_dessin.begin_fill()
espace_dessin.forward(50)
espace_dessin.left(90)
espace_dessin.forward(50)
espace_dessin.left(90)
espace_dessin.forward(50)
espace_dessin.left(90)
espace_dessin.forward(50)
espace_dessin.fillcolor("#1E90FF")
espace_dessin.end_fill()
espace_dessin.write("Un carré bleu", font=("Arial", 14, "normal"))
# Terminer le dessin
turtle.done()
Dessine une fleur
import turtle
# Configurer la fenêtre de dessin
turtle.setup(width=800, height=600)
espace_dessin = turtle.Turtle()
# Paramètres de la tortue
espace_dessin.speed(4)
espace_dessin.width(2) # épaisseur du trait
# Fonction pour dessiner un pétale
def dessiner_petale():
for i in range(2):
espace_dessin.circle(100, 60) # Demi-cercle
espace_dessin.left(120)
# Dessiner une fleur avec plusieurs pétales
espace_dessin.color("red")
for i in range(6):
dessiner_petale()
espace_dessin.right(60)
# Dessiner le centre de la fleur
espace_dessin.penup()
espace_dessin.goto(0, -20)
espace_dessin.pendown()
espace_dessin.color("yellow")
espace_dessin.begin_fill()
espace_dessin.circle(20)
espace_dessin.end_fill()
# Dessiner la tige de la fleur
espace_dessin.penup()
espace_dessin.goto(0, -20)
espace_dessin.setheading(-90) # Orienter vers le bas
espace_dessin.pendown()
espace_dessin.color("green")
espace_dessin.forward(200)
# Dessiner les feuilles
espace_dessin.setheading(-45)
espace_dessin.begin_fill()
espace_dessin.circle(50, 90)
espace_dessin.left(90)
espace_dessin.circle(50, 90)
espace_dessin.end_fill()
espace_dessin.setheading(-135)
espace_dessin.penup()
espace_dessin.goto(0, -100)
espace_dessin.pendown()
espace_dessin.begin_fill()
espace_dessin.circle(50, 90)
espace_dessin.left(90)
espace_dessin.circle(50, 90)
espace_dessin.end_fill()
# Cacher la tortue
espace_dessin.hideturtle()
# Terminer le dessin
turtle.done()
Créer du mouvement avec la balle
import turtle
# Configuration de l'écran
screen = turtle.Screen()
screen.title("Animation de la balle avec Turtle")
screen.bgcolor("white")
screen.setup(width=600, height=600)
# Créer la balle
balle = turtle.Turtle()
balle.shape("circle")
balle.color("blue")
balle.penup() # Ne pas dessiner la trace
balle.speed(3) # Vitesse maximale pour le mouvement lisse
# Définir la vitesse initiale de la balle
vx = 6 # Vitesse sur l'axe x
vy = 6 # Vitesse sur l'axe y
# Définir un temps maximum pour arrêter l'animation (en millisecondes)
temps_max = 5 * 1000 # 60 secondes en millisecondes
temps_ecoule = 0 # Compteur pour le temps écoulé
# Fonction pour déplacer la balle
def deplacer_balle():
global vx, vy, temps_ecoule
# Obtenir les coordonnées actuelles de la balle
x, y = balle.xcor(), balle.ycor()
# Calculer les nouvelles coordonnées
x += vx
y += vy
# Vérifier les collisions avec les bords
if x > 290 or x < -290: # Collision avec les côtés gauche ou droit
vx = -vx # Inverser la direction horizontale
if y > 290 or y < -290: # Collision avec le haut ou le bas
vy = -vy # Inverser la direction verticale
# Déplacer la balle à sa nouvelle position
balle.setx(x)
balle.sety(y)
# Augmenter le temps écoulé à chaque appel
temps_ecoule += 40 # Ajout de 20 ms (le délai défini dans ontimer)
# Continuer l'animation tant que moins de temps_max se sont écoulées
if temps_ecoule < temps_max:
screen.ontimer(deplacer_balle, 10) # Refaire cette action dans 20 ms
else:
print("Fin de l'animation.")
# balle.goto(0, 0) # Amener la tortue au centre de l'écran
balle.clear()
balle.hideturtle() # Cacher la tortue (balle)
balle.write("Fin de l'animation !", align="center", font=("Arial", 16, "normal")) # Écrire sur la fenêtre
screen.ontimer(screen.bye, 5000) # Fermer la fenêtre après 3 secondes
# Démarrer l'animation
deplacer_balle()
# Maintenir la fenêtre ouverte
screen.mainloop()
Les fonctions
- Une fonction réalise un calcul et renvoie le résultat. Elle peut être appelée à plusieurs reprise par un programme.
- Par exemple : faire une fonction qui donne le tarif en fonction de la saison en cours
fonction calcul_tarif(pain_nom, achat_date)
- Lors d’un appel à la fonction des valeurs particulières (arguments) sont données à la fonction (ici le nom du pain et la date d’achat)
API
Exercices
Attaque de Ninjas
Crée une instruction if qui affiche «Il y en a trop» si la variable ninjas contient un nombre inférieur à 50, qui affiche «Je vais devoir me battre mais je peux les avoir» s’il est inférieur à 30, et qui affiche « Je peux affronter ces ninjas!» s’il est inférieur à 10.
Teste ton code avec : ninjas = 5
Résultat
Cet exercice contient un piège ! Es-tu tombé dedans ? Si tu relis
l’énoncé de l’exercice et écris l’instruction if dans l’ordre indiqué, tu
risques de ne pas obtenir les résultats auxquels tu t’attends. Voyons
cela :
>>> ninjas = 5
>>> if ninjas < 50:
print("Il y en a trop")
elif ninjas < 30:
print("Je vais devoir me battre mais je peux les avoir ")
elif ninjas < 10:
print("Je peux affronter ces ninjas !")
Il y en a trop
Même si le nombre de ninjas est plus petit que 10, tu reçois tou-
jours le message « Il y en a trop ». Ceci est dû au fait que la première
condition, < 50, est évaluée en premier lieu. Autrement dit, Python la
vérifie d’abord, avant les autres. Or, comme la valeur de la variable
est bel et bien plus petite que 50, le programme affiche le message
auquel tu ne t’attendais pas.
Pour que les vérifications se fassent dans le bon ordre, il faut
inverser l’ordre du code précédent, pour vérifier d’abord que la
variable est plus petite que 10, puis que 30, puis que 50 :
>>> ninjas = 5
>>> if ninjas < 10:
print("Je peux affronter ces ninjas !")
elif ninjas < 30:
print("Je vais devoir me battre mais je peux les avoir ")
elif ninjas < 50:
print("Il y en a trop")
Je peux affronter ces ninjas !
Ton âge
Crée une boucle qui n’affiche que les nombres pairs (2, 4, 6, etc.) jusqu’à atteindre ton âge. Ou, si ton âge est un nombre impair (1, 3, 5, etc.), n’affiche que les nombre impairs jusqu’à ton âge. Par exemple, tu pourrais afficher quelque chose comme ceci :
2
4
6
8
10
12
14
Résultat
for x in range(2, 16, 2):
print(x)
Le paramètre pas de la fonction range permet de produire la liste des
nombres pairs. Si tu as 14 ans, par exemple, le paramètre de départ
sera de 2 et le paramètre de fin sera de 16 car la boucle for ne fonc-
tionnera que jusqu’à la valeur juste avant le paramètre de fin.
Ton poids sur la lune
Si tu étais en ce moment sur la Lune, ton poids ne représenterait que 16,5% de celui que tu as sur Terre. Pour le calculer, multiplie ton poids sur Terre par 0,165 (attention au point décimal : 0.165 !).
Supposons que tu prennes un kilo de plus tous les ans pendant les 15 années à venir. Quel serait ton poids sur la Lune lors de tes visites annuelles et au bout des 15 ans? Utilise une boucle for pour afficher ton poids sur la Lune pour chaque année.
Résultat
Pour calculer ton poids en kilogrammes sur la lune sur 15 ans, crée
d’abord une variable pour mémoriser ton poids de départ :
>>> poids = 30
Pour chaque année, tu peux calculer ton nouveau poids en ajou-
tant un kilo, puis multiplier le tout par 16,5 % (0.165), pour connaître
le poids équivalent sur la lune :
>>> poids = 30
>>> for annee in range(1, 16):
poids = poids + 1
poids_sur_lune = poids * 0.165
print("Poids de l'année %s vaut %s" % (annee, poids_sur_lune))
Poids de l'année 1 vaut 5.115
Poids de l'année 2 vaut 5.28
Poids de l'année 3 vaut 5.445
Poids de l'année 4 vaut 5.61
Poids de l'année 5 vaut 5.775
Poids de l'année 6 vaut 5.94
Poids de l'année 7 vaut 6.105
Poids de l'année 8 vaut 6.2700000000000005
Poids de l'année 9 vaut 6.4350000000000005
Poids de l'année 10 vaut 6.6000000000000005
Poids de l'année 11 vaut 6.765000000000001
Poids de l'année 12 vaut 6.930000000000001
Poids de l'année 13 vaut 7.095000000000001
Poids de l'année 14 vaut 7.260000000000001
Poids de l'année 15 vaut 7.425000000000001
Compter le nombre de caractère d’un programme
Conversion binaire
Écrire le programme qui convertit un nombre en binaire et inversement.