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

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Algorithme pour planifier les horaires de travail en équipes,
Un billet blog de Denis Hulo

Le , par User

0PARTAGES

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



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



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



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
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
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
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
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
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
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

Une erreur dans cette actualité ? Signalez-nous-la !