delay delay - Wie kann ich in Python eine Verzögerung machen?



without sleep (12)

Ich würde gerne wissen, wie man ein Python-Skript zeitlich verzögert.


Answers

Die beste Möglichkeit, die Zeit in Python zu verzögern, ist die Verwendung der Zeitbibliothek. So was:

import time
time.sleep(10)

Ersetzen Sie einfach 10 durch die Anzahl der Sekunden, die Sie verzögern möchten. Sie können Formate wie '10 .1 ',' 5.07 'usw. verwenden.

Es wird nicht empfohlen, dies mit Tkinter zu verwenden


Verzögerungen können mit drei Methoden implementiert werden.

Beginnen wir mit dem einfachsten:

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

Die zweite zu verzögernde Methode wäre die implizite wait-Methode:

 driver.implicitly_wait(5)

Die dritte Methode ist nützlicher, wenn Sie warten müssen, bis eine bestimmte Aktion abgeschlossen ist oder ein Element gefunden wird:

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

Während alle anderen das De-facto- time Modul vorgeschlagen haben, dachte ich, ich würde eine andere Methode mit der matplotlib -Funktion von pyplot verwenden, pause .

Ein Beispiel

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

Normalerweise wird dies verwendet, um zu verhindern, dass der Plot beim Plotten verschwindet, oder um grobe Animationen zu erstellen.

Dies würde Ihnen einen import ersparen, wenn Sie bereits matplotlib importiert haben.


Sie können die sleep() Funktion im Zeitmodul verwenden. Es kann ein Float-Argument für eine zweite Auflösung dauern.

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

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

Hier ist ein weiteres Beispiel, bei dem ungefähr einmal pro Minute etwas ausgeführt wird:

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

Ein bisschen Spaß mit einem verschlafenen generator .

Die Frage ist über Zeitverzögerung. Es kann eine feste Zeit sein, aber in einigen Fällen benötigen wir möglicherweise eine seit dem letzten Mal gemessene Verzögerung. Hier ist eine mögliche Lösung:

Gemessene Verzögerung seit dem letzten Mal (regelmäßiges Aufwachen)

Die Situation kann sein, wir wollen so regelmäßig wie möglich etwas tun und wir wollen uns nicht mit all dem last_time , next_time Zeug rund um unseren Code last_time next_time .

Summer-Generator

Der folgende Code ( sleepy.py ) definiert einen buzzergen Generator:

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

Regelmäßiges Buzzergen aufrufen

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()

Und wenn wir es ausführen, sehen wir:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

Wir können es auch direkt in einer Schleife verwenden:

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

Und wenn wir es ausführen, könnten wir sehen:

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)

Wie wir sehen, ist dieser Summer nicht zu starr und erlaubt es uns, regelmäßig verschlafene Intervalle einzuhalten, selbst wenn wir verschlafen und den regulären Zeitplan verlassen.


import time
time.sleep(1) #sleep for one second.

Einfaches Beispiel:

#After five seconds,output "hello python!!!"
import time
time.sleep(5)
print("hello python!!!")

Verzögerungen werden mit der time.sleep() gemacht, insbesondere mit der Funktion time.sleep() ...

Um es einfach warten zu lassen:

from time import sleep
sleep(1)

Das funktioniert, weil:

from time import sleep

Sie extrahieren die time.sleep() nur aus der Zeitbibliothek. Sie können sie also einfach mit aufrufen:

sleep(seconds)

anstatt tippen zu müssen

time.sleep()

das ist unhandlich lang zu tippen.

Mit dieser Methode erhalten Sie keinen Zugriff auf die anderen Funktionen der Zeitbibliothek, und Sie können keine Variable mit dem Namen sleep haben. Sie können jedoch eine Variable mit dem Namen Uhrzeit erstellen.

Das Ausführen from [library] import [function] (, [function2]) ist ideal, wenn Sie nur bestimmte Teile eines Moduls benötigen.

Sie könnten es auch als tun

import time
time.sleep(1)

und Sie hätten Zugriff auf die anderen Funktionen der time.clock() wie time.clock() , solange Sie time.[function]() time.clock() , die variable Zeit konnte jedoch nicht erstellt werden.


Es gibt 4 Methoden, die ich kenne: time.sleep() , pygame.time.wait() , matplotlibs pyplot.pause() und .after() .

time.sleep() Beispiel (nicht verwenden, wenn Tkinter verwendet wird):

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

pygame.time.wait() (nicht zu empfehlen, wenn Sie das Pygame-Fenster nicht verwenden, aber Sie könnten das Fenster sofort schließen):

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')

matplotlibs Funktion pyplot.pause() Beispiel (nicht zu empfehlen, wenn Sie die Grafik nicht verwenden, aber Sie können die Grafik sofort beenden):

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

