python - मैं पायथन में समय देरी कैसे कर सकता हूं?



delay sleep timedelay (12)

मैं जानना चाहता हूं कि पाइथन लिपि में समय देरी कैसे करें।


Answers

एक नींद generator साथ थोड़ा मज़ा।

सवाल समय विलंब के बारे में है। यह निश्चित समय हो सकता है, लेकिन कुछ मामलों में हमें पिछली बार मापा गया देरी की आवश्यकता हो सकती है। यहां एक संभावित समाधान है:

आखिरी बार से मापा विलंब (नियमित रूप से जागना)

स्थिति हो सकती है, हम नियमित रूप से यथासंभव कुछ करना चाहते हैं और हम अपने अंतिम कोड के सभी last_time , next_time सामग्री से परेशान नहीं होना चाहते हैं।

बुजर जनरेटर

निम्न कोड ( sleepy.py ) एक buzzergen जनरेटर को परिभाषित करता है:

import time
from itertools import count

def buzzergen(period):
    nexttime = time.time() + period
    for i in count():
        now = time.time()
        tosleep = nexttime - now
        if tosleep > 0:
            time.sleep(tosleep)
            nexttime += period
        else:
            nexttime = now + period
        yield i, nexttime

नियमित buzzergen का आह्वान

from sleepy import buzzergen
import time
buzzer = buzzergen(3) # Planning to wake up each 3 seconds
print time.time()
buzzer.next()
print time.time()
time.sleep(2)
buzzer.next()
print time.time()
time.sleep(5) # Sleeping a bit longer than usually
buzzer.next()
print time.time()
buzzer.next()
print time.time()

और इसे चलाना हम देखते हैं:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

हम इसे सीधे लूप में भी इस्तेमाल कर सकते हैं:

import random
for ring in buzzergen(3):
    print "now", time.time()
    print "ring", ring
    time.sleep(random.choice([0, 2, 4, 6]))

और इसे चलाना हम देख सकते हैं:

now 1400102751.46
ring (0, 1400102754.461676)
now 1400102754.46
ring (1, 1400102757.461676)
now 1400102757.46
ring (2, 1400102760.461676)
now 1400102760.46
ring (3, 1400102763.461676)
now 1400102766.47
ring (4, 1400102769.47115)
now 1400102769.47
ring (5, 1400102772.47115)
now 1400102772.47
ring (6, 1400102775.47115)
now 1400102775.47
ring (7, 1400102778.47115)

जैसा कि हम देखते हैं, यह बजर बहुत कठोर नहीं है और हम नियमित नींद के अंतराल के साथ पकड़ने की इजाजत देते हैं भले ही हम सोते हैं और नियमित शेड्यूल से बाहर निकलते हैं।


देरी समय पुस्तकालय के साथ की जाती है, विशेष रूप से time.sleep() फ़ंक्शन ...

इसे एक सेकंड के लिए प्रतीक्षा करने के लिए:

from time import sleep
sleep(1)

यह काम करता है क्योंकि ऐसा करके:

from time import sleep

आप केवल समय पुस्तकालय से time.sleep() निकालते हैं जिसका अर्थ है कि आप इसे केवल कॉल कर सकते हैं:

sleep(seconds)

टाइप करने के बजाय

time.sleep()

जो टाइप करने के लिए अजीब रूप से लंबा है।

इस विधि के साथ, आपको समय पुस्तकालय की अन्य सुविधाओं तक पहुंच नहीं मिलेगी और आपके पास नींद नामक एक चर नहीं हो सकता है। लेकिन आप समय कहा जाता है एक चर बना सकते हैं।

from [library] import [function] (, [function2]) से करना बहुत अच्छा है यदि आप बस मॉड्यूल के कुछ हिस्सों को चाहते हैं।

आप इसे उतना ही कर सकते हैं

import time
time.sleep(1)

और जब तक आप time.[function]() टाइप करते हैं, तब तक आपको time.clock() जैसे समय पुस्तकालय की अन्य विशेषताओं तक पहुंच होगी time.[function]() , लेकिन आप परिवर्तनीय समय नहीं बना सके।


कृपया https://web.archive.org/web/20090207081238/http://faqts.com/knowledge_base/view.phtml/aid/2609/fid/378 पढ़ें, जो आपको आगे की सहायता कर सकता है:

