Ceci est une ancienne révision du document !
Last month, we looked at using the datetime library to, among other things, calculate a billing cost for hours worked. Unfortunately, I didn’t have enough time or space to discuss adding multiple hours worked to get a “grand total” to bill the customer. One would assume that since you can subtract two datetime objects, that you could add two datetime objects just as easily. But you can’t. If we use an example from last month and have the two datetime objects st and et (meaning start time and end time), and try to add them – which really makes no sense, but let’s try it anyway – you will receive the text shown below.
Le mois dernier, nous avons étudié la possibilité d'utiliser la bibliothèque des heures pour, entre autres, calculer un coût de facturation des heures travaillées. Malheureusement, je n'ai pas eu le temps ou l'espace nécessaire pour discuter de l'ajout de plusieurs heures de travail afin d'obtenir un “grand total” à facturer au client.
On pourrait supposer que puisque vous pouvez soustraire deux objets date-heure, vous pourriez ajouter deux objets date-heure tout aussi facilement. Mais ce n'est pas le cas.
Si nous utilisons un exemple du mois dernier et que nous avons les deux objets date-heure st et et (qui signifie heure de début et heure de fin), et que nous essayons de les ajouter - ce qui n'a vraiment aucun sens, mais essayons quand même - vous recevrez le texte ci-dessous.
While there are a few ways to actually add times using datediff, they are very clumsy, and I really don’t think I could properly explain it, so I started looking for a better solution. After digging around on the Internet, I found this discussion on stackoverflow.com. (https://stackoverflow.com/questions/2410454/adding-up-time-durations-in-python). Banderlog013 answered the question the best, so I grabbed a copy of his code. It seems the solution is “simply” to use the numpy library. After playing around with the code, I realized that, for my needs, it didn’t quite give me what I needed. Here (top right) is his original code, including his comments.
Bien qu'il existe quelques moyens d'ajouter des heures en utilisant datediff, ils sont très maladroits, et je ne pense pas pouvoir l'expliquer correctement, alors j'ai commencé à chercher une meilleure solution.
Après avoir fouillé sur Internet, j'ai trouvé cette discussion sur stackoverflow.com. (https://stackoverflow.com/questions/2410454/adding-up-time-durations-in-python). C'est Banderlog013 qui a le mieux répondu à la question, alors j'ai pris une copie de son code.
Il semble que la solution soit “simplement” d'utiliser la bibliothèque numpy. Après avoir joué avec le code, j'ai réalisé que, pour mes besoins, il ne me donnait pas tout à fait ce dont j'avais besoin. Voici (en haut à droite) son code original, y compris ses commentaires.
While this worked on a basic level, it wasn’t really what I wanted. So I started modifying the code. But, before we get too deep into the code, I will remind you that you need to have the numpy library installed. Most of my regular readers already have done this, but let’s go through the motions – just in case you haven’t done this yet. You can simply use pip (or pip3) to install numpy … $ pip3 install numpy If numpy is already installed, that’s ok. You’ll just get a gentle message that you have already done this … Requirement already satisfied: numpy in ./.local/lib/python3.8/site-packages (1.19.2)
Bien que cela ait fonctionné à un niveau de base, ce n'était pas vraiment ce que je voulais. J'ai donc commencé à modifier le code. Mais, avant d'entrer trop profondément dans le code, je vous rappelle que vous devez avoir installé la bibliothèque numpy. La plupart de mes lecteurs réguliers l'ont déjà fait, mais passons à l'action - au cas où vous ne l'auriez pas encore fait. Vous pouvez simplement utiliser pip (ou pip3) pour installer numpy …
$ pip3 install numpy
Si numpy est déjà installé, c'est bon. Vous recevrez juste un petit message vous indiquant que vous avez déjà fait cela …
Exigence déjà satisfaite : numpy in ./.local/lib/python3.8/site-packages (1.19.2)
The program assumes that you have the hours put into a text file. Here ‘s the one that I will use for this project. It’s simply just a series of task times for our mythical employee. One entry per line. 06:00:00 03:00:00 02:08:00 03:10:00 11:10:00 08:00:00 Make sure that you press <Enter> after you make the last entry in the text file. You can use any text editor you wish, from Vim, to nano, or your favorite IDE. Save the file as “hours-11-20-20.txt” .
Le programme suppose que vous avez les heures mises dans un fichier texte. Voici celui que j'utiliserai pour ce projet. Il s'agit simplement d'une série d'heures de tâches pour notre employé mythique. Une entrée par ligne.
06:00:00 03:00:00 02:08:00 03:10:00 11:10:00 08:00:00
Veillez à appuyer sur <Enter> après avoir effectué la dernière entrée dans le fichier texte. Vous pouvez utiliser n'importe quel éditeur de texte, de Vim, à nano, ou votre IDE préféré. Enregistrez le fichier sous le nom “hours-11-20-20.txt” .
Now that is taken care of, let’s look at the code (after I modified it), block by block, with some explanations along the way. To run the program, you will need to use a version of Python that is 3.7 or later, since I use “f-strings” throughout.
First, we need to import numpy into our program, and then read the file. The data from the file is going to be put into a variable named “x”. At this point, most of this this is the code from Banderlog013, including his original comments (top right).
At this point, the data that is in the variable “tmp” is:
['06:00:00', '03:00:00', '02:08:00', '03:10:00', '11:10:00', '08:00:00', ]
Maintenant que c'est réglé, regardons le code (après que je l'ai modifié), bloc par bloc, avec quelques explications en cours de route. Pour exécuter le programme, vous devrez utiliser une version de Python 3.7 ou ultérieure, puisque j'utilise des “f-strings” tout au long du programme.
Tout d'abord, nous devons importer numpy dans notre programme, puis lire le fichier. Les données du fichier vont être placées dans une variable nommée “x”. À ce stade, il s'agit pour l'essentiel du code de Banderlog013, y compris ses commentaires originaux (en haut à droite).
À ce stade, les données qui se trouvent dans la variable “tmp” sont :
['06:00:00', '03:00:00', '02:08:00', '03:10:00', '11:10:00', '08:00:00', ]
I didn’t include microseconds in my data entries, so it’s just a list of the simple strings that we had entered into the file. Also notice that the last element of the list is a blank string, which is why he mentions that he needed to drop the last item in his comments.
Now, we need to take each entry in our list and convert that into a list of lists.
# get list of ['00', 02, '12.31']
tmp = [i.split(“:”) for i in tmp.copy()]
print(f“tmp={tmp}”)
The print statement is mine – so that we can see the data. The variable tmp now contains:
tmp='06', '00', '00'], ['03', '00', '00'], ['02', '08', '00'], ['03', '10', '00'], ['11', '10', '00'], ['08', '00', '00'], [''
There is the list of lists I mentioned above. Next, we create an empty list that will hold each of the items and then walk through each item, convert that to a numpy float array, append that to the empty list (np_tims) see below.
So this is the end of the for loop. At this point, the program has printed each of the values for np_tmp and has appended each into the np_tims list. Our output, at this time, looks like this:
np_tmp=[6. 0. 0.]
np_tmp=[3. 0. 0.]
np_tmp=[2. 8. 0.]
np_tmp=[ 3. 10. 0.]
np_tmp=[11. 10. 0.]
np_tmp=[8. 0. 0.]
And the np_tims list looks like this:
[array([6., 0., 0.]), array([3., 0., 0.]), array([2., 8., 0.]), array([ 3., 10., 0.]), array([11., 10., 0.]), array([8., 0., 0.])]
Je n'ai pas inclus les microsecondes dans mes entrées de données, donc c'est juste une liste des chaînes simples que nous avions entrées dans le fichier. Notez également que le dernier élément de la liste est une chaîne vide, c'est pourquoi il mentionne qu'il a dû laisser tomber le dernier élément dans ses commentaires.
Maintenant, nous devons prendre chaque entrée de notre liste et la convertir en une liste de listes.
# get list of ['00', 02, '12.31']
tmp = [i.split(“ :”) pour i dans tmp.copy()]
print(f “tmp={tmp}”)
La déclaration imprimée est à moi - pour que nous puissions voir les données. La variable tmp contient maintenant :
tmp='06', '00', '00'], ['03', '00', '00'], ['02', '08', '00'], ['03', '10', '00'], ['11', '10', '00'], ['08', '00', '00'], [''
We are getting close to the “magic” of what the program does. Since we are done with the for loop, we’ll now use the .sum function of numpy. He originally divided the array sums by another array of [24, 60, 1000]. However when that happened, it threw the numbers off. So I changed the code to leave the array sums as it was, which worked for me.
# X = np.array(np_tims).sum(axis=0) / np.array([24, 60, 1000])
X = np.array(np_tims).sum(axis=0) # / np.array([1, 60, 1000])
print(X)
Now when we hit the print(X) line, the output from our program presents us with:
[33. 28. 0.]
Nous nous rapprochons de la “magie” de ce que fait le programme. Puisque nous en avons fini avec la boucle for, nous allons maintenant utiliser la fonction .sum de numpy. Il a d'abord divisé les sommes du tableau par un autre tableau de [24, 60, 1000]. Cependant, lorsque cela s'est produit, il a fait dévier les nombres. J'ai donc changé le code pour laisser les tableaux de sommes tels quels, ce qui a fonctionné pour moi.
# X = np.array(np_tims).sum(axis=0) / np.array([24, 60, 1000])
X = np.array(np_tims).sum(axis=0) # / np.array([1, 60, 1000])
imprimer(X)
Maintenant, lorsque nous appuyons sur la ligne print(X), la sortie de notre programme nous présente :
[33. 28. 0.]
At this point, we pull the hour and minute values from the list so that we can easily deal with them.
hrs = X[0]
mins = X[1]
print(hrs, mins)
And the output here would be:
33.0 28.0
And, as you know, the value on the left is hours with the value on the right being the minutes. Notice that I don’t really care about seconds at this point, so they are ignored.
À ce stade, nous retirons les valeurs des heures et des minutes de la liste afin de pouvoir les traiter facilement.
hrs = X[0]
mins = X[1]
imprimer(hrs, mins)
Et le résultat serait ici :
33.0 28.0
Et, comme vous le savez, la valeur à gauche est celle des heures et la valeur à droite celle des minutes. Remarquez que je ne me soucie pas vraiment des secondes à ce stade, donc elles sont ignorées.
Next, we convert the hours to seconds by multiplying by 3600, and the minutes by 60, and then adding them together.
totalsecs = (hrs * 3600) + (mins * 60)
print(f“TotalSecs: {totalsecs}”)
TotalSecs: 120480.0
You COULD make the line:
Totalsecs = (X[0] * 3600) + (X[1] * 60)
Which is much more intuitive and requires a lot less programming, but I wanted to break it down into easily “digestible chunks”.
Ensuite, nous convertissons les heures en secondes en les multipliant par 3600, et les minutes par 60, puis en les additionnant.
totalsecs = (hrs * 3600) + (mins * 60)
print(f “TotalSecs : {totalsecs}”)
TotalSecs : 120480.0
Vous POUVEZ faire la queue :
Totalsecs = (X[0] * 3600) + (X[1] * 60)
Ce qui est beaucoup plus intuitif et nécessite beaucoup moins de programmation, mais je voulais le décomposer en “morceaux facilement digestibles”.
As we did last month, we use divmod to convert the numbers into hours, minutes and seconds just in case we have more minutes than 60 so the values correlate correctly:
min, sec = divmod(totalsecs, 60)
hours, minutes = divmod(min, 60)
print(f“{hours} hours and {minutes} minutes”)
33.0 hours and 28.0 minutes
Luckily, in this example the numbers match. Finally, we apply our billing factor. In this case, our mythical programmer bills out at $25 per hour, AND we bill portions of an hour instead of rounding everything up to the next hour.
billingratehours = 25
billingrateminutes = 25 / 60
billtotal = (hours * billingratehours) + (minutes * billingrateminutes)
print(f“Bill= ${billtotal:.2f}”)
Bill= $836.67
Comme nous l'avons fait le mois dernier, nous utilisons divmod pour convertir les chiffres en heures, minutes et secondes, au cas où nous aurions plus de minutes que 60, afin que les valeurs soient correctement corrélées :
min, sec = divmod(totalsecs, 60)
heures, minutes = divmod(min, 60)
print(f “{heures} heures et {minutes} minutes”)
33,0 heures et 28,0 minutes
Heureusement, dans cet exemple, les chiffres correspondent. Enfin, nous appliquons notre facteur de facturation. Dans ce cas, notre mythique programmeur facture à 25 dollars de l'heure, ET nous facturons des portions d'une heure au lieu de tout arrondir à l'heure suivante.
heures de facturation = 25
billingrateminutes = 25 / 60
total de la facture = (heures * heures de facturation) + (minutes * minutes de facturation)
print(f “Bill= ${billtotal :.2f}”)
Projet de loi = 836,67
If you look at the print statement at the end of the code block, we format the total amount to be billed to only two decimal points by using the “:.2f” constructor. What if we didn’t format the billtotal variable? The program would print:
Bill= $836.6666666666666
Which doesn’t make sense for a billing amount.
Since we spent time creating a program, I thought long and hard about how to provide the source code. If I went to pastebin as I have in the past, you would have to make two separate downloads, but if I put the code on my github repository, then you have to download only one happy little zip file. So, I have put the code in my github repository. You can download them at https://github.com/gregwa1953/FCM164.
As always, until next time; stay safe, healthy, positive and creative!
Si vous regardez la déclaration imprimée à la fin du bloc de code, nous formatons le montant total à facturer à deux décimales seulement en utilisant le constructeur “ :.2f”. Et si nous n'avions pas formaté la variable “total de la facture” ? Le programme s'imprimerait :
Facture = 836,6666666666666
Ce qui n'a pas de sens pour un montant de facturation.
Comme nous avons passé du temps à créer un programme, j'ai longuement réfléchi à la manière de fournir le code source. Si j'allais sur pastebin comme je l'ai fait dans le passé, il faudrait faire deux téléchargements séparés, mais si je mettais le code sur mon dépôt github, alors il ne faudrait télécharger qu'un seul petit fichier zip. J'ai donc mis le code dans mon dépôt github. Vous pouvez les télécharger à l'adresse suivante : https://github.com/gregwa1953/FCM164.
Comme toujours, jusqu'à la prochaine fois ; restez en sécurité, en bonne santé, positif et créatif !