🐍 Script Python & Science : Comment un Menuisier optimise son temps
Ah, bonjour ! Je suis Quentin, menuisier. Mon métier, ce n'est pas juste couper du bois ; c'est optimiser le temps et minimiser les chutes. Quand on travaille avec des planches, chaque coupe compte. J'ai créé ce petit script pour m'aider à déterminer combien de planches je dois acheter pour un projet donné, en évitant le gaspillage.
Voici mon outil d'optimisation des matériaux !
```python
# -*- coding: utf-8 -*-
"""
Script Python de Quentin, Menuisier : Optimisation du nombre de planches nécessaires.
Objectif : Calculer le nombre minimum de planches de bois requises pour obtenir
une liste donnée de longueurs de pièces. Ceci est essentiel pour réduire les coûts
et le temps de préparation des commandes.
"""
def optimiser_coupes(longueurs_pieces, longueur_planche_max):
"""
Calcule le nombre minimal de planches nécessaires en utilisant une approche
gloutonne (greedy approach).
Args:
longueurs_pieces (list): Une liste des longueurs (en cm) des pièces à couper.
longueur_planche_max (int): La longueur maximale d'une planche disponible (en cm).
Returns:
int: Le nombre total de planches nécessaires.
"""
# 1. Préparation : Trier les pièces par ordre décroissant.
# C'est la clé de l'optimisation ! On essaie toujours de placer les plus grandes
# pièces en premier, car elles sont les plus difficiles à placer ensuite.
pieces_a_couper = sorted(longueurs_pieces, reverse=True)
nombre_planches_utilisees = 0
planche_courante_taille = 0 # Commence avec une planche vide
for piece in pieces_a_couper:
# Vérification de base : Si une seule pièce est plus longue que la planche max, c'est impossible.
if piece > longueur_planche_max:
print(f"ATTENTION : La pièce de {piece} cm est trop grande pour une planche de {longueur_planche_max} cm.")
return float('inf') # Retourne l'infini si impossible
# 2. Logique d'empilement (Greedy Algorithm) :
# Si la pièce actuelle rentre sur la planche courante, on l'ajoute.
if planche_courante_taille + piece <= longueur_planche_max:
planche_courante_taille += piece
else:
# Sinon, la pièce ne rentre pas. Il faut commencer une nouvelle planche.
nombre_planches_utilisees += 1
planche_courante_taille = piece # La nouvelle planche commence avec cette pièce
# 3. Comptage final : On compte la dernière planche utilisée (si elle n'est pas vide).
if planche_courante_taille > 0:
nombre_planches_utilisees += 1
return nombre_planches_utilisees
# --- Exemple d'utilisation par Quentin ---
print("--- Optimisation des matériaux pour un projet de caissons ---")
# Mes besoins en pièces (en cm) :
besoins_coupes = [300, 150, 280, 100, 180, 400, 200]
# La planche standard que j'utilise (par exemple, une planche de 250 cm)
longueur_standard = 250
print(f"Pièces requises : {besoins_coupes}")
print(f"Longueur maximale de ma planche : {longueur_standard} cm\n")
# Appel de la fonction pour obtenir l'optimisation
resultat = optimiser_coupes(besoins_coupes, longueur_standard)
if resultat != float('inf'):
print("=====================================================")
print(f"✅ Résultat de l'optimisation :")
print(f"Pour obtenir toutes ces pièces, je dois acheter au minimum {resultat} planches.")
print("Ceci me fait gagner du temps et réduit mon gaspillage !")
print("=====================================================")
else:
print("\nImpossible de réaliser ce projet avec les planches disponibles.")
Prix : 9,99€
🐍 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€