2-python

November 13, 2024

1 PRENDRE DES DÉCISIONS

• Utiliser l’instruction if pour prendre une décision simple.
• Prendre des décisions plus complexes avec l’instruction if…else.
• Créer des niveaux de décision multiples en imbriquant les instructions.
La possibilité de prendre des décisions pour suivre un chemin ou bien un autre est quelque chose
d’essentiel dans toute activité. Les mathématiques donnent à l’ordinateur la capacité d’obtenir des
informations utiles. Et ces informations permettent ensuite d’effectuer telle ou telle action. Sans
cela, un ordinateur ne servirait strictement à rien. Tout langage de programmation doit offrir des
fonctionnalités pour pouvoir prendre des décisions d’une certaine manière. Ce chapitre explore les
techniques que Python utilise dans ce domaine.
Réfléchissez au processus que vous suivez lorsque vous prenez des décisions. Vous obtenez la valeur
de quelque chose, vous la comparez avec une valeur attendue, et vous agissez en conséquence.
Prenons un exemple : vous voyez un signal lumineux et vous voyez qu’il est rouge. Vous le
comparez au signal que vous attendez, le vert. Vous constatez donc que le signal n’est pas au vert.
Action : vous vous arrêtez au feu. La plupart des gens ne prennent pas le temps de réfléchir à ce
genre de processus, tout simplement, car c’est devenu un automatisme. La plupart des décisions
quotidiennes se prennent naturellement, mais les ordinateurs, eux, doivent effectuer à chaque fois
les tâches suivantes :

1. Obtenir la valeur réelle ou actuelle de quelque chose.

2. Comparer cette valeur réelle ou actuelle avec une valeur attendue.

3. Effectuer l’action voulue en fonction du résultat de la comparaison.

1.1 Prendre des décisions simples avec l’instruction if

Dans Python, l’instruction if fournit la méthode la plus simple pour prendre des décisions. Si
cette instruction constate que quelque chose est vrai, cela signifie que Python devrait exécuter les
étapes qui suivent. Les prochaines sections vous expliquent comment utiliser l’instruction if pour
prendre différentes décisions. Vous pourriez être surpris de découvrir tout ce que ces deux petites
lettres peuvent faire pour vous.

1
1.1.1 Comprendre l’instruction if
La structure fondamentale de l’instruction if en Python est utilisée pour exécuter un bloc de code
uniquement si une condition donnée est vraie. Voici la syntaxe de base :
if condition:
# Bloc de code à exécuter si la condition est vraie

1.1.2 Explication :
• if : mot-clé utilisé pour commencer l’instruction conditionnelle.
• condition : une expression évaluée en True ou False.
• : : indique le début du bloc de code.
• Bloc de code : le code à exécuter si la condition est vraie. Il doit être indenté (généralement
de 4 espaces) pour faire partie de l’instruction if.

1.1.3 Exemple simple :

age = 18

if age >= 18:

print("Vous êtes majeur.")

1.1.4 Exercice 1 : Vérification de la parité

Demandez à l’utilisateur de saisir un nombre entier et utilisez une instruction if pour vérifier si ce
nombre est pair. Affichez “Le nombre est pair” si c’est le cas.
Instructions : 1. Demandez un nombre entier à l’utilisateur. 2. Utilisez if pour vérifier si le
reste de la division par 2 est égal à 0. 3. Affichez un message si la condition est vraie.
Exemple de code attendu :
nombre = int(input("Entrez un nombre entier : "))

if nombre % 2 == 0:
print("Le nombre est pair.")

1.1.5 Exercice 2 : Vérification de l’âge

Écrivez un programme qui demande à l’utilisateur son âge et utilise une instruction if pour afficher
un message si l’utilisateur est majeur (18 ans ou plus).
Instructions : 1. Demandez l’âge de l’utilisateur. 2. Utilisez if pour vérifier si l’âge est supérieur
ou égal à 18. 3. Affichez “Vous êtes majeur.” si la condition est remplie.
Exemple de code attendu :
age = int(input("Entrez votre âge : "))

