usleep en Python

Question

Estaba buscando una función usleep() en Python 2.7.

¿Alguien sabe si existe, quizás con otro nombre de función?

Answer 1

Desde usleep generalmente significa que desea retrasar la ejecución de x microsegundos, se debe dividir el valor por segundo 1000000.

import time 
time.sleep(seconds/1000000.0) 

time.sleep() toma como parámetro segundos.

http://docs.python.org/library/time.html#time.sleep

Answer 2

from time import sleep 
sleep(seconds) 

More info.

Answer 3

from time import sleep 
sleep(0.1) #sleep during 100ms 

Answer 4

import time 
usleep = lambda x: time.sleep(x/1000000.0) 

usleep(100) #sleep during 100μs 

Answer 5

ser muy, muy cuidadoso con time.sleep. Me quemó python3 usando time.sleep porque no es monótono. Si el reloj de pared cambia hacia atrás, la llamada de tiempo muerto no terminará hasta que el reloj de pared se ponga al día con lo que hubiera sido si el sueño hubiera avanzado como estaba previsto. Todavía no he encontrado un sueño monotónico bloqueado para Python.

En cambio, recomiendo Event.wait, así:

def call_repeatedly(interval, func, *args, **kwargs): 
    stopped = Event() 
    def loop(): 
     while not stopped.wait(interval): # the first call is in `interval` secs 
      try: 
       func(*args) 
      except Exception as e: 
       logger.error(e); 
       if kwargs.get('exception'): 
        kwargs.get('exception')(e) # SEND exception to the specified function if there is one. 
       else: 
        raise Exception(e) 
    Thread(target=loop).start() 
    return stopped.set 

http://pastebin.com/0rZdY8gB

Answer 6

¿qué tal esto:

import time 
def usleep(delay): 
    mdelay = delay /1000 
    now = time.time() 
    while now + mdelay > time.time(): 
     pass 

Answer 7

una función alternativa del sueño para el pitón.

Nota: No se debe utilizar para varios subprocesos debido al bloqueo GIL, pero para subprocesos múltiples está bien. Lo mismo con time.sleep()

Estoy envolviendo una función C en Python. Estoy usando nanosleep() de la biblioteca C, que detiene el hilo que se ejecuta durante tanto tiempo. No es un tipo de retraso de espera ocupado que usa mucha CPU para evaluar algunas matemáticas. Los códigos son los siguientes. Pon todo en una carpeta, di CWrapper.

C_functions.h

#include <time.h> 
int c_sleep_msec(long milliseconds); 
int c_sleep_nsec(long nanoseconds); 

C_functions.c

#include "C_functions.h" 
int c_sleep_msec(long milliseconds) { 
    struct timespec req; 
    //struct timespec rem; 
    if(milliseconds > 999) { 
     req.tv_sec = (int)(milliseconds/1000); /* Must be Non-Negative */ 
     req.tv_nsec = (milliseconds - ((long)req.tv_sec * 1000)) * 1000000; /* Must be in range of 0 to 999999999 */ 
    } 
    else { 
     req.tv_sec = 0;       /* Must be Non-Negative */ 
     req.tv_nsec = milliseconds * 1000000; /* Must be in range of 0 to 999999999 */ 
    } 
    //rem = NULL; 
    return nanosleep(&req , NULL); 
} 
//------------------------------------------------------ 
int c_sleep_nsec(long nanoseconds) { 
    struct timespec req; 
    //struct timespec rem; 
    if (nanoseconds > 999999999) { 
     req.tv_sec = (int)(nanoseconds/1000000000); 
     req.tv_nsec = (nanoseconds - ((long)req.tv_sec * 1000000000)); 
    } 
    else { 
     req.tv_sec = 0; 
     req.tv_nsec = nanoseconds; 
    } 
    //rem = NULL; 
    return nanosleep(&req , NULL); 
} 

También puede crear una función para micro segundos usando el mismo nanosleep()

CWrapper.pyx

cdef extern from "C_functions.h": 
    int c_sleep_msec(long milliseconds) 
    int c_sleep_nsec(long nanoseconds) 

def sleep_msec(milliseconds): 
    return c_sleep_msec(milliseconds) 

def sleep_nsec(nanoseconds): 
    return c_sleep_nsec(nanoseconds) 

setup.py

from distutils.core import setup 
from distutils.extension import Extension 
from Pyrex.Distutils import build_ext 

setup(
    name = "CWrapper", 
    ext_modules=[ Extension("CWrapper", ["CWrapper.pyx", "C_functions.c"]) ], 
    cmdclass = {'build_ext': build_ext} 
) 

Instalar python-pyrex. A continuación, ejecute en el terminal de Linux

python setup.py build_ext -i 

Se va a crear CWrapper.c, construir y archivos CWrapper.so. Use CWrapper.so donde quiera, y solo importe en python.

Nota: compilar por separado para Raspberry Pi.

Ahora, probar la función

Test_sleep.py

import serial 
from multiprocessing import Process 
import time 
import CWrapper 


class TestSleep: 
    def __init__(self): 
     self.delay_sec = 0.00000100 
     self.delay_msec = 30 
     self.delay_nsec = 1000 #200000000 
     self.start_time = time.time() 

     self.process_1 = Process(name="process_1", target=self.process_1_task, args=("process_1",)) 
     self.process_1.daemon = True 
     self.process_1.start() 

     self.process_2 = Process(name="process_2", target=self.process_1_task, args=("process_2",)) 
     self.process_2.daemon = True 
     self.process_2.start() 

     self.process_3 = Process(name="process_3", target=self.process_1_task, args=("process_3",)) 
     self.process_3.daemon = True 
     self.process_3.start() 

    def process_1_task(self, process_name): 
     start = self.start_time 
     delay_msec = self.delay_msec 
     delay_sec = self.delay_sec 
     delay_nsec = self.delay_nsec 

     t1 = start 
     for i in range(1, 81): 
      status = CWrapper.sleep_msec(delay_msec) 
      # status = CWrapper.sleep_nsec(delay_nsec) 
      #status = time.sleep(delay_sec) 
      t2 = time.time() 
      elapsed_time = t2 - t1 
      t1 = t2 
      print process_name, i, "status:", status, "Elapsed-time:", elapsed_time 


if __name__ == '__main__': 
    test = TestSleep() 
    # for i in range(1,10000): 
    #  print "main thread", i 
     # time.sleep(0.1) 
    while True: # Since daemon=True, main thread should check join() or stay in loop 
     pass 

variar los parámetros delay_sec para time.sleep(), delay_msec para CWrapper.sleep_msec(), delay_nsec para CWrapper.sleep_nsec(). Descomente la función que desea probar en thread_1_task().