IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Voir le flux RSS

User

[Actualité] Algorithme pour planifier les horaires de travail en équipes

Noter ce billet
par , 02/09/2021 à 09h55 (4783 Affichages)
On s'intéresse dans ce billet à la planification des horaires de travail en équipes ou posté.

Pour mieux comprendre ce système de travail en rotation, on prendra comme exemple une organisation en 4x8.

On expliquera ensuite le fonctionnement de l'algorithme mis en œuvre pour réaliser cette planification.

Enfin, on décrira une fonction en Python permettant de générer ce type de planning horaire sur plusieurs semaines.


I. Organisation du travail en 4x8

Le quatre fois huit est un système qui consiste à faire tourner par roulement de huit heures consécutives quatre équipes sur un même poste, afin d'assurer un fonctionnement continu sur les vingt-quatre heures d'une journée, y compris le week-end.
Les équipes changent de tranche horaire tous les deux jours.
2 MATINS => 2 APRÈS-MIDI => 2 NUITS => 2 JOURS DE REPOS


Exemple d'organisation du travail sur 8 jours

Nom : tableau_travail_4x8_8_jours.png
Affichages : 2899
Taille : 8,3 Ko

avec par exemple :

  • 05 h - 13 h : matin
  • 13 h - 21 h : après-midi
  • 21 h - 05 h : nuit


Exemple d'organisation du travail en 4x8 sur 3 semaines

Nom : tableau_travail_4x8_3_sem.png
Affichages : 2936
Taille : 40,5 Ko

Décrivons maintenant le fonctionnement de l'algorithme permettant de planifier les horaires des équipes.



II. Représentation des horaires de la journée et rotation des équipes sur ces horaires

Nom : tableau2_travail_4x8_3_sem.png
Affichages : 3020
Taille : 55,0 Ko

La liste des tranches horaires sur lesquelles les 4 équipes vont tourner peut être représentée par :

[H0,H1,H2,H3]

On fait commencer les indices à 0, comme pour les listes en Python.

Dans notre exemple, on effectue une rotation des équipes tous les 2 jours, ce qui revient en fait à faire tourner les horaires sur les équipes.

On aura donc aux jours d'indices 0 et 1, les horaires des 4 équipes :

[H0,H1,H2,H3]

Aux jours d'indices 2 et 3, après une rotation vers la gauche des éléments de la liste de départ :

[H1,H2,H3,H0]

On constate que le 1er élément devient le dernier, le 2e devient le 1er, etc..

aux jours d'indices 4 et 5 :

[H2,H3,H0,H1]

etc..

. En Python, une rotation d'une position vers la gauche des éléments d'une liste h se fait simplement par :

Code Pyhton : Sélectionner tout - Visualiser dans une fenêtre à part
h = h[1:] + h[:1]

On concatène 2 listes pour en former une 3e : h[:1] contient le 1er élément de la liste et h[1:] les éléments suivants.
On place ainsi le 1e élément en dernière position, et les autres éléments se retrouvent décalés d'une position vers la gauche.

Pour effectuer une rotation avec un décalage de k positions vers la gauche :

Code Pyhton : Sélectionner tout - Visualiser dans une fenêtre à part
h = h[k:] + h[:k]

La valeur maxi de k étant égale au nombre d'éléments de la liste.

Dans notre cas, on parlera donc de rotations simples avec k égal à 1.

Note : le nombre d'équipes n pouvant être inférieur aux nombres d'horaires sur lesquels elles tournent, on ne gardera en fait après rotation que les n premiers horaires.

. Comme le montre le tableau précédent, on peut également effectuer ces rotations en utilisant une relation entre les indices.

L'indice de l'horaire Hi est alors donné par la formule générale :

i = (j + k) modulo n

Avec :

  • i : indice de l'horaire ;
  • j : indice de l'équipe ;
  • k : indice de rotation ou nombre de rotations de 1 position vers la gauche depuis le 1er jour ;
  • n : nombre d'horaires sur lesquels tournent les équipes.


On voit par exemple sur le dernier tableau, qu'après 3 rotations, aux jours d'indices 6 et 7, et sur la colonne 2 :

i = (2 + 3) modulo 4

En Python, on peut ainsi réaliser une rotation des éléments de la liste h, de k positions vers la gauche :