if age >= 18:

print("Vous êtes majeur.")

2
1.1.6 Exercice 3 : Comparaison de nombres
Écrivez un programme qui prend deux nombres entiers en entrée et utilise une instruction if pour
afficher “Le premier nombre est plus grand” si le premier nombre est strictement supérieur au
second.
Instructions : 1. Demandez à l’utilisateur de saisir deux nombres entiers. 2. Utilisez if pour
comparer les deux nombres. 3. Affichez un message si le premier nombre est supérieur au second.
Exemple de code attendu :
nombre1 = int(input("Entrez le premier nombre : "))
nombre2 = int(input("Entrez le deuxième nombre : "))

if nombre1 > nombre2:

print("Le premier nombre est plus grand.")
Ces exercices permettent de pratiquer la syntaxe de base de l’instruction if et de comprendre
comment elle peut être utilisée pour exécuter un bloc de code en fonction d’une condition.

1.1.7 Exercices : Utilisation de if avec des entiers

1. Vérification du nombre d’employés
Déclarez une variable nombre_employes et utilisez if pour vérifier si le nombre est supérieur
à 50. Affichez “L’entreprise a plus de 50 employés” si c’est vrai.
Résolution :
nombre_employes = 75

if nombre_employes > 50:

print("L'entreprise a plus de 50 employés.")

2. Projets en attente
Initialisez projets_en_attente et utilisez if pour vérifier s’il y a des projets en attente (plus
de 0). Affichez “Il y a des projets en attente” si la condition est vraie.
Résolution :
projets_en_attente = 3

if projets_en_attente > 0:
print("Il y a des projets en attente.")

3. Utilisateurs actifs
Créez utilisateurs_actifs et utilisez if pour afficher “Le site a des utilisateurs connectés”
si le nombre d’utilisateurs actifs est supérieur à 10.
Résolution :

3
 utilisateurs_actifs = 25

if utilisateurs_actifs > 10:

print("Le site a des utilisateurs connectés.")

4. Budget du projet
Déclarez budget_projet et utilisez if pour vérifier si le budget est supérieur à 10 millions.
Affichez “Le budget du projet est élevé” si c’est le cas.
Résolution :
budget_projet = 15

if budget_projet > 10:

print("Le budget du projet est élevé.")

5. Lignes de code écrites

Déclarez lignes_de_code et utilisez if pour vérifier si le nombre est supérieur à 1000. Af-
fichez “L’équipe a été très productive” si la condition est vraie.
Résolution :
lignes_de_code = 1200

if lignes_de_code > 1000:

print("L'équipe a été très productive.")

1.1.8 Exercices : Utilisation de if avec des nombres à virgule flottante

1. Note moyenne des utilisateurs
Déclarez note_moyenne et utilisez if pour afficher “La note moyenne est bonne” si elle est
supérieure à 4.0.
Résolution :
note_moyenne = 4.5

if note_moyenne > 4.0:

print("La note moyenne est bonne.")

2. Taux d’erreur
Créez taux_erreur et utilisez if pour afficher “Le taux d’erreur est critique” si le taux est
supérieur à 5%.
Résolution :

4
 taux_erreur = 3.25

if taux_erreur > 5:
print("Le taux d'erreur est critique.")

3. Ratio de réussite
Déclarez ratio_reussite et utilisez if pour afficher “Le ratio de réussite est excellent” si le
ratio est supérieur à 0.9.
Résolution :
ratio_reussite = 0.95

if ratio_reussite > 0.9:

print("Le ratio de réussite est excellent.")

4. Temps d’exécution
Créez temps_execution et utilisez if pour afficher “Le temps d’exécution est trop long” si
la valeur est supérieure à 2 secondes.
Résolution :
temps_execution = 2.5

if temps_execution > 2:
print("Le temps d'exécution est trop long.")

