Bucle de Python para ejecutar durante cierta cantidad de segundos

Tengo un bucle while y quiero que siga ejecutándose durante 15 minutos. actualmente es:

while True:
    #blah blah blah

(Esto se ejecuta y luego se reinicia. Necesito que continúe haciendo esto, excepto que después de 15 minutos sale del ciclo)

¡Gracias!

Prueba esto:

import time

t_end = time.time() + 60 * 15
while time.time() < t_end:
    # do whatever you do

Esto se ejecutará durante 15 min x 60 s = 900 segundos.

Función time.time devuelve la hora actual en segundos desde el 1 de enero de 1970. El valor está en punto flotante, por lo que incluso puede usarlo con una precisión de subsegundos. Al principio, el valor t_end se calcula como “ahora” + 15 minutos. El bucle se ejecutará hasta que el tiempo actual exceda este tiempo de finalización preestablecido.

Si te entiendo, puedes hacerlo con un datetime.timedelta –

import datetime

endTime = datetime.datetime.now() + datetime.timedelta(minutes=15)
while True:
  if datetime.datetime.now() >= endTime:
    break
  # Blah
  # Blah

Simplemente puedes hacerlo

import time
delay=60*15    ###for 15 minutes delay 
close_time=time.time()+delay
while True:
      ##bla bla
      ###bla bla
     if time.time()>close_time
         break

Para aquellos que usan asyncio, una manera fácil es usar asyncio.wait_for():

async def my_loop():
    res = False
    while not res:
        res = await do_something()

await asyncio.wait_for(my_loop(), 10)

Estaba buscando un ciclo de tiempo más fácil de leer cuando encontré esta pregunta aquí. Algo como:

for sec in max_seconds(10):
      do_something()

Así que creé este ayudante:

# allow easy time-boxing: 'for sec in max_seconds(42): do_something()'
def max_seconds(max_seconds, *, interval=1):
    interval = int(interval)
    start_time = time.time()
    end_time = start_time + max_seconds
    yield 0
    while time.time() < end_time:
        if interval > 0:
            next_time = start_time
            while next_time < time.time():
                next_time += interval
            time.sleep(int(round(next_time - time.time())))
        yield int(round(time.time() - start_time))
        if int(round(time.time() + interval)) > int(round(end_time)): 
            return

Solo funciona con segundos completos, lo cual estuvo bien para mi caso de uso.

Ejemplos:

for sec in max_seconds(10) # -> 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
for sec in max_seconds(10, interval=3) # -> 0, 3, 6, 9
for sec in max_seconds(7): sleep(1.5) # -> 0, 2, 4, 6
for sec in max_seconds(8): sleep(1.5) # -> 0, 2, 4, 6, 8

Tenga en cuenta que el intervalo no es tan preciso, ya que solo espero segundos completos (dormir nunca fue bueno para mí con tiempos

La mejor solución para un mejor rendimiento es usar la respuesta de @DrV y la sugerencia de @jfs de usar time.monotonic():

    import time
    from datetime import datetime, timedelta

    count = 0
    end_time = time.monotonic() + 10
    while time.monotonic() < end_time:
        count += 1
    print(f'10 second result: {count=:,}')
    # 10 second result: count=185,519,745

    count = 0
    end_time = time.time() + 10
    while time.time() < end_time:
        count += 1
    print(f'10 second result: {count=:,}')
    # 10 second result: count=158,219,172

    count = 0
    end_time = datetime.now() + timedelta(seconds=10)
    while datetime.now() < end_time:
        count += 1
    print(f'10 second result: {count=:,}')
    # 10 second result: count=39,168,578

prueba esto:

import time
import os

n = 0
for x in range(10): #enter your value here
    print(n)
    time.sleep(1) #to wait a second
    os.system('cls') #to clear previous number
                     #use ('clear') if you are using linux or mac!
    n = n + 1