🐍 Script Python & Science : Comment un Pharmacienne optimise son temps
Bonjour ! Je suis Pascale, pharmacienne. Dans mon quotidien, le temps est précieux. L'un des défis majeurs est d'assurer une dispensation rapide et sans erreur tout en gérant un stock complexe. Ce petit script Python vise à automatiser le calcul du stock restant après plusieurs dispensations, ce qui me fait gagner un temps précieux lors de la vérification des commandes !
Voici mon outil d'optimisation :
```python
# -*- coding: utf-8 -*-
"""
Script Python pour l'optimisation du suivi des stocks en pharmacie.
Objectif : Calculer automatiquement le stock restant après plusieurs dispensations,
réduisant ainsi le temps passé à faire des décomptes manuels.
Auteur : Pascale (Pharmacienne)
Date : 2023-10-27
"""
def gerer_stock_dispensation(stock_initial, dispensations):
"""
Calcule le stock restant pour chaque médicament après une série de dispensations.
Args:
stock_initial (dict): Un dictionnaire représentant le stock initial
(Nom du médicament: Quantité en stock).
dispensations (dict): Un dictionnaire représentant les quantités vendues
ou dispensées (Nom du médicament: Quantité vendue).
Returns:
dict: Un dictionnaire contenant le stock restant pour chaque article.
"""
stock_actuel = stock_initial.copy() # On crée une copie pour ne pas modifier le stock initial
print("--- Démarrage de l'optimisation du stock ---")
for nom, quantite_dispensée in dispensations.items():
if nom in stock_actuel:
# Calcul simple : Stock actuel - Quantité dispensée
nouvelle_quantite = stock_actuel[nom] - quantite_dispensée
if nouvelle_quantite < 0:
print(f"[ALERTE STOCK] {nom}: Erreur ! Tentative de dispensation de {quantite_dispensée} unités, mais seulement {stock_actuel[nom]} en stock.")
stock_actuel[nom] = 0 # On met le stock à zéro pour éviter des erreurs négatives
else:
stock_actuel[nom] = nouvelle_quantite
print(f"✅ {nom} : Stock restant après dispensation : {nouvelle_quantite} unités.")
else:
print(f"⚠️ Attention : Le médicament '{nom}' n'a pas été trouvé dans le stock initial.")
print("--- Fin du calcul. Rapport final ---")
return stock_actuel
# =============================================================================
# SIMULATION DE SCÉNARIO PHARMACIE
# =============================================================================
# 1. Définition du stock initial (ce que nous avons en rayon)
stock_de_base = {
"Paracétamol 500mg": 200,
"Amoxicilline 500mg": 150,
"Ibuprofène 400mg": 300,
"Vitamine D3": 50
}
print("--- Inventaire Initial ---")
for drug, qty in stock_de_base.items():
print(f"{drug}: {qty}")
print("\n" + "="*40 + "\n")
# 2. Définition des dispensations effectuées aujourd'hui (les prescriptions traitées)
dispensations_du_jour = {
"Paracétamol 500mg": 35, # Prescription A
"Amoxicilline 500mg": 15, # Prescription B
"Ibuprofène 400mg": 60, # Prescription C
"Paracétamol 500mg": 20, # Prescription D (Deuxième dispensation du même produit)
"Vitamine D3": 10 # Prescription E
}
print("--- Transactions de la Journée ---")
for drug, qty in dispensations_du_jour.items():
print(f"- {drug}: {qty} unités vendues.")
print("\n" + "="*40 + "\n")
# 3. Exécution de l'optimisation
stock_final = gerer_stock_dispensation(stock_de_base, dispensations_du_jour)
Prix : 9,99€
🐍 Script Python & Science : Comment un Agriculteur optimise son temps
Ah, bonjour ! Je suis Olivier. L'agriculture, c'est autant de terre que de calculs. Le temps, c'est notre ressource la plus précieuse. On ne peut pas se permettre de gaspiller une heure sur un champ quand on pourrait l'utiliser pour vérifier l'irrigation ou préparer le prochain semis.
Pour optimiser mon temps, j'utilise des modèles simples basés sur les données. Voici un petit script Python que j'utilise pour déterminer *quand* il est optimal d'appliquer un apport d'azote, en fonction de la phase de croissance du blé. C'est une approche mathématique pour éviter le sur-dosage et gaspiller mes engrais !
```python
import datetime
def optimiser_fertilisation(phase_croissance: str, jours_depuis_semis: int) -> dict:
"""
Calcule l'opportunité d'appliquer un apport d'azote en fonction de la phase
de croissance du céréale. Ceci permet d'optimiser le temps et les ressources.
Args:
phase_croissance (str): La phase actuelle du blé ('germination', 'vegetative', 'reproductive').
jours_depuis_semis (int): Nombre de jours écoulés depuis le semis initial.
Returns:
dict: Un rapport indiquant si l'apport est recommandé et quand.
"""
print(f"\n--- Analyse pour la phase : {phase_croissance.upper()} ---")
# Définition des seuils critiques basés sur l'expérience (la science du champ !)
seuil_debut = 20 # Jours après semis où l'on commence à surveiller
seuil_optimal = 45 # Période idéale pour un premier apport d'azote
seuil_fin = 75 # Jours après semis où il faut vérifier la maturité
recommandation = {
"appliquer_azote": False,
"justification": "",
"action_prochaine": "Surveiller l'humidité du sol."
}
if phase_croissance == 'germination':
# En germination, on ne fertilise pas encore. On attend que la plante soit établie.
recommandation["justification"] = "La plante est en phase de démarrage. Pas d'apport d'azote nécessaire pour l'instant."
elif phase_croissance == 'vegetative':
# Phase de croissance rapide, c'est le moment idéal pour un premier coup.
if jours_depuis_semis >= seuil_debut and jours_depuis_semis < seuil_optimal:
recommandation["appliquer_azote"] = True
recommandation["justification"] = f"Phase végétative active. Le moment optimal pour un premier apport d'azote (Jours {jours_depuis_semis}). Optimisation du rendement !"
recommandation["action_prochaine"] = "Préparer l'irrigation."
else:
recommandation["justification"] = f"Trop avancé ou trop tôt. Jours écoulés : {jours_depuis_semis}. Attendre la prochaine fenêtre."
elif phase_croissance == 'reproductive':
# Phase de remplissage du grain, l'azote n'est plus prioritaire.
recommandation["justification"] = "Phase reproductive. L'apport d'azote est contre-productif ; concentrer sur l'eau et la protection."
recommandation["action_prochaine"] = "Vérifier la densité des grains."
else:
recommandation["justification"] = "Phase inconnue. Arrêter toute intervention non planifiée."
return recommandation
# --- SIMULATION DE L'OPTIMISATION DU TEMPS ---
print("=================================================")
print("OLIVIER : OPTIMISATION DES APPORTS D'AZOTE")
print("=================================================")
# Scénario 1: Semis récent, plante en phase de croissance active
jours_actuels_1 = 35
phase_actuelle_1 = 'vegetative'
resultat_1 = optimiser_fertilisation(phase_actuelle_1, jours_actuels_1)
print("\n[Rapport pour le Champ A]")
if resultat_1["appliquer_azote"]:
print(f"✅ ACTION REQUISE : Appliquer l'azote immédiatement !")
print(f" -> Raison : {resultat_1['justification']}")
print(
Prix : 9,99€
🐍 Script Python & Science : Comment un Coiffeuse optimise son temps
Bonjour ! Je suis Nathalie, votre coiffeuse. Dans mon métier, le temps est précieux. Pour optimiser mon planning et m'assurer de ne jamais être en retard, j'utilise parfois un petit script Python pour calculer la durée idéale d'une série de services.
Voici un exemple où je calcule le temps total nécessaire pour une journée type, en tenant compte du temps de préparation et de l'exécution des coupes.
```python
# -*- coding: utf-8 -*-
"""
Script Python pour l'optimisation du temps d'une coiffeuse.
Objectif : Calculer le temps total requis pour une séquence de services
afin d'assurer un planning efficace.
Auteur : Nathalie (Coiffeuse)
Date : 2023-10-27
"""
def calculer_temps_service(type_service, duree_minutes):
"""
Fonction utilitaire pour retourner la durée formatée d'un service.
:param type_service: Le nom du service (pour le rapport).
:param duree_minutes: La durée réelle du service en minutes.
:return: Une chaîne de caractères décrivant le temps.
"""
return f"Service '{type_service}': {duree_minutes} minutes."
def optimiser_planning(services):
"""
Calcule le temps total nécessaire pour réaliser une liste de services.
Cette fonction simule l'optimisation du flux de travail.
:param services: Une liste de dictionnaires, chaque dictionnaire
décrivant un service (type et durée).
:return: Le temps total cumulé en minutes, et un rapport détaillé.
"""
temps_total = 0
rapport_detaille = []
print("--- Démarrage de l'optimisation du planning ---")
for service in services:
type_s = service['type']
duree = service['duree']
# Ajout de la durée au total
temps_total += duree
# Construction du rapport pour le client/gestionnaire
rapport_detaille.append(calculer_temps_service(type_s, duree))
print(f"✅ Ajouté : {type_s} ({duree} min)")
print("\n--- Rapport final de l'optimisation ---")
for ligne in rapport_detaille:
print(line)
# Calcul final et recommandation
print("-" * 40)
print(f"⏱️ Temps total nécessaire pour cette séquence : {temps_total} minutes.")
if temps_total > 180:
print("⚠️ Attention : Ce planning est très chargé. Prévoyez une pause de 15 minutes entre les deux blocs majeurs.")
else:
print("👍 Planning optimisé et fluide !")
print("-" * 40)
return temps_total
# ===============================================================
# --- EXÉCUTION DU SCRIPT : Mon planning du jour ! ---
# ===============================================================
# Définition des services prévus pour la journée (les données brutes)
planning_du_jour = [
{'type': 'Coupe Classique', 'duree': 35}, # Temps de coupe standard
{'type': 'Mèches et Dégradé', 'duree': 45}, # Service plus complexe
{'type': 'Coloration Complète', 'duree': 60}, # Nécessite un temps de pose
{'type': 'Coiffage Rapide (Styling)', 'duree': 20} # Fin rapide pour libérer du temps
]
# Appel de la fonction d'optimisation
temps_final = optimiser_planning(planning_du_jour)
print(f"\nFin de l'analyse. Temps final validé : {temps_final} minutes.")
```
### Explication de l'Optimisation (Du point de vue de Nathalie) :
1. **Le Problème Résolu :** L'inefficacité dans la gestion du temps entre différents types de services (coupe simple vs. coloration complexe).
2. **La Solution Mathématique :** J'utilise une approche
Prix : 9,99€