5. Charge du processeur
Déclarez charge_cpu et utilisez if pour afficher “La charge CPU est élevée” si la charge
dépasse 75%.
Résolution :
charge_cpu = 80.5

if charge_cpu > 75:

print("La charge CPU est élevée.")

1.1.9 Extensions de l’instruction if :

1. if-else : permet de définir un bloc de code alternatif si la condition est fausse.
if condition:
# Code si la condition est vraie
else:
# Code si la condition est fausse

5
 2. if-elif-else : permet de tester plusieurs conditions.
if condition1:
# Code si condition1 est vraie
elif condition2:
# Code si condition1 est fausse et condition2 est vraie
else:
# Code si toutes les conditions précédentes sont fausses

1.1.10 Exemple if-elif-else :

note = 75

if note >= 90:

print("Excellent")
elif note >= 70:
print("Bien")
else:
print("Besoin d'amélioration")
Cette structure permet d’écrire des conditions complexes et de contrôler le flux d’exécution du
programme.
Voici une version modifiée des exercices pour inclure des conditions simples et des résolutions :

1.1.11 Exercices Avancés : Variables Entières, Conditions et Opérations Arithmé-

tiques
1. Vérification d’un ID de produit unique
Créez une variable id_produit en combinant serie_base et edition. Multipliez serie_base
par 10 et ajoutez edition. Si l’ID chiffré (le carré de l’ID) dépasse 1000, affichez “ID valide”,
sinon affichez “ID non valide”.
2. Estimation de la population avec vérification de croissance
Initialisez population_actuelle et projetez la population sur trois ans (croissance de 8% par
an). Si la population projetée dépasse un seuil de 1 million, affichez “Croissance notable”,
sinon affichez “Croissance modérée”.
3. Validation de profit positif
Calculez le bénéfice annuel en soustrayant depenses_annee de revenus_annee, puis simulez
une augmentation de 15%. Si le bénéfice projeté est supérieur à zéro, affichez “Entreprise
rentable”, sinon affichez “Entreprise déficitaire”.
4. Croissance trimestrielle et analyse
Calculez la valeur finale après quatre trimestres avec croissance_annuelle. Si la valeur
finale est supérieure à 120% de la valeur initiale, affichez “Croissance rapide”, sinon affichez
“Croissance standard”.
5. Simulation et évaluation du taux d’erreur

6
 Réduisez taux_erreur_initial de 3% puis simulez une surcharge. Si le taux final est in-
férieur à 5%, affichez “Taux acceptable”, sinon affichez “Taux élevé”.
6. Analyse de charges cumulatives
Calculez la charge cumulée sur 6 mois avec charge_mensuelle. Si la charge cumulée dépasse
500 Go, affichez “Alerte: Charge élevée”, sinon affichez “Charge sous contrôle”.
7. Estimation et vérification de coûts
Doublez cout_initial puis appliquez un facteur de croissance de 10% chaque année pendant
5 ans. Si le coût final dépasse 1000 unités, affichez “Coût élevé”, sinon affichez “Coût modéré”.
8. Répartition de ressources et validation
Distribuez ressources_totales entre trois projets. Si l’un des projets reçoit moins de 20%
des ressources, affichez “Ressources insuffisantes”, sinon affichez “Répartition adéquate”.
9. Capitalisation et seuil de rentabilité
Calculez le capital après cinq années d’intérêt composé à partir de capital_initial. Si le
capital final est supérieur à 1.5 fois le capital initial, affichez “Rentabilité atteinte”, sinon
affichez “Rentabilité insuffisante”.
10. Ratio de performance et évaluation
Augmentez ratio_performance de 20% puis doublez-le. Si le ratio final est supérieur à 1.5,
affichez “Performance optimale”, sinon affichez “Performance à améliorer”.

1.1.12 Exercices Avancés : Variables Flottantes, Conditions et Opérations Arithmé-

