Programmation

Langage Python et PHP, cours de Julie Chaumard

#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
Front-end vs Back-end
1 - Les languages
#1 - 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 - Script système et CRON
Script
Windows Powershell
  • Script PowerShell qui copie tous les fichiers avec l'extension .xlsx d'un dossier source vers un dossier cible.
    # Définir le dossier source et le dossier cible
    $sourceFolder = "C:\Chemin\Vers\Source"
    $destinationFolder = "C:\Chemin\Vers\Destination"
    
    # Vérifier si le dossier source existe
    if (-not (Test-Path -Path $sourceFolder)) {
        Write-Output "Le dossier source n'existe pas : $sourceFolder"
        exit
    }
    
    # Vérifier si le dossier cible existe, sinon le créer
    if (-not (Test-Path -Path $destinationFolder)) {
        Write-Output "Le dossier cible n'existe pas, création du dossier : $destinationFolder"
        New-Item -ItemType Directory -Path $destinationFolder | Out-Null
    }
    
    # Copier les fichiers .xlsx
    Get-ChildItem -Path $sourceFolder -Filter "*.xlsx" -File | ForEach-Object {
        $sourceFile = $_.FullName
        $destinationFile = Join-Path -Path $destinationFolder -ChildPath $_.Name
        Write-Output "Copie du fichier : $sourceFile vers $destinationFile"
        Copy-Item -Path $sourceFile -Destination $destinationFile -Force
    }
    
    Write-Output "Copie terminée."
    

    Instructions pour exécuter le script :

    1. Modifier les chemins :
      • Remplacez C:\Chemin\Vers\Source et C:\Chemin\Vers\Destination par les chemins réels de vos dossiers.
    1. Sauvegarder le script :
      • Copiez ce script dans un fichier texte et sauvegardez-le avec l'extension .ps1 (par exemple, CopieFichiers.ps1).
    1. Exécuter le script :
      • Ouvrez PowerShell en tant qu'administrateur.
      • Accédez au répertoire où se trouve le script :
        cd "C:\Chemin\Vers\Le\Script"
      • Exécutez le script :
        .\CopieFichiers.ps1
    • Politique d’exécution : Si PowerShell refuse d'exécuter le script, vous devrez peut-être ajuster la politique d'exécution en utilisant la commande :
      Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

      Étape 2 : Créer la tâche planifiée avec schtasks

      Exécutez la commande suivante dans l'invite de commande (CMD) ou PowerShell pour planifier l'exécution du script :

      cmd
      Copier le code
      schtasks /create /tn "CopieFichiersXLSX" /tr "powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:\Scripts\CopieFichiers.ps1" /sc daily /st 08:00
      
      

      Explication des paramètres :

      • /create : Crée une nouvelle tâche.
      • /tn "CopieFichiersXLSX" : Nom de la tâche dans le Planificateur de tâches.
      • /tr "powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:\Scripts\CopieFichiers.ps1" : Commande à exécuter (ici, PowerShell exécute le script).
        • NoProfile : Évite de charger un profil utilisateur PowerShell.
        • ExecutionPolicy Bypass : Contourne les restrictions de politique d'exécution.
        • File : Chemin du script PowerShell à exécuter.
      • /sc daily : Planifie la tâche pour qu'elle s'exécute tous les jours.
      • /st 08:00 : Spécifie l'heure de l'exécution (ici, 8h00 du matin).

      Étape 3 : Vérifier la tâche

      1. Ouvrez le Planificateur de tâches (taskschd.msc).
      1. Recherchez la tâche nommée CopieFichiersXLSX.
      1. Vérifiez ses propriétés pour confirmer les paramètres.

      Étape 4 : Tester la tâche

      Vous pouvez tester immédiatement la tâche en exécutant cette commande :

      cmd
      Copier le code
      schtasks /run /tn "CopieFichiersXLSX"
      
      

      Cela exécutera la tâche et lancera le script PowerShell immédiatement.


      Étape 5 : Vérification et logs

      Pour vous assurer que la tâche s'est exécutée correctement :

      • Consultez les fichiers dans le dossier cible pour vérifier la copie.
      • Vérifiez les journaux du Planificateur de tâches dans l'onglet Historique.
  • script PowerShell qui supprime tous les fichiers avec l'extension .log

    Script PowerShell

    powershell
    Copier le code
    # Définir le dossier cible
    $targetFolder = "C:\Chemin\Vers\Dossier"
    
    # Vérifier si le dossier cible existe
    if (-not (Test-Path -Path $targetFolder)) {
        Write-Output "Le dossier cible n'existe pas : $targetFolder"
        exit
    }
    
    # Supprimer les fichiers .log
    Get-ChildItem -Path $targetFolder -Filter "*.log" -File -Recurse | ForEach-Object {
        Write-Output "Suppression du fichier : $($_.FullName)"
        Remove-Item -Path $_.FullName -Force
    }
    
    Write-Output "Suppression des fichiers .log terminée."
    
    

    Explications du script :

    1. Définir le dossier cible :
      • Remplacez C:\Chemin\Vers\Dossier par le chemin du dossier où vous voulez supprimer les fichiers .log.
    1. Supprimer les fichiers .log :
      • La commande Get-ChildItem recherche tous les fichiers .log dans le dossier cible et ses sous-dossiers (grâce au paramètre Recurse).
      • Chaque fichier trouvé est supprimé avec la commande Remove-Item -Force.
    1. Logs des suppressions :
      • Le script affiche chaque fichier supprimé dans la console pour un suivi facile.

    Instructions pour exécuter le script :

    1. Sauvegarder le script :
      • Enregistrez-le dans un fichier texte avec l'extension .ps1 (par exemple, SupprimerLogs.ps1).
    1. Exécuter le script :
      • Ouvrez PowerShell en tant qu'administrateur.
      • Accédez au répertoire du script :
        powershell
        Copier le code
        cd "C:\Chemin\Vers\Le\Script"
        
        
      • Lancez le script :
        powershell
        Copier le code
        .\SupprimerLogs.ps1
        
        

    Planification avec schtasks (facultatif)

    Si vous souhaitez exécuter ce script automatiquement avec une tâche planifiée, utilisez cette commande dans un terminal :

    cmd
    Copier le code
    schtasks /create /tn "SuppressionLogs" /tr "powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:\Chemin\Vers\Le\Script\SupprimerLogs.ps1" /sc daily /st 03:00
    
    

    Cela exécutera le script tous les jours à 3h00.


    Remarques :

    • Si vous voulez une suppression uniquement dans le dossier principal sans ses sous-dossiers, retirez le paramètre Recurse de la commande Get-ChildItem.
    • Testez le script avec un dossier de test avant de l'utiliser en production, surtout si les fichiers .log sont importants.