Code Python : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
for j in range(nb_equipes): # parcours des indices des équipes : (0 : Equipe 1, 1: Equipe 2, 2: Equipe 3, 3: Equipe 4)            
    i=(j+k) % n # l'indice de l'horaire est égal à l'indice de rotation ajouté à l'indice de l'équipe, modulo le nombre de tranches horaires
    horaires[j]=h[i] # copie de l'horaire d'indice i

Où la liste h contient les horaires du départ ["matin", "après-midi", "nuit", "repos"] et la liste horaires contient les horaires des équipes après une rotation de k positions vers la gauche, ou k rotations de 1 position vers la gauche.



III. Implémentation de fonctions en Python

. La fonction planifier_horaires_v1 permet de générer la liste des horaires journaliers des équipes pour plusieurs semaines.

Elle prend comme arguments :

  • equipes : liste des équipes, par exemple ['Equipe 1','Equipe 2','Equipe 3','Equipe 4'] ;
  • horaires : liste des horaires de départ sur lesquels les équipes tournent, par exemple ['Matin', 'Après-midi', 'Nuit', 'Repos'] ;
  • periode_rotation : période de rotation des équipes en nombre de jours, par exemple rotation tous les 2 jours ;
  • nb_semaines : nombre de semaines sur lesquelles on planifie les horaires de travail.


Code Python : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def planifier_horaires_v1(equipes,horaires,periode_rotation,nb_semaines):
 
    jours_semaine=['Lundi','Mardi','Mercredi','Jeudi','Vendredi','Samedi','Dimanche']
 
    horaires_jour = horaires[:len(equipes)] # horaires des équipes le 1er jour : ['Matin', 'Après-midi', 'Nuit', 'Repos']
    horaires_jours=[] # liste enregistrant les horaires des équipes jour par jour : [{'Semaine': '01', 'Jour': 'Lundi', 'Horaires Equipes': ['Matin', 'Après-midi', 'Nuit', 'Repos']},etc..]
 
    nb_jours=nb_semaines*7 # nombre de jours correspondant au nombre de semaines
 
    for indice_jour in range(nb_jours): # parcours des indices des jours : (0 : 1er jour, 1: 2ème jour, 2: 3ème jour, 4: 4ème jour, etc..)
 
        num_semaine=indice_jour//7 + 1 # on évalue le numéro de la semaine en fonction de l'indice du jour
        indice_jour_semaine=indice_jour % 7 # on évalue l'indice du jour de la semaine en fonction de l'indice du jour
        jour_semaine=jours_semaine[indice_jour_semaine] # on détermine le jour de la semaine en fonction de son indice
 
        horaires_jours.append({'Semaine':"%02d" % num_semaine, 'Jour':jour_semaine, 'Horaires Equipes': horaires_jour}) # ajout des horaires du jour 
 
        if ((indice_jour+1) % periode_rotation)==0: # on teste si on doit effectuer une rotation
            horaires=horaires[1:] + horaires[:1] # rotation des horaires de la liste d'une position vers la gauche
            horaires_jour=horaires[:len(equipes)] # affectation des horaires aux équipes
 
    return horaires_jours # on retourne la liste des horaires journaliers des équipes

Exemple d'exécution pour planifier les horaires de 4 équipes sur 3 semaines, avec une période de rotation de 2 jours :

Code Python : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
liste_horaires_jours=planifier_horaires_v1(['Equipe 1','Equipe 2','Equipe 3','Equipe 4'],['Matin', 'Après-midi', 'Nuit', 'Repos'],2,3)
print(liste_horaires_jours)

On obtient une liste d'horaires journaliers :

[{'Semaine': '01', 'Jour': 'Lundi', 'Horaires Equipes': ['Matin', 'Après-midi', 'Nuit', 'Repos']}, {'Semaine': '01', 'Jour': 'Mardi', 'Horaires Equipes': ['Matin', 'Après-midi', 'Nuit', 'Repos']}, {'Semaine': '01', 'Jour': 'Mercredi', 'Horaires Equipes': ['Après-midi', 'Nuit', 'Repos', 'Matin']},.., {'Semaine': '03', 'Jour': 'Samedi', 'Horaires Equipes': ['Après-midi', 'Nuit', 'Repos', 'Matin']}, {'Semaine': '03', 'Jour': 'Dimanche', 'Horaires Equipes': ['Nuit', 'Repos', 'Matin', 'Après-midi']}]

On pourra ensuite facilement exporter cette liste dans une feuille Excel.