tiques
1. Vérification de la marge moyenne
Ajoutez 0.75 à marge_initiale puis appliquez une réduction de 5%. Si la marge finale est
supérieure à 15%, affichez “Marge favorable”, sinon affichez “Marge à revoir”.
2. Évaluation des coûts projetés
Ajoutez 15% à cout_initial_projet et élevez au carré. Si le coût projeté dépasse 2000
unités, affichez “Coût à surveiller”, sinon affichez “Coût sous contrôle”.
3. Charge CPU avec surcharge et optimisation
Simulez une surcharge sur charge_cpu_initiale, puis réduisez la valeur. Si la charge finale
est inférieure à 75%, affichez “Charge optimisée”, sinon affichez “Charge critique”.
4. Analyse de la répartition en parallèle
Divisez charge_totale par 2 et appliquez un gain de 15% par tâche. Si la charge répartie
est inférieure à 50%, affichez “Répartition efficace”, sinon affichez “Répartition à optimiser”.
5. Calcul du volume de ressources
Multipliez taux_utilisation par capacité_disque, puis divisez par 1.1. Si le volume final
est supérieur à 800 Go, affichez “Volume acceptable”, sinon affichez “Volume sous-utilisé”.
6. Calcul et vérification de rentabilité
Multipliez rentabilité_brute par 1.25 après soustraction des frais. Si la rentabilité finale
est supérieure à 20%, affichez “Rentabilité positive”, sinon affichez “Rentabilité faible”.

7
 7. Temps de traitement et efficacité par lots
Réduisez temps_initial de 10% et calculez le total pour 20 traitements. Si le temps total
est inférieur à 180 secondes, affichez “Traitement rapide”, sinon affichez “Traitement lent”.
8. Analyse des ressources en cloud
Multipliez volume_donnees par 1.2 et divisez par 0.85. Si le volume récupéré dépasse 1500
To, affichez “Récupération réussie”, sinon affichez “Récupération insuffisante”.
9. Productivité avec croissance vérifiée
Ajoutez 0.2 à productivité_initiale et multipliez par 1.15. Si la productivité finale est
supérieure à 8 heures/jour, affichez “Productivité accrue”, sinon affichez “Productivité stable”.
10. Calcul et vérification de l’espace de stockage
Multipliez espace_initial par 1.05, puis élevez à la puissance de 5. Si l’espace projeté
dépasse 50 To, affichez “Stockage suffisant”, sinon affichez “Stockage limité”.

Ces exercices visent à intégrer des conditions pour tester des valeurs après des opérations arithmé-
tiques et afficher des résultats basés sur les seuils définis.
Voici les solutions détaillées pour chaque exercice avancé, incluant le code Python et les explications
:

1.1.13 Exercices Avancés : Variables Entières, Conditions et Opérations Arithmé-

tiques
1. Génération d’ID de produit unique
serie_base = 123
edition = 7
id_produit = serie_base * 10 + edition
id_chiffre = id_produit ** 2
if id_chiffre > 1000:
print("ID valide")
else:
print("ID non valide")
2. Estimation de la population sur trois ans
population_actuelle = 500_000
population_proj = population_actuelle * (1.08 ** 3)
if population_proj > 1_000_000:
print("Croissance notable")
else:
print("Croissance modérée")
3. Bilan des pertes et profits
revenus_annee = 1_200_000
depenses_annee = 950_000
benefice = revenus_annee - depenses_annee

8
 benefice_proj = benefice * 1.15