CRON
Windows
  • Ligne de commande

    Options principales de schtasks :

    • /create : Crée une nouvelle tâche.
    • /sc : Spécifie la fréquence (daily, weekly, monthly, etc.).
    • /st : Heure de début.
    • /tr : Chemin vers l'action à exécuter.
    • /tn : Nom de la tâche.
    schtasks /create /sc daily /tn "MonScript" /tr "powershell.exe -File C:\chemin\vers\mon_script.ps1" /st 08:00
  • Tâche planifiée
    • Ouvrir le Planificateur de tâches :
      • Appuyez sur Win + R pour ouvrir la boîte de dialogue "Exécuter".
      • Tapez taskschd.msc et appuyez sur Entrée.
    • Créer une nouvelle tâche :
      • Dans le panneau de droite, cliquez sur Créer une tâche.
      • Donnez un nom à votre tâche et configurez les options générales (comme les droits d'exécution).
    • Définir un déclencheur :
      • Allez dans l'onglet Déclencheurs.
      • Cliquez sur Nouveau... pour définir quand la tâche doit être exécutée (par exemple, tous les jours, chaque semaine, ou selon un horaire personnalisé).
    • Configurer l'action :
      • Allez dans l'onglet Actions.
      • Cliquez sur Nouveau... pour spécifier l'action à effectuer (par exemple, exécuter un script, un programme ou une commande).
    • Définir des conditions supplémentaires (facultatif) :
      • Vous pouvez configurer des conditions telles que l'exécution uniquement si l'ordinateur est alimenté ou si l'utilisateur est connecté.
    • Enregistrer la tâche :
      • Cliquez sur OK pour enregistrer la tâche. Vous devrez peut-être entrer vos identifiants administratifs
#3 - Python
Faire du Python sur internet :
Installer Python en local
É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")
    • File / save
  • Exécuter le programme
    • Run / Run module
  • Pour ouvrir le Shell
    • Run / Python shell
  • un icone sur le bureau avec ton programme est créé

Exercices
Attaque de Ninja

Crée une instruction if qui affiche «Il y en a trop» si la variable Ninja 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 Ninja !» s’il est inférieur à 10.
Teste ton code avec : Ninja = 5

Je vous donne un exemple qui contient une erreur. Nous allons le corriger en l’écrivant de nouveau après

  • 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 :

0

# variable "espace" pour aérer le rendu
espaces = ' ' * 5

# On demande le nombre de Ninja trouvées au départ
ninjas = int(input("Veuillez entrer le nombre de Ninja : "))
print("\nLa variable \"ninjas\" est égale à = ", ninjas,"\n")

if ninjas < 50:
	print(f"{espaces}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 !")

print("\n-------------------")
print("PROGRAMME NINJA QUI CONTIENT UNE ERREUR")
print("-------------------\n")
  • Même si le nombre de Ninja est plus petit que 10, tu reçois toujours 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 :
print("\n-------------------")
print("PROGRAMME NINJA")
print("-------------------\n")

# variable "espace" pour aérer le rendu
espaces = ' ' * 5

# On demande le nombre de Ninja trouvées au départ
ninjas = int(input("Veuillez entrer le nombre de Ninja : "))
print("\nLa variable \"ninjas\" est égale à = ", ninjas,"\n")

if ninjas < 10:
	print(f"{espaces}=> Je peux affronter ces ninjas !")
elif ninjas < 30:
	print(f"{espaces}=> Je vais devoir me battre mais je peux les avoir :)")
elif ninjas < 50:
	print(f"{espaces}=> Il y en a trop :(")

print("\n-------------------")
print("FIN DU PROGRAMME NINJA")
print("-------------------\n")
  • Écrire le programme en ajoutant ce qu’il se passe quand il y a plus de 50 Ninja.
print("\n-------------------")
print("PROGRAMME NINJA")
print("-------------------\n")

# variable "espace" pour aérer le rendu
espaces = ' ' * 5

# On demande le nombre de Ninja trouvées au départ
ninjas = int(input("Veuillez entrer le nombre de Ninja : "))
print("\nLa variable \"ninjas\" est égale à = ", ninjas,"\n")

if ninjas < 10:
	print(f"{espaces}=> Je peux affronter ces ninjas !")
elif ninjas < 30:
	print(f"{espaces}=> Je vais devoir me battre mais je peux les avoir :)")
elif ninjas < 50:
	print(f"{espaces}=> Il y en a trop :(")
else:  # Cas où le nombre de ninjas est supérieur ou égal à 50
    print(f"{espaces}=> Mission impossible, je dois fuir !")

print("\n-------------------")
print("FIN DU PROGRAMME NINJA")
print("-------------------\n")

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

# C'est une boucle qui va se répéter un nombre de fois

range (valeur de départ, valeur de fin exclusive, la pas)
range (2, 16, 2)
range (cela commence à 2, La séquence s'arrête avant d'atteindre 16, À chaque itération, la valeur de x sera augmentée de 2)

# Pour une nombre pair
for x in range(2, 16, 2):
	print(x)

# Pour un nombre impair
for x in range(1, 17, 2):
  print(x)

Écris le programme qui demande l’âge et en fonction si c’est un âge pair ou impair, avance en pair ou impair :

  • comment fait-on pour savoir si un nombre est pair ?
print("\n-------------------")
print("PROGRAMME QUI DONNE DES NOMBRES PAIRS OU IMPAIRS")
print("-------------------\n")

# Demande de l'âge à l'utilisateur
age = int(input("Veuillez entrer votre âge : "))
# Vérifie si l'âge est pair ou impair
if age % 2 == 0:
    print(f"\nVotre âge ({age}) est pair. Nous allons avancer par des nombres pairs.\n")
    # Génère une séquence de nombres pairs à partir de l'âge
    for x in range(2, age + 2, 2):
        print(x)
else:
    print(f"\nVotre âge ({age}) est impair. Nous allons avancer par des nombres impairs.\n")
    # Génère une séquence de nombres impairs à partir de l'âge
    for x in range(1, age + 2, 2):
        print(x)

print("\n-------------------")
print("FIN DU PROGRAMME QUI DONNE DES NOMBRES PAIRS OU IMPAIRS")
print("-------------------\n")

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 “poids” pour mémoriser ton poids de départ.
  • Pour chaque année, tu peux calculer ton nouveau poids en ajoutant un kilo, puis multiplier le tout par 16,5 % (0.165), pour connaître le poids équivalent sur la lune

  • .2f : pour insérer une valeur de type virgule flottante (float)avec 2 chiffres après la virgule.
    print("\n-------------------")
    print("PROGRAMME DE TON POIDS SUR LA LUNE")
    print("-------------------\n")
    
    # Demande le poids à l'utilisateur
    poids = int(input("Veuillez entrer votre poids : "))
    print("\n")
    for annee in range(1, 16):
        poids_sur_lune = poids * 0.165
        print(f"Année {annee} = {poids_sur_lune:.2f}")
        poids = poids + 1
    
    print("\n-------------------")
    print("FIN DU PROGRAMME DE TON POIDS SUR LA LUNE")
    print("-------------------\n")
Conversion binaire

Écrire le programme qui convertit un nombre en binaire et inversement.

print("\n-------------------")
print("PROGRAMME DE CONVERSION BINAIRE")
print("-------------------\n")

def convertir_en_binaire(nombre):
    
    return bin(nombre)[2:]  # [2:] pour enlever le préfixe '0b'

def convertir_en_decimal(binaire):
    
    return int(binaire, 2)

# Menu pour l'utilisateur
print("Programme de conversion :\n")
print("1. Convertir un entier en binaire")
print("2. Convertir un nombre binaire en entier\n")

choix = input("Entrez votre choix (1 ou 2) : ")

if choix == "1":
    # Conversion d'un entier en binaire
    nombre = int(input("\nEntrez un nombre entier : "))
    binaire = convertir_en_binaire(nombre)
    print(f"\nLe nombre {nombre} en binaire est : {binaire}")
elif choix == "2":
    # Conversion d'un binaire en entier
    binaire = input("\nEntrez un nombre binaire (ex : 1101) : ")
    try:
        entier = convertir_en_decimal(binaire)
        print(f"\nLe nombre binaire {binaire} en entier est : {entier}")
    except ValueError:
        print("\nEntrée invalide. Assurez-vous d'entrer un nombre binaire valide.")
else:
    print("\nChoix invalide. Veuillez relancer le programme.")

print("\n-------------------")
print("FIN DU PROGRAMME DE CONVERSION BINAIRE")
print("-------------------\n")
EXERCICE DES PIÈCES D’OR

É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 à dupliquer à 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. Le nombre de pièces magiques est égal aux nombre de pièces trouvés divisés par 2 (seulement la partie entière de la division).
  • 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
  • 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
  • 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
  • É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 (365 jours)
    • 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("\n-------------------")
print("PROGRAMME DES PIÈCES D'OR")
print("-------------------\n")

# On demande le nombre de pièces trouvées au départ
pieces_trouvees = int(input("\nVeuillez entrer le nombre de pièces trouvées : "))


# On calcule le nombre de pièces fabriquées par jours avec la machine de grand-père qui est égale à la moitié des pièces trouvées
# // est l'opérateur de division entière
pieces_magiques = pieces_trouvees // 2

# pour répéter 25 fois un caractère
espaces = ' ' * 5

print(f"{espaces}\nLe nombre de \"pieces_magiques\" fabriquées par jours avec la machine de grand-père, est égale à = {pieces_magiques} pièces")

# On demande le nombre de pièces volées chaque semaine par le corbeau
pieces_volees = int(input("\nVeuillez entrer le nombre de pièces volées chaque semaine par le corbeau (au moins 2) : "))


# calcul du nombre de pièces restantes avec 6 mois à x pièces volées et 6 mois à x-1 pièces volées
nombre_de_pieces = (pieces_trouvees) + (pieces_magiques * 365) - (pieces_volees * 26) - ((pieces_volees - 1) * 26)

# On l'affiche
print(f"{espaces}\nLe \"nombre de pièce au bout de 1 an \" est égale à = {nombre_de_pieces} pièces\n")

# On affiche maintenant le nombre de pièce que l'on a par semaine

# On initialise le nombre de pièces calculé précédemment
nombre_de_pieces = 0
for semaine in range(1, 53):
    
    if semaine == 1:
        nombre_de_pieces = pieces_trouvees + (pieces_magiques * 7) - pieces_volees
        print(f"Semaine numéro {semaine} = {nombre_de_pieces} pièces avec {(pieces_magiques * 7)} 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 {semaine} = {nombre_de_pieces} pièces avec {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 {semaine} = {nombre_de_pieces} pièces avec {pieces_magiques * 7} pièces fabriquées / {pieces_volees-1} pièces volées")

# on rajoute 1 jour de fabrication de pièces car 52 x 7 donne 364 jours.
print(f"\n la fin de l'année on a {nombre_de_pieces + pieces_magiques}")
    

print("\n-------------------")
print("FIN DU PROGRAMME DES PIÈCES D'OR")
print("-------------------\n")
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)

#4 - API
💡

Voir le Drive, dossier “cours” / “youngbank”

  • API qui dialogue entre notre programme PHP et une Google Sheet

💚

Agence digitale Parisweb.art
Tout savoir sur Julie, notre directrice de projets digitaux :
https://www.linkedin.com/in/juliechaumard/