On peut également remplacer les jours de la semaine par leurs dates, il suffit pour cela de préciser la date du 1er jour du planning.

. La fonction planifier_horaires_v2 permet de générer la liste des horaires journaliers des équipes à partir d'une semaine donnée.

Elle utilise la relation entre les indices décrite précédemment, qui permet de connaître les horaires des équipes pour un jour précis, sans avoir besoin de parcourir les jours précédents.

Elle prend comme arguments :

  • equipes : liste des équipes, par exemple ('Equipe 1','Equipe 2','Equipe 3','Equipe 4') ;
  • horaires : liste des horaires de départ sur lesquels les équipes tournent, par exemple ('Matin', 'Après-midi', 'Nuit', 'Repos') ;
  • periode_rotation : période de rotation des équipes en nombre de jours, par exemple rotation tous les 2 jours ;
  • num_semaine : numéro de la 1re semaine de planification ;
  • nb_semaines : nombre de semaines sur lesquelles on planifie les horaires de travail.


Code Python : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def planifier_horaires_v2(equipes,horaires,periode_rotation,num_semaine,nb_semaines):
 
    jours_semaine=['Lundi','Mardi','Mercredi','Jeudi','Vendredi','Samedi','Dimanche']
 
    horaires_jour = horaires[:len(equipes)] # horaires des équipes le 1er jour : ['Matin', 'Après-midi', 'Nuit', 'Repos']        
    horaires_jours=[] # liste enregistrant les horaires des équipes jour par jour : [{'Semaine': '01', 'Jour': 'Lundi', 'Horaires Equipes': ['Matin', 'Après-midi', 'Nuit', 'Repos']},etc..]
 
    nb_equipes=len(equipes) # nombre total d'équipes
    nb_horaires=len(horaires) # nombre total de tranches horaires ou de périodes de repos
    indice_jour1=(num_semaine-1)*7 # indice du 1er jour
    indice_jourN= indice_jour1 + nb_semaines*7 # indice du dernier jour
 
    for indice_jour in range(indice_jour1,indice_jourN): # parcours des indices des jours 
 
        if (indice_jour % periode_rotation)==0: # on teste par rapport à la période de rotation, si on doit effectuer une rotation
            indice_rotation = indice_jour // periode_rotation # indice de rotation, exemple incrémentation tous les 2 jours
 
            for indice_equipe in range(nb_equipes): # parcours des indices des équipes : (0 : Equipe 1, 1: Equipe 2, 2: Equipe 3, 3: Equipe 4)            
                indice_horaire=(indice_rotation+indice_equipe) % nb_horaires # l'indice de l'horaire est égal à l'indice de rotation ajouté à l'indice de l'équipe, modulo le nombre de tranches_horaires
                horaires_jour[indice_equipe]=horaires[indice_horaire] # copie de l'horaire d'indice indice_horaire_jour
 
        num_semaine=indice_jour//7 + 1 # on évalue le numéro de la semaine en fonction de l'indice du jour
        indice_jour_semaine=indice_jour % 7 # on évalue l'indice du jour de la semaine en fonction de l'indice du jour
        jour_semaine=jours_semaine[indice_jour_semaine] # on détermine le jour de la semaine en fonction de son indice
 
        horaires_jours.append({'Semaine':"%02d" % num_semaine, 'Jour':jour_semaine, 'Horaires Equipes': list(horaires_jour)}) # ajout des horaires du jour 
 
    return horaires_jours #  on retourne la liste des horaires journaliers des équipes


IV. Conclusion

En partant d'un exemple simple d'organisation du travail en 4x8 planifié sur 3 semaines, et après avoir identifié chaque horaire par son indice, nous avons pu mieux nous représenter les rotations de ces horaires sur le planning. Ceci nous a permis ensuite de comprendre comment réaliser ces transformations en Python, enfin, nous avons pu écrire une fonction permettant de générer le planning horaire d'équipes sur plusieurs semaines.


Sources :
https://fr.wikipedia.org/wiki/Travail_post%C3%A9
https://python.developpez.com/cours/...ypes/lists.php

Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog Viadeo Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog Twitter Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog Google Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog Facebook Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog Digg Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog Delicious Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog MySpace Envoyer le billet « Algorithme pour planifier les horaires de travail en équipes » dans le blog Yahoo

Mis à jour 18/09/2021 à 13h23 par User

Catégories
Programmation , Python

Commentaires