if benefice_proj > 0:
print("Entreprise rentable")
else:
print("Entreprise déficitaire")
4. Calcul de croissance cumulée avec une distribution trimestrielle
croissance_annuelle = 1.20
croissance_trimestrielle = croissance_annuelle / 4
valeur_finale = (1 + croissance_trimestrielle) ** 4
if valeur_finale > 1.20:
print("Croissance rapide")
else:
print("Croissance standard")
5. Simulation de taux d’erreur ajusté
taux_erreur_initial = 10
taux_erreur_final = (taux_erreur_initial - 3) * 1.2
if taux_erreur_final < 5:
print("Taux acceptable")
else:
print("Taux élevé")
6. Calcul de charges cumulatives
charge_mensuelle = 80
charge_cumulee = 0
for mois in range(6):
charge_cumulee += charge_mensuelle * (1.05 ** mois)
if charge_cumulee > 500:
print("Alerte: Charge élevée")
else:
print("Charge sous contrôle")
7. Estimation de coût projeté sur plusieurs années
cout_initial = 100
cout_final = cout_initial * 2 * (1.1 ** 5)
if cout_final > 1000:
print("Coût élevé")
else:
print("Coût modéré")
8. Répartition de ressources par proportion
ressources_totales = 1000
projet1 = ressources_totales * 0.40
projet2 = ressources_totales * 0.35
projet3 = ressources_totales * 0.25
if min(projet1, projet2, projet3) < ressources_totales * 0.20:
print("Ressources insuffisantes")

9
 else:
print("Répartition adéquate")
9. Calcul de capitalisation avec intérêt composé
capital_initial = 5000
capital_final = capital_initial * (1.06 ** 5)
if capital_final > capital_initial * 1.5:
print("Rentabilité atteinte")
else:
print("Rentabilité insuffisante")
10. Ratio de performance optimisé
ratio_performance = 0.8
ratio_optimise = ratio_performance * 1.2
ratio_final = ratio_optimise * 2
if ratio_final > 1.5:
print("Performance optimale")
else:
print("Performance à améliorer")

1.1.14 Exercices Avancés : Variables Flottantes, Conditions et Opérations Arithmé-

tiques
1. Calcul de la marge moyenne après frais supplémentaires
marge_initiale = 10.5
marge_apres_frais = (marge_initiale + 0.75) * 0.95
if marge_apres_frais > 15:
print("Marge favorable")
else:
print("Marge à revoir")
2. Évaluation des coûts de projet à long terme
cout_initial_projet = 300
cout_projete = (cout_initial_projet * 1.15) ** 2
if cout_projete > 2000:
print("Coût à surveiller")
else:
print("Coût sous contrôle")
3. Simulation d’augmentation de charge CPU
charge_cpu_initiale = 65.0
charge_cpu_surchargee = charge_cpu_initiale * 1.3 - 0.4
if charge_cpu_surchargee < 75:
print("Charge optimisée")
else:
print("Charge critique")

10
4. Distribution de la charge en parallèle
charge_totale = 100.0
charge_parallele = (charge_totale / 2) * 1.15
if charge_parallele < 50:
print("Répartition efficace")
else:
print("Répartition à optimiser")
5. Conversion de taux d’utilisation en volume de ressources
taux_utilisation = 0.85
capacite_disque = 1000 # en Go
volume_utilise = (taux_utilisation * capacite_disque) / 1.1
if volume_utilise > 800:
print("Volume acceptable")
else:
print("Volume sous-utilisé")
6. Calcul de rentabilité ajustée
rentabilite_brute = 15.0
rentabilite_finale = (rentabilite_brute - 0.5) * 1.25
if rentabilite_finale > 20:
print("Rentabilité positive")
else:
print("Rentabilité faible")
7. Optimisation du temps de traitement par lots
temps_initial = 9.0
temps_optimise = temps_initial * 0.9 * 20
if temps_optimise < 180:
print("Traitement rapide")
else:
print("Traitement lent")
8. Évaluation des ressources en cloud selon le volume de données
volume_donnees = 1200 # en To
volume_recupere = (volume_donnees * 1.2) / 0.85
if volume_recupere > 1500:
print("Récupération réussie")
else:
print("Récupération insuffisante")
9. Estimation de la productivité avec taux de croissance
productivite_initiale = 7.5
productivite_finale = (productivite_initiale + 0.2) * 1.15
if productivite_finale > 8:
print("Productivité accrue")

11
 else:
