usleep in Python

Question

나는 파이썬 2.7에서 usleep() 함수를 찾고 있었다.

다른 함수 이름과 함께 존재하는지 여부를 아는 사람이 있습니까?

Answer 1

usleep 때문에, 당신은

import time 
time.sleep(seconds/1000000.0) 

time.sleep() 매개 변수로 초가 소요 1000000하여 초 값을 분할한다.

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

는

Answer 2

from time import sleep 
sleep(seconds) 

More info. 일반적으로는 X의 마이크로의 실행을 지연 시킨다는 것을 의미

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

time.sleep 매우 매우주의해야합니다. 나는 그것이 비 단조이기 때문에 time.sleep을 사용하여 python3에 의해 불 태워진다. 벽시계가 뒤로 바뀌면, 잠자기 시간이 계획대로 진행 되었다면 벽시계가 멈출 때까지 time.sleep 콜은 끝나지 않습니다. 나는 아직 파이썬을위한 단조로운 차단 된 수면을 발견하지 못했다.

대신,이 같은 Event.wait 추천 :

이 방법에 대해

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

:

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

Answer 7

파이썬위한 또 다른 절전 기능.

참고 : GIL 잠금으로 인해 여러 스레드에 사용하지 말고 여러 개의 하위 프로세스를 사용하는 것이 좋습니다. time.sleep()과 같습니다.

파이썬에 C 함수를 래핑합니다. C 라이브러리의 nanosleep()을 사용하고 있습니다.이 라이브러리는 많은 시간 동안 실행되는 스레드를 정지시킵니다. 그것은 많은 CPU를 사용하여 수학을 평가하는 바쁜 대기 유형의 지연이 아닙니다. 코드는 다음과 같습니다. 모든 것을 폴더에 넣어 라.

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); 
} 

또한 동일한 인 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} 
) 

python-pyrex를 설치하십시오. 그런 다음 리눅스 터미널에서 실행하십시오.

python setup.py build_ext -i 

CWrapper.c, build 및 CWrapper.so 파일이 생성됩니다. 어느 곳에서나 CWrapper.so를 사용하고 파이썬으로 가져 오기 만하면됩니다.

참고 : Raspberry Pi에 대해 별도로 컴파일하십시오.

지금,

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 

는 파라미터 time.sleep위한 delay_sec 바리 함수

에게 Test_sleep.py

테스트() CWrapper.sleep_msec()에 대한 delay_msec, CWrapper.sleep_nsec위한 delay_nsec(). thread_1_task()에서 테스트 할 함수의 주석 처리를 제거하십시오.