Zum Schluss noch die .after() Methode (am besten mit 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')

Bitte lesen Sie https://web.archive.org/web/20090207081238/http://faqts.com/knowledge_base/view.phtml/aid/2609/fid/378 , die Ihnen weiterhelfen können:

Versuchen Sie die Sleep-Funktion im Zeitmodul.

import time
time.sleep(60)

Fügen Sie dies in eine while Schleife ein, und eine Anweisung wird nur in der Minute ausgeführt. Damit können Sie eine Anweisung in vordefinierten Intervallen ausführen, unabhängig davon, wie lange der Befehl dauert (sofern dies weniger als eine Minute oder 5 oder 60 dauert.) oder was auch immer Sie eingestellt haben) Zum Beispiel wollte ich einmal pro Minute einen Ping ausführen. Wenn ich einfach nur time.sleep(60) oder time.sleep(45) , time.sleep(45) der Ping nicht immer gleich viel Zeit. Hier ist der Code :)

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

Die [5] zieht nur die Sekunden aus dem time.localtime() von time.localtime() .

Das Tolle an time.sleep ist, dass Fließkommazahlen unterstützt werden!

import time
time.sleep(0.1) 

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


Die tkinter-Bibliothek in der Python-Standardbibliothek ist ein interaktives Werkzeug, das Sie importieren können. Grundsätzlich können Sie Schaltflächen, Boxen und Popups sowie Elemente erstellen, die als Fenster angezeigt werden, die Sie mit Code bearbeiten.

Wenn Sie tkinter verwenden, VERWENDEN Sie TIME.SLEEP() NICHT, da dadurch Ihr Programm TIME.SLEEP() wird. Das ist mir passiert. Verwenden root.after() stattdessen root.after() und ersetzen Sie die Werte für viele Sekunden durch Millisekunden. time.sleep(1) entspricht z. B. root.after(1000) in tkinter.

Ansonsten time.sleep() , auf die viele Antworten hingewiesen haben, ist der Weg.


Was sind Metaklassen? Wofür benutzt du sie?

TLDR: Eine Metaklasse instanziiert und definiert das Verhalten für eine Klasse wie eine Klasse, die instanziiert wird, und definiert das Verhalten für eine Instanz.

Pseudocode:

>>> Class(...)
instance

Das oben genannte sollte bekannt aussehen. Nun, wo kommt die Class ? Es ist eine Instanz einer Metaklasse (auch Pseudocode):

>>> Metaclass(...)
Class

In echtem Code können wir die Standard-Metaklasse, type , alles übergeben, was wir zum Instanziieren einer Klasse benötigen, und wir erhalten eine Klasse:

>>> type('Foo', (object,), {}) # requires a name, bases, and a namespace
<class '__main__.Foo'>

Anders ausgedrückt

  • Eine Klasse ist eine Instanz, wie eine Metaklasse eine Klasse.

    Wenn wir ein Objekt instanziieren, erhalten wir eine Instanz:

    >>> object()                          # instantiation of class
    <object object at 0x7f9069b4e0b0>     # instance
    

    Wenn wir eine Klasse explizit mit der Standard-Metaklasse type , wird sie instanziiert:

    >>> type('Object', (object,), {})     # instantiation of metaclass
    <class '__main__.Object'>             # instance
    
  • Anders ausgedrückt: Eine Klasse ist eine Instanz einer Metaklasse:

    >>> isinstance(object, type)
    True
    
  • Ein dritter Weg: Eine Metaklasse ist die Klasse einer Klasse.

    >>> type(object) == type
    True
    >>> object.__class__
    <class 'type'>
    

Wenn Sie eine Klassendefinition schreiben und diese von Python ausführen, verwendet sie eine Metaklasse, um das Klassenobjekt zu instanziieren (das wiederum dazu verwendet wird, Instanzen dieser Klasse zu instanziieren).

Genauso wie Klassendefinitionen verwendet werden können, um das Verhalten von benutzerdefinierten Objektinstanzen zu ändern, können wir eine Metaklassenklassendefinition verwenden, um das Verhalten eines Klassenobjekts zu ändern.

Wofür können sie verwendet werden? Aus den docs :

Die möglichen Verwendungen von Metaklassen sind grenzenlos. Einige Ideen, die erforscht wurden, umfassen Protokollierung, Schnittstellenprüfung, automatische Delegierung, automatische Erstellung von Eigenschaften, Proxies, Frameworks und automatische Sperrung / Synchronisierung von Ressourcen.

Nichtsdestotrotz wird der Benutzer in der Regel dazu angehalten, die Verwendung von Metaklassen zu vermeiden, sofern dies nicht unbedingt erforderlich ist.

Sie verwenden jedes Mal eine Metaklasse, wenn Sie eine Klasse erstellen:

Wenn Sie zum Beispiel eine Klassendefinition schreiben,

class Foo(object): 
    'demo'

Sie instanziieren ein Klassenobjekt.

>>> Foo
<class '__main__.Foo'>
>>> isinstance(Foo, type), isinstance(Foo, object)
(True, True)

Es entspricht dem funktional aufrufenden type mit den entsprechenden Argumenten und der Zuordnung des Ergebnisses zu einer Variablen dieses Namens:

name = 'Foo'
bases = (object,)
namespace = {'__doc__': 'demo'}
Foo = type(name, bases, namespace)