print("Productivité stable")
10. Calcul d’espace de stockage projeté avec croissance exponentielle
espace_initial = 10 # en To
espace_projete = espace_initial * (1.05 ** 5)
if espace_projete > 50:
print("Stockage suffisant")
else:
print("Stockage limité")

Ces solutions présentent des étapes complètes pour chaque exercice, avec l’initialisation des vari-
ables, les calculs nécessaires, et les conditions pour évaluer les résultats.

1.1.15 Exercices Avancés : Opérateurs Relationnels

1. Vérification d’inventaire minimum avec notification
Créez deux variables stock_actuel et seuil_minimum pour représenter le stock d’un produit
et le seuil minimum acceptable. Vérifiez si le stock_actuel est inférieur au seuil_minimum.
Si c’est le cas, affichez un message de réapprovisionnement et envoyez une notification (simulée
par un simple print).
2. Contrôle de validité d’âge avec message personnalisé
Déclarez une variable age_utilisateur pour l’âge d’un utilisateur et age_minimum pour
l’âge minimum requis pour un accès à une fonctionnalité. Vérifiez si age_utilisateur est
supérieur ou égal à age_minimum et affichez un message personnalisé indiquant si l’accès est
autorisé ou refusé, incluant la différence d’âge.
3. Comparaison de tarifs avec recommandation
Créez deux variables tarif_service1 et tarif_service2 représentant les tarifs de deux
services cloud. Utilisez un opérateur relationnel pour vérifier si tarif_service1 est inférieur
à tarif_service2, et affichez un message indiquant si le premier service est plus rentable,
avec une recommandation basée sur la différence de coût.
4. Validation de performance d’un algorithme avec évaluation critique
Déclarez deux variables performance_attendue et performance_mesuree pour représen-
ter les performances d’un algorithme. Utilisez un opérateur relationnel pour vérifier si
la performance_mesuree est supérieure ou égale à la performance_attendue. Affichez si
l’algorithme répond aux attentes, et ajoutez une évaluation critique si les performances ne
sont pas atteintes.
5. Comparaison de volumes de stockage avec suggestion de migration
Initialisez deux variables stockage_serveurA et stockage_serveurB pour le stockage utilisé
dans deux serveurs différents. Vérifiez si le stockage du serveur A est supérieur à celui du
serveur B, et affichez un message indiquant quel serveur utilise le plus de stockage, avec une
suggestion de migration des données si nécessaire.

12
 6. Vérification de compatibilité de version logicielle avec mise en garde
Créez deux variables version_minimale et version_utilisée pour la version minimale req-
uise et la version actuelle d’un logiciel. Vérifiez si version_utilisée est au moins égale à
version_minimale, et affichez si le logiciel est compatible ou s’il nécessite une mise à jour,
avec une mise en garde sur les implications de ne pas mettre à jour.
7. Contrôle de dépassement de limite budgétaire avec alerte
Déclarez budget_alloué pour le budget total et dépense_actuelle pour les dépenses
en cours. Utilisez un opérateur relationnel pour vérifier si dépense_actuelle a dépassé
budget_alloué. Affichez un message indiquant si le budget est respecté ou non, avec une
alerte en cas de dépassement.
8. Validation de connexion pour l’éligibilité à une offre avec rappel
Créez deux variables nb_connexions pour le nombre de connexions d’un utilisateur et
seuil_eligibilité pour le nombre minimum requis de connexions pour une offre. Véri-
fiez si nb_connexions est supérieur ou égal au seuil_eligibilité et affichez si l’utilisateur
est éligible, avec un rappel du seuil requis.
9. Évaluation de seuil de risque avec message d’alerte
Déclarez deux variables taux_erreur et seuil_risque pour représenter le taux d’erreur
actuel et un seuil de risque acceptable. Utilisez un opérateur relationnel pour vérifier si
taux_erreur est inférieur ou égal au seuil_risque. Affichez un message d’alerte si le seuil
de risque est dépassé, avec des suggestions pour réduire le taux d’erreur.
10. Vérification de date limite pour livraison de projet avec plan d’action
Créez deux variables jours_restant pour le nombre de jours restants avant la date limite de
livraison et jours_minimum pour le minimum requis pour effectuer les derniers tests. Vérifiez
si jours_restant est inférieur ou égal à jours_minimum, et affichez un message indiquant si
le projet est en risque de retard, avec un plan d’action pour remédier au retard.

