Python: Tijden beter "afvangen"

[Verwijderd]

Goedendag,

Ik ben bezig met een projectje om ledjes op een bepaalde tijd langzaam feller te laten worden.
En dat dit in de loop van de dag ook weer gaat dimmen.
Nu heb ik het stukje waar ik een vraag over heb eruit gehaald om het zo duidelijk mogelijk te maken.

Onderstaande code werkt maar vind ik zeker niet netjes.
Alleen ik weet niet welke "functie" of "list" is kan gebruiken zodat het allemaal overzichtelijker en compacter wordt.

import time
from datetime import datetime


start_time = ('08:00:00')
end_time = ('10:00:00')

start_time1 = ('20:00:00')
end_time1 = ('22:00:00')

start_time2 = ('22:00:00')
end_time2 = ('23:00:00')


def fader(start,end):
print("Start time: " + start + ". \nEnd Time: " + end + ". \nStart Bright: " + str(start_bright) + ".\nEnd Bright: " + str(end_bright) + ".\n")


while True:
CurrentTime = datetime.now().strftime('%H:%M:%S')

if CurrentTime >= (start_time) and CurrentTime <= (end_time):
start_bright = 0
end_bright = 100
fader(start_time,end_time)

if CurrentTime >= (start_time1) and CurrentTime <= (end_time1):
start_bright = 100
end_bright = 50
fader(start_time1,end_time1)

if CurrentTime >= (start_time2) and CurrentTime <= (end_time2):
start_bright = 50
end_bright = 0
fader(start_time2,end_time2)

time.sleep(1)

Het mooiste zou ik vinden om de "start_time", "end_time", "start_bright" en "end_bright" in een database te zetten. (de meeste flexibiliteit omdat ik dan veel "tijden" kan verwerken met verschillende "lichtsterktes".) Maar hoe ik dat moet aanpakken heb ik helemaal nog geen idee over.

[farlane]

- Zet ze om te beginnen in een lijst, zodat je op een generieke manier verschillende tijden kunt verwerken.
- Daarna zou je deze lijst kunnen gaan vullen (of vervangen) met iets wat uit een database tabel komt

[Dark Blue]

In plaats van telkens met begin- en eindtijden te rekenen, kun je het verschil ook omzetten in een timedelta object.

Random documentatielinkje:
https://docs.python.org/2.4/lib/datetime-timedelta.html

[armageddon_2k1]

Ik ben heel gul vandaag en heb het een en ander uitgetypt voor je, omdat ik Python zo'n leuke taal vind en je er hopelijk iets van kan leren

Ik zou van een database idee even afstappen, omdat je dan een hoop dependencies erbij haalt voor een erg makkelijk probleem. Eerst de basis goed proberen te krijgen in pure Python en dan altijd even kijken of extra complexiteit nodig is.

Volgens mij ben je gewoon aan het zoeken naar code tips, dus kan het geen kwaad wat voorbeelden te geven.

Python:

# eerst alleen even de time module importeren. Je bent niet geïnteresseerd in dates namelijk, vooralsnog.
from datetime import time, datetime

# we maken nu een list van tuples. Tuples zijn handige bundeltjes van data die je makkelijk kan 'unpacken'
# we gebruiken de volgorde (t_start, t_end, bright_start, bright_end)
segments = [
    (time(8, 0, 0), time(10, 0, 0), 0, 100),
    (time(10, 0, 0), time(20, 0, 0), 100, 100),
    (time(20, 0, 0), time(22, 0, 0), 100, 50),
    (time(22, 0, 0), time(23, 0, 0), 50, 0)
]

# even een aparte functie maken om de brightness op een bepaald tijdstip uit te lezen
def brightness(t):
    # we 'unpacken' de tuples nu terwijl we door de lijst heen lopen
    for t_start, t_end, bright_start, bright_end in segments:
        if t_start <= t < t_end:
            # we rekenen nu het totaal aantal seconden in een segment uit, middels een timedelta object welke automagisch uit het verschil volgt.
            # we moeten alleen wel eerst van de times een datetime maken, anders kunnen we er geen timedelta objecten van maken
            total_delta = (datetime.combine(datetime.today(), t_end) - datetime.combine(datetime.today(), t_start)).total_seconds()

            # en nu rekenen uit hoeveel seconden onze huidige tijd al in de nieuwe sectie zit
            delta = (datetime.combine(datetime.today(), t) - datetime.combine(datetime.today(), t_start)).total_seconds()

            # en nu kunnen we middels lineaire interpolatie even uitrekenen wat de brightness moet zijn
            return bright_start + (bright_end - bright_start) / total_delta * delta
    
    # als er geen segment gevonden is dan is ie maar uit....
    return 0.0

# even wat testen
for i in range(0, 24):
    print(i, brightness(time(i, 0, 0)))

Beetje verbose nog, en kan vast korter. Maar ik vind zoiets prima werken. Nu hoef je alleen maar die while loop te doen en de brightness functie aan te roepen.

[Verwijderd]

Whow, dit is meer dan dat ik had verwacht.
(Juist omdat ik de code werkend had maar deze niet naar mijn zin was.)

Ik had zelf een functie gebouwd die dus ook op een willekeurig moment de helderheid kon uitrekenen
Maar dat had ik er even uitgesloopt omdat het met name om de verschillende tijden ging en hoe ik die het beste kon noteren.

De "datetime.combine" kende ik niet maar bovenstaande code ben ik erg blij mee!


Hartelijk dank. Ik ga stukken van bovenstaande code zeker gebruiken!
Dank voor het meedenken. :-)