समय मॉड्यूल में नींद समारोह का प्रयास करें।

import time
time.sleep(60)

और इसे while और एक कथन केवल मिनट पर निष्पादित होगा ... इससे आपको पूर्व निर्धारित अंतराल पर एक बयान चलाने की अनुमति मिलती है, भले ही कमांड कितना समय लगे (जब तक कि यह एक मिनट या 5 या 60 से कम समय लेता है या जिसे आप इसे सेट करते हैं) उदाहरण के लिए, मैं एक मिनट में एक पिंग चलाने के लिए चाहता था। अगर मैं बस समय। time.sleep(60) या time.sleep(45) यहां तक ​​कि, पिंग हमेशा एक ही समय नहीं ले जाएगा। कोड यहाँ है :)

time.sleep(time.localtime(time.time())[5])

[5] बस समय के बाहर सेकंड खींचता है। time.localtime() के वापसी मूल्य।

time.sleep बारे में अच्छी बात यह है कि यह फ़्लोटिंग पॉइंट नंबरों का समर्थन करता है!

import time
time.sleep(0.1) 

http://python.org/doc/current/lib/module-time.html


पायथन मानक पुस्तकालय में टिंकर लाइब्रेरी एक इंटरेक्टिव टूल है जिसे आप आयात कर सकते हैं। असल में, आप बटन और बक्से और पॉपअप और सामान बना सकते हैं जो आपके द्वारा कोड के साथ छेड़छाड़ की खिड़कियों के रूप में दिखाई देते हैं।

यदि आप टिंकर का उपयोग करते हैं, तो समय का उपयोग न करें TIME.SLEEP() क्योंकि यह आपके प्रोग्राम को TIME.SLEEP() होगा। यह मेरे साथ हुआ। इसके बजाय, root.after() उपयोग करें और मिलीसेकंड के साथ मानों को कई सेकंड के लिए प्रतिस्थापित करें। उदाहरण के लिए, time.sleep(1) root.after(1000) के बराबर है।

अन्यथा, time.sleep() , जो कि कई उत्तरों ने इंगित किया है, जो जाने का तरीका है।


4 तरीके हैं जो मुझे पता है: time.sleep() , pygame.time.wait() , matplotlib की pyplot.pause() , और pyplot.pause() .after()

time.sleep() उदाहरण (Tkinter का उपयोग करते समय उपयोग न करें):

import time
print('Hello')
time.sleep(5) #number of seconds
print('Bye')

pygame.time.wait() उदाहरण (अगर आप pygame विंडो का उपयोग नहीं कर रहे हैं तो अनुशंसित नहीं है, लेकिन आप तुरंत विंडो से बाहर निकल सकते हैं):

import pygame
#If you are going to use the time module
#don't do "from pygame import *"
pygame.init()
print('Hello')
pygame.time.wait(5000)#milliseconds
print('Bye')

matplotlib का फ़ंक्शन pyplot.pause() उदाहरण (यदि आप ग्राफ का उपयोग नहीं कर रहे हैं तो अनुशंसित नहीं है, लेकिन आप तुरंत ग्राफ से बाहर निकल सकते हैं):

import matplotlib
print('Hello')
matplotlib.pyplot.pause(5)#seconds 
print('Bye')

अंत में, .after .after() विधि (Tkinter के साथ सबसे अच्छा):

import tkinter as tk #Tkinter for python 2
root = tk.Tk()
print('Hello')
def ohhi():
 print('Oh, hi!')
root.after(5000, ohhi)#milliseconds and then a function
print('Bye')

यह समय विलंब का एक आसान उदाहरण है:

import time

def delay(period='5'):
    # If the user enters nothing, It'll wait 5 seconds
    try:
        #If the user not enters a int, I'll just return ''
        time.sleep(period)
    except:
        return ''

एक और, टिंकर में:

import tkinter

def tick():
    pass

root=Tk()
delay=100 # time in milliseconds
root.after(delay,tick)
root.mainloop()

पाइथन में समय देरी का सबसे अच्छा तरीका time पुस्तकालय का उपयोग करना है। ऐशे ही:

import time
time.sleep(10)

