🐍 Script Python & Science : Comment un Bibliothécaire optimise son temps
Ah, bonjour ! Je suis Jeanne, et en tant que bibliothécaire, je passe une bonne partie de mon temps à organiser des milliers de documents. Bien que la classification soit essentielle, j'ai remarqué qu'une tâche chronophage est le suivi des amendes pour les livres en retard.
Pour optimiser ce processus, j'ai créé un petit script Python. Il permet de calculer rapidement le montant total des amendes dues et d'identifier les utilisateurs qui ont accumulé le plus de retards. C'est une application simple de la gestion financière et de l'analyse de données !
Voici mon script :
***
## 🐍 Script Python : Optimisation du suivi des amendes
```python
# -*- coding: utf-8 -*-
"""
Script Python pour l'optimisation du suivi des amendes.
Objectif : Calculer le montant total des amendes et identifier les utilisateurs
avec les retards les plus importants, permettant une gestion financière plus rapide.
Auteur : Jeanne, Bibliothécaire
Date : 2023-10-27
"""
def calculer_amendes(liste_emprunts):
"""
Traite une liste d'emprunts pour calculer les amendes dues et agréger les totaux.
Args:
liste_emprunts (list): Une liste de dictionnaires, chaque dictionnaire
représentant un livre emprunté avec ses détails.
Returns:
dict: Un dictionnaire contenant le total général des amendes et une liste
des utilisateurs triés par montant d'amende.
"""
total_general_amendes = 0
amendes_par_utilisateur = {} # Utilisé pour stocker les totaux par personne
print("--- Démarrage du calcul des amendes ---")
for emprunt in liste_emprunts:
utilisateur = emprunt['utilisateur']
duree_jours = emprunt['jours_en_retard']
montant_amende = emprunt['montant_unitaire'] * duree_jours
# 1. Calcul de l'amende spécifique pour cet emprunt (Mathématiques appliquées)
amende_actuelle = montant_amende
# Mise à jour du total général
total_general_amendes += amende_actuelle
# Agrégation des amendes par utilisateur (Analyse de données)
if utilisateur in amendes_par_utilisateur:
amendes_par_utilisateur[utilisateur] += amende_actuelle
else:
amendes_par_utilisateur[utilisateur] = amende_actuelle
print(f"✅ Calcul terminé. Total général des amendes : {total_general_amendes:.2f} €\n")
# 2. Tri pour l'optimisation (Identification des priorités)
# Nous trions les utilisateurs du plus grand montant d'amende au plus petit.
tri_amendes = sorted(amendes_par_utilisateur.items(), key=lambda item: item[1], reverse=True)
return total_general_amendes, tri_amendes
# --- Données de test (Simulant notre base de données d'emprunts) ---
donnees_emprunts = [
{'titre': 'Le Petit Prince', 'utilisateur': 'Alice Dupont', 'jours_en_retard': 5, 'montant_unitaire': 0.50},
{'titre': 'Algorithmes Avancés', 'utilisateur': 'Bob Martin', 'jours_en_retard': 12, 'montant_unitaire': 0.75},
{'titre': 'Histoire de l\'Art', 'utilisateur': 'Alice Dupont', 'jours_en_retard': 3, 'montant_unitaire': 0.40},
{'titre': 'Physique Quantique', 'utilisateur': 'Charlie Lefevre', 'jours_en_retard': 20, 'montant_unitaire': 1.00},
{'titre': 'La Cuisine Française', 'utilisateur': 'Bob Martin', 'jours_en_retard': 8, 'montant_unitaire': 0.60}
]
# --- Exécution du script ---
if __name__ == "__main__":
print("==================================================")
print(" Rapport d'optimisation des frais de retard")
Prix : 9,99€
🐍 Script Python & Science : Comment un Pompier optimise son temps
**[Bruit de sirène lointaine, puis une voix calme et assurée]**
Salut à tous. Moi, c'est Igor. Quand on est sur le terrain, chaque seconde compte. On ne peut pas se permettre d'être inefficace. La première chose qu'on fait, c'est appliquer les principes de la physique et des mathématiques pour optimiser notre temps de réponse.
Voici un petit script Python que j'utilise pour simuler l'optimisation du temps de trajet entre deux points critiques, en tenant compte de différentes conditions de circulation ou d'accès. C'est une application simple mais essentielle de la formule : **Temps = Distance / Vitesse**.
```python
# -*- coding: utf-8 -*-
"""
Script Python pour l'optimisation du temps de réponse (Simulation Pompier).
Objectif : Calculer le temps minimum nécessaire pour atteindre un site d'intervention.
Auteur : Igor, Pompier.
Date : 2023-10-27
"""
def calculer_temps_optimise(distance_km: float, vitesse_kmh: float) -> float:
"""
Calcule le temps de trajet nécessaire en heures pour couvrir une distance donnée
à une vitesse constante. C'est notre outil d'optimisation temporel.
Args:
distance_km (float): La distance totale à parcourir en kilomètres.
vitesse_kmh (float): La vitesse moyenne estimée en kilomètres par heure (km/h).
Returns:
float: Le temps de trajet total en heures.
"""
if vitesse_kmh <= 0:
# Gestion d'erreur : Impossible de calculer le temps si la vitesse est nulle ou négative.
print("ERREUR : La vitesse doit être supérieure à zéro pour un calcul valide.")
return float('inf') # Retourne l'infini pour indiquer une impossibilité.
# Formule scientifique appliquée : Temps = Distance / Vitesse
temps_heures = distance_km / vitesse_kmh
return temps_heures
# --- Simulation de Scénarios d'Intervention ---
print("--- SIMULATION D'OPTIMISATION DU TEMPS DE RÉPONSE ---")
print("En tant que pompier, je dois choisir la meilleure stratégie pour chaque appel.")
print("-" * 50)
# Scénario 1 : Route dégagée (Vitesse élevée)
distance_incident_1 = 15.0 # Distance du dépôt au site A en km
vitesse_route_ouverte = 60.0 # Vitesse optimisée sur route libre en km/h
temps_optimise_1 = calculer_temps_optimise(distance_incident_1, vitesse_route_ouverte)
print(f"Scénario 1 (Route ouverte):")
print(f"Distance : {distance_incident_1} km | Vitesse estimée : {vitesse_route_ouverte} km/h")
# On affiche le résultat en minutes pour une meilleure lisibilité opérationnelle
temps_minutes_1 = temps_optimise_1 * 60
print(f"Temps de trajet optimisé : {temps_heures:.2f} heures ({temps_minutes_1:.0f} minutes).")
print("-> Stratégie : Départ immédiat, vitesse maximale.")
print("-" * 50)
# Scénario 2 : Conditions difficiles (Vitesse réduite)
distance_incident_2 = 15.0 # Même distance pour comparaison
vitesse_conditions_difficiles = 30.0 # Vitesse réduite en raison de trafic ou obstacles en km/h
temps_optimise_2 = calculer_temps_optimise(distance_incident_2, vitesse_conditions_difficiles)
print(f"Scénario 2 (Conditions difficiles):")
print(f"Distance : {distance_incident_2} km | Vitesse estimée : {vitesse_conditions_difficiles} km/h")
temps_minutes_2 = temps_optimise_2 * 60
print(f"Temps de trajet optimisé : {temps_heures:.2
Prix : 9,99€
🐍 Script Python & Science : Comment un Infirmière optimise son temps
Bonjour ! Je suis Hélène, infirmière. L'optimisation du temps est cruciale en milieu clinique pour assurer la sécurité et la qualité des soins. Souvent, cela passe par une bonne gestion des priorités et des tâches.
Voici un petit script Python qui simule comment on pourrait évaluer l'efficacité d'une séquence de soins, en utilisant une pondération (priorité) pour optimiser le temps passé sur les urgences.
```python
# -*- coding: utf-8 -*-
"""
Script Python : Optimisation du Temps de Soins Infirmiers
Auteur : Hélène, Infirmière
Objectif : Calculer le temps total nécessaire pour une séquence de soins
en tenant compte de la priorité (urgence) de chaque tâche.
"""
def calculer_temps_optimise(taches):
"""
Calcule le temps total estimé pour réaliser un ensemble de tâches,
en pondérant la durée par la priorité.
Args:
taches (list): Une liste de dictionnaires, où chaque dictionnaire
contient 'nom', 'duree_minutes' et 'priorite' (échelle de 1 à 10).
Returns:
float: Le temps total cumulé en minutes.
"""
temps_total = 0
print("--- Début de l'évaluation des tâches ---")
# Tri initial : On trie pour s'assurer que les tâches les plus urgentes (priorité élevée)
# sont traitées en premier, ce qui est une bonne pratique clinique.
taches_triees = sorted(taches, key=lambda item: item['priorite'], reverse=True)
for tache in taches_triees:
duree = tache['duree_minutes']
priorite = tache['priorite']
# Calcul de la charge pondérée : Pour une tâche urgente (haute priorité),
# on peut ajuster le temps pour refléter l'urgence. Ici, nous multiplions
# la durée par un facteur basé sur la priorité.
facteur_priorite = tache['priorite'] / 10.0 # Normalisation de la priorité (max 1.0)
temps_pondere = duree * facteur_priorite
temps_total += temps_pondere
print(f"Tâche : {tache['nom']} | Durée brute : {duree} min | Priorité : {priorite}/10 | Temps pondéré : {temps_pondere:.2f} min")
print("--------------------------------------")
return temps_total
# --- Simulation de la situation clinique ---
# Liste des tâches à effectuer sur un patient pour une période donnée.
soins_du_jour = [
{'nom': 'Vérification signes vitaux', 'duree_minutes': 10, 'priorite': 8}, # Très urgent
{'nom': 'Administration de médicaments quotidiens', 'duree_minutes': 15, 'priorite': 9}, # Critique
{'nom': 'Contrôle de la plaie (Urgence modérée)', 'duree_minutes': 20, 'priorite': 6},
{'nom': 'Documentation des observations', 'duree_minutes': 5, 'priorite': 3}, # Moins urgent
{'nom': 'Préparation du matériel pour le prochain soin', 'duree_minutes': 10, 'priorite': 2} # Routine
]
# Appel de la fonction pour optimiser l'évaluation du temps
temps_final = calculer_temps_optimise(soins_du_jour)
print(f"\n✅ Temps total estimé (pondéré) pour cette séquence de soins : {temps_final:.2f} minutes.")
print("Cette évaluation nous aide à savoir si notre planning est réaliste et si nous devons réallouer du temps.")
```
### Explication en tant qu'Infirmière :
**Pourquoi ce script est utile ?**
1. **Priorisation (Le Cœur des Soins) :** En milieu hospitalier, toutes les tâches n'ont pas la même importance. Ce script utilise la variable `priorite` pour simuler l'urgence clinique.
2. **Optimisation Mathématique :** Au lieu de simplement additionner les minutes (ce qui donnerait 60 minutes brutes), nous faisons une
Prix : 9,99€