Beachten Sie, dass einige Dinge automatisch zum __dict__ hinzugefügt werden, dh zum Namespace:

>>> Foo.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, 
'__module__': '__main__', '__weakref__': <attribute '__weakref__' 
of 'Foo' objects>, '__doc__': 'demo'})

Die Metaklasse des von uns erstellten Objekts ist in beiden Fällen type .

(Eine Randnotiz zum Inhalt der Klasse __dict__ : __module__ ist da, weil Klassen wissen müssen, wo sie definiert sind, und __dict__ und __weakref__ sind da, weil wir __slots__ nicht definieren - wenn wir __slots__ definieren, __slots__ wir ein bisschen Platz in den Instanzen, da wir __dict__ und __weakref__ durch Ausschluss von ihnen verbieten können, zum Beispiel:

>>> Baz = type('Bar', (object,), {'__doc__': 'demo', '__slots__': ()})
>>> Baz.__dict__
mappingproxy({'__doc__': 'demo', '__slots__': (), '__module__': '__main__'})

... Aber ich schweife ab.)

Wir können type wie jede andere Klassendefinition erweitern:

Hier ist die Standardeinstellung von Klassen:

>>> Foo
<class '__main__.Foo'>

Eines der wertvollsten Dinge, die wir standardmäßig beim Schreiben eines Python-Objekts tun können, ist, es mit einem guten __repr__ . Wenn wir help(repr) aufrufen help(repr) erfahren wir, dass es einen guten Test für __repr__ , der auch einen Test auf Gleichheit erfordert - obj == eval(repr(obj)) . Die folgende einfache Implementierung von __repr__ und __eq__ für Klasseninstanzen unseres Typs class bietet eine Demonstration, die die Standardwerte von __repr__ von Klassen verbessern kann:

class Type(type):
    def __repr__(cls):
        """
        >>> Baz
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        >>> eval(repr(Baz))
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        """
        metaname = type(cls).__name__
        name = cls.__name__
        parents = ', '.join(b.__name__ for b in cls.__bases__)
        if parents:
            parents += ','
        namespace = ', '.join(': '.join(
          (repr(k), repr(v) if not isinstance(v, type) else v.__name__))
               for k, v in cls.__dict__.items())
        return '{0}(\'{1}\', ({2}), {{{3}}})'.format(metaname, name, parents, namespace)
    def __eq__(cls, other):
        """
        >>> Baz == eval(repr(Baz))
        True            
        """
        return (cls.__name__, cls.__bases__, cls.__dict__) == (
                other.__name__, other.__bases__, other.__dict__)

Wenn wir nun ein Objekt mit dieser Metaklasse erstellen, bietet das __repr__Echo in der Befehlszeile einen viel weniger hässlichen Anblick als der Standard:

>>> class Bar(object): pass
>>> Baz = Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
>>> Baz
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})

Mit einem __repr__für die Klasseninstanz definierten Code haben wir eine stärkere Möglichkeit, unseren Code zu debuggen. Eine weitere Überprüfung eval(repr(Class))ist jedoch unwahrscheinlich (da Funktionen normalerweise nicht von ihren Standardwerten abgewälzt werden könnten __repr__).

Eine erwartete Verwendung: __prepare__ein Namespace

Wenn wir beispielsweise wissen möchten, in welcher Reihenfolge die Methoden einer Klasse erstellt werden, können wir ein geordnetes Diktat als Namespace der Klasse angeben. Wir würden dies tun, mit __prepare__dem das Namespace dict für die Klasse zurückgegeben wird, wenn es in Python 3 implementiert ist :

from collections import OrderedDict

class OrderedType(Type):
    @classmethod
    def __prepare__(metacls, name, bases, **kwargs):
        return OrderedDict()
    def __new__(cls, name, bases, namespace, **kwargs):
        result = Type.__new__(cls, name, bases, dict(namespace))
        result.members = tuple(namespace)
        return result

Und Verwendung:

class OrderedMethodsObject(object, metaclass=OrderedType):
    def method1(self): pass
    def method2(self): pass
    def method3(self): pass
    def method4(self): pass

Und jetzt haben wir eine Aufzeichnung der Reihenfolge, in der diese Methoden (und andere Klassenattribute) erstellt wurden:

>>> OrderedMethodsObject.members
('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4')

Beachten Sie, dass dieses Beispiel aus der docs angepasst wurde - die neue Enumeration in der Standardbibliothek macht dies.

Also haben wir eine Metaklasse durch Erstellen einer Klasse instanziiert. Wir können die Metaklasse auch wie jede andere Klasse behandeln. Es hat eine Methodenauflösungsreihenfolge:

>>> inspect.getmro(OrderedType)
(<class '__main__.OrderedType'>, <class '__main__.Type'>, <class 'type'>, <class 'object'>)

Und es hat ungefähr das Richtige repr(was wir nicht mehr auswerten können, wenn wir keinen Weg finden, unsere Funktionen darzustellen).

>>> OrderedMethodsObject
OrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet
hodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d
ict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})




python delay sleep timedelay