बस उस विलंब की मात्रा के साथ 10 को प्रतिस्थापित करें जिसे आप देरी करना चाहते हैं। आप '10 .1 ',' 5.07 'इत्यादि जैसे प्रारूपों का उपयोग कर सकते हैं।

टिंकर के साथ इसका उपयोग करने की अनुशंसा नहीं की जाती है


import time
time.sleep(5)   # Delays for 5 seconds. You can also use a float value.

यहां एक और उदाहरण दिया गया है जहां कुछ मिनट में लगभग एक बार चलाया जाता है:

import time
while True:
    print("This prints once a minute.")
    time.sleep(60) # Delay for 1 minute (60 seconds).

मैं पायथन में समय देरी कैसे कर सकता हूं?

एक धागे में मैं नींद समारोह का सुझाव देता हूं:

>>> from time import sleep

>>> sleep(4)

यह वास्तव में थ्रेड की प्रसंस्करण को निलंबित करता है जिसमें इसे ऑपरेटिंग सिस्टम द्वारा बुलाया जाता है, जिससे अन्य धागे और प्रक्रियाएं सोते समय निष्पादित होती हैं।

उस उद्देश्य के लिए इसका उपयोग करें, या किसी फ़ंक्शन को निष्पादित करने में देरी करें। उदाहरण के लिए:

>>> def party_time():
...     print('hooray!')
... 
>>> sleep(3); party_time()
hooray!

"हुर्रे!" एंटर दबाए जाने के 3 सेकंड बाद मुद्रित।

कई धागे और प्रक्रियाओं के साथ sleep का उपयोग उदाहरण

फिर, sleep आपके धागे को निलंबित कर देती है - यह शून्य प्रसंस्करण शक्ति के बगल में उपयोग करती है।

प्रदर्शित करने के लिए, इस तरह की एक स्क्रिप्ट बनाएं (मैंने पहले इसे एक इंटरैक्टिव पायथन 3.5 खोल में करने का प्रयास किया था, लेकिन उप-प्रक्रियाओं को किसी कारण से party_later फ़ंक्शन नहीं मिल रहा है):

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
from time import sleep, time

def party_later(kind='', n=''):
    sleep(3)
    return kind + n + ' party time!: ' + __name__

def main():
    with ProcessPoolExecutor() as proc_executor:
        with ThreadPoolExecutor() as thread_executor:
            start_time = time()
            proc_future1 = proc_executor.submit(party_later, kind='proc', n='1')
            proc_future2 = proc_executor.submit(party_later, kind='proc', n='2')
            thread_future1 = thread_executor.submit(party_later, kind='thread', n='1')
            thread_future2 = thread_executor.submit(party_later, kind='thread', n='2')
            for f in as_completed([
              proc_future1, proc_future2, thread_future1, thread_future2,]):
                print(f.result())
            end_time = time()
    print('total time to execute four 3-sec functions:', end_time - start_time)

if __name__ == '__main__':
    main()

इस स्क्रिप्ट से उदाहरण आउटपुट:

thread1 party time!: __main__
thread2 party time!: __main__
proc1 party time!: __mp_main__
proc2 party time!: __mp_main__
total time to execute four 3-sec functions: 3.4519670009613037

बहु सूत्रण

आप Timer थ्रेडिंग ऑब्जेक्ट के साथ एक अलग थ्रेड में बाद में एक फ़ंक्शन को ट्रिगर कर सकते हैं:

>>> from threading import Timer
>>> t = Timer(3, party_time, args=None, kwargs=None)
>>> t.start()
>>>
>>> hooray!

>>> 

खाली रेखा दिखाती है कि मेरे मानक को मुद्रित किया गया फ़ंक्शन और मुझे यह सुनिश्चित करने के लिए एंटर दबा देना पड़ा कि मैं एक प्रॉम्प्ट पर था।

इस विधि का उछाल यह है कि जब Timer थ्रेड इंतजार कर रहा था, तो मैं अन्य चीजों को करने में सक्षम था, इस मामले में, एक बार एंटर करना - फ़ंक्शन निष्पादित करने से पहले (पहला खाली संकेत देखें)।

