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


मैं जानना चाहूंगा कि कैसे एक पायथन स्क्रिप्ट में समय देरी डालनी है I



Answers



import time
time.sleep(5)   # delays for 5 seconds. You can Also Use 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(0.1) # Time in seconds.



कृपया 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() की वापसी मूल्य

समय के बारे में महान बात यह है कि यह अस्थायी बिंदु संख्याओं का समर्थन करता है!

import time
time.sleep(0.1) 

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




नींद जनरेटर के साथ थोड़ा मज़ा।

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

पिछली बार से देर से मापा (नियमित रूप से जागने)

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

बजर जनरेटर

निम्नलिखित कोड ( नीलामी ) 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

नियमित बजरजेन को शामिल करना

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)

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




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

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

>>> from time import sleep

>>> sleep(4)

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

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

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

"हुर्रे!" 3 सेकंड के बाद मैंने एंट मारा मारा

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

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

प्रदर्शित करने के लिए, इस तरह एक स्क्रिप्ट party_later (मैंने पहली बार एक इंटरैक्टिव पायथन 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 थ्रेड का इंतजार करते समय, मैं अन्य बातों को करने में सक्षम था, इस मामले में, एक बार एंटर करने से पहले - फ़ंक्शन निष्पादित होने से पहले (पहला खाली प्रॉम्प्ट देखें)।

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




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

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

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




समय देरी लगाने के लिए आपको time मॉड्यूल आयात करना चाहिए। और उस मॉड्यूल के साथ आपको केवल लिखना होगा:

time.sleep(The amount of time)

उदाहरण के लिए यदि आप कंप्यूटर को दूसरी पंक्ति चलाने से पहले एक सेकंड का समय देरी करना चाहते हैं तो आपको रखना चाहिए:

time.sleep(1)
print('Hello World!')

बस इतना ही :)




अच्छा प्रश्न।

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

from time import sleep

# doing stuff
sleep(0.5) # sleeping half a second (sleep() uses seconds, but you can also use floats)
# doing stuff..

आशा है, मैं मदद कर सकता हूँ




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

सिर्फ एक सेकंड के लिए इंतजार करने के लिए:

from time import sleep
sleep(1)

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

from time import sleep

आप केवल समय लाइब्रेरी से नींद समारोह निकालने का मतलब है कि आप इसे केवल इसके साथ कॉल कर सकते हैं:

sleep(seconds)

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

time.sleep()

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

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

[पुस्तकालय] आयात [समारोह] ([[function2]) से करना अच्छा है अगर आप सिर्फ एक मॉड्यूल के कुछ भागों चाहते हैं।

आप समान रूप से ऐसा कर सकते हैं:

import time
time.sleep(1)

और आपके पास टाइम लाइब्रेरी की अन्य विशेषताओं तक पहुंच होती है जैसे कि टाइम.क्लॉक () जब तक आप समय टाइप करते हैं फ़ंक्शन लेकिन आप चर समय नहीं बना सका।




देरी तीन तरीकों का उपयोग करके लागू किया जा सकता है।

सबसे आसान एक के साथ शुरू करते हैं:

import time
time.sleep(5) #delay for 5 seconds.

देरी का दूसरा तरीका अंतर्वस्तु प्रतीक्षा विधि का उपयोग करेगा।

 driver.implicitly_wait(5)

तीसरा तरीका अधिक उपयोगी होता है, जब तक आपको किसी विशेष कार्यवाही तक इंतजार करना पड़ता है या जब तक कोई तत्व नहीं मिलता है।

self.wait.until(EC.presence_of_element_located((By.ID, 'UserName'))



पैगमेम का उपयोग करना

import pygame
pygame.init()
while True:
    pygame.time.wait(1000)
    print("This prints every second.")
    print("Please note that this method uses milliseconds.")