1.1.16 Résolutions
1. Vérification d’inventaire minimum avec notification
stock_actuel = 20
seuil_minimum = 50
if stock_actuel < seuil_minimum:
print(f"Le stock est inférieur au seuil minimum de {seuil_minimum}. Réapprovisionnemen
print("Notification envoyée au service d'approvisionnement.")
else:
print("Le stock est suffisant.")
2. Contrôle de validité d’âge avec message personnalisé
age_utilisateur = 16
age_minimum = 18
if age_utilisateur >= age_minimum:
print(f"Accès autorisé. Vous avez {age_utilisateur} ans.")
else:
print(f"Accès refusé. Vous devez avoir au moins {age_minimum} ans. Vous avez {age_util

13
3. Comparaison de tarifs avec recommandation
tarif_service1 = 100
tarif_service2 = 150
if tarif_service1 < tarif_service2:
difference = tarif_service2 - tarif_service1
print(f"Le service 1 est plus rentable de {difference} unités. Recommandation : optez
else:
print("Le service 2 est plus rentable ou équivalent.")
4. Validation de performance d’un algorithme avec évaluation critique
performance_attendue = 85
performance_mesuree = 80
if performance_mesuree >= performance_attendue:
print("L'algorithme répond aux attentes.")
else:
print(f"Les performances mesurées ({performance_mesuree}%) sont inférieures à celles a
print("Évaluation critique : Revisez les paramètres de l'algorithme.")
5. Comparaison de volumes de stockage avec suggestion de migration
stockage_serveurA = 700
stockage_serveurB = 500
if stockage_serveurA > stockage_serveurB:
print(f"Le serveur A utilise plus de stockage ({stockage_serveurA} unités) que le serv
print("Suggestion : envisager la migration des données de A vers B.")
else:
print("Le serveur B utilise plus de stockage ou les deux sont équivalents.")
6. Vérification de compatibilité de version logicielle avec mise en garde
version_minimale = 2.0
version_utilisée = 1.5
if version_utilisée >= version_minimale:
print("Le logiciel est compatible.")
else:
print(f"Le logiciel n'est pas compatible. La version utilisée ({version_utilisée}) est
print("Mise en garde : Veuillez mettre à jour le logiciel pour éviter des dysfonctionn
7. Contrôle de dépassement de limite budgétaire avec alerte
budget_alloué = 10000
dépense_actuelle = 10500
if dépense_actuelle > budget_alloué:
print("Dépassement du budget alloué.")
print("Alerte : Les dépenses ont dépassé le budget alloué.")
else:
print("Le budget est respecté.")
8. Validation de connexion pour l’éligibilité à une offre avec rappel
nb_connexions = 150

14
 seuil_eligibilité = 200
if nb_connexions >= seuil_eligibilité:
print("L'utilisateur est éligible à l'offre.")
else:
print(f"L'utilisateur n'est pas éligible. Nombre de connexions actuel : {nb_connexions
9. Évaluation de seuil de risque avec message d’alerte
taux_erreur = 0.07
seuil_risque = 0.05
if taux_erreur <= seuil_risque:
print("Le taux d'erreur est acceptable.")
else:
print(f"Alerte : Le taux d'erreur ({taux_erreur*100}%) dépasse le seuil de risque ({se
print("Suggestions : Améliorer les procédures de vérification des données.")
10. Vérification de date limite pour livraison de projet avec plan d’action
jours_restant = 5
jours_minimum = 7
if jours_restant <= jours_minimum:
print("Il reste encore des jours")
[ ]:

15