मल्टीप्रोसेसिंग लाइब्रेरी में कोई संबंधित वस्तु नहीं है। आप एक बना सकते हैं, लेकिन यह संभवतः किसी कारण से मौजूद नहीं है। एक उप-थ्रेड एक पूरी नई उप-प्रक्रिया की तुलना में एक साधारण टाइमर के लिए बहुत अधिक समझ में आता है।


आप समय मॉड्यूल में sleep() फ़ंक्शन का उपयोग कर सकते हैं। यह उप दूसरे संकल्प के लिए एक फ्लोट तर्क ले सकता है।

from time import sleep
sleep(0.1) # Time in seconds.

जबकि हर किसी ने वास्तव में time मॉड्यूल का सुझाव दिया है, मैंने सोचा कि मैं matplotlib के pyplot फ़ंक्शन का उपयोग करके एक अलग विधि साझा pyplot , pause

एक उदाहरण

from matplotlib import pyplot as plt
plt.pause(5)    # Pauses the program for 5 seconds

आम तौर पर इस प्लॉट को प्लॉट या क्रूड एनीमेशन बनाने के लिए गायब होने से रोकने के लिए उपयोग किया जाता है।

यदि आपके पास पहले से ही matplotlib आयात किया गया है तो यह आपको एक import सहेज देगा।


नोट, यह उत्तर Python 2.x के लिए है क्योंकि यह 2008 में लिखा गया था, मेटाक्लास 3.x में थोड़ा अलग हैं, टिप्पणियां देखें।

Metaclasses गुप्त सॉस हैं जो 'वर्ग' काम करते हैं। एक नई शैली वस्तु के लिए डिफ़ॉल्ट मेटाक्लास को 'प्रकार' कहा जाता है।

class type(object)
  |  type(object) -> the object's type
  |  type(name, bases, dict) -> a new type

मेटाक्लास 3 तर्क लेते हैं। ' नाम ', ' आधार ' और ' dict '

यहां वह जगह है जहां रहस्य शुरू होता है। इस उदाहरण वर्ग परिभाषा में नाम, आधार और निर्देश कहां से आते हैं।

class ThisIsTheName(Bases, Are, Here):
    All_the_code_here
    def doesIs(create, a):
        dict

आइए एक मेटाक्लास को परिभाषित करें जो दिखाएगा कि ' वर्ग: ' इसे कैसे कॉल करता है।

def test_metaclass(name, bases, dict):
    print 'The Class Name is', name
    print 'The Class Bases are', bases
    print 'The dict has', len(dict), 'elems, the keys are', dict.keys()

    return "yellow"

class TestName(object, None, int, 1):
    __metaclass__ = test_metaclass
    foo = 1
    def baz(self, arr):
        pass

print 'TestName = ', repr(TestName)

# output => 
The Class Name is TestName
The Class Bases are (<type 'object'>, None, <type 'int'>, 1)
The dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']
TestName =  'yellow'

और अब, एक उदाहरण जिसका वास्तव में कुछ मतलब है, यह स्वचालित रूप से कक्षा में सेट "विशेषताएँ" सूची में चर बना देगा, और किसी भी पर सेट नहीं होगा।

def init_attributes(name, bases, dict):
    if 'attributes' in dict:
        for attr in dict['attributes']:
            dict[attr] = None

    return type(name, bases, dict)

class Initialised(object):
    __metaclass__ = init_attributes
    attributes = ['foo', 'bar', 'baz']

print 'foo =>', Initialised.foo
# output=>
foo => None

ध्यान दें कि मेटाक्लास init_attributes होने से प्राप्त 'व्यवहार' लाभ का जादू व्यवहार इनटाइलाइज्ड के उप-वर्ग पर पारित नहीं होता है।

यहां एक और अधिक ठोस उदाहरण दिया गया है, यह दर्शाता है कि क्लास बनने पर कार्रवाई करने वाले मेटाक्लास को बनाने के लिए आप 'टाइप' को कैसे उपclass कर सकते हैं। यह काफी मुश्किल है:

class MetaSingleton(type):
    instance = None
    def __call__(cls, *args, **kw):
        if cls.instance is None:
            cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)
        return cls.instance

 class Foo(object):
     __metaclass__ = MetaSingleton

 a = Foo()
 b = Foo()
 assert a is b




python delay sleep timedelay