print ausführen

[jan.b]

wenn ich jetzt zum Beispiel die print Anweisung "print("diese print Anweisung wird für 5 Sekunden ganz oft geprintet") ausführen will, wie kann ich das dann machen?

[Sirius3]

@jan.b: wie man Zeiten ermittelt, hast Du ja schon in Deinem anderen Thread gezeigt. Wo kommst Du bei der Aufgabe nicht weiter?

[BlackJack]

@jan.b: Dazu kann man beispielsweise die `time.time()`-Funktion verwenden um eine passende Bedingung für eine ``while``-Schleife zu formulieren.

[jan.b]

wenn ich das so eingeben würde, würde es natürlich nur einmal ausgegeben. aber ich will, dass es 5 Sekunden lang so oft wie möglich ausgegeben wird. wie bei einer schleife. nur halt eine mit zeitlicher Begrenzung.

[snafu]

Code: Alles auswählen

while aktuelle_zeit < alte_zeit + 5:
    print('Dein Text')

[pixewakb]

Code: Alles auswählen

import time

startzeit = time.time()
jetzt = time.time()
durchgang = 1

while jetzt - startzeit <= 5:

    print("{: 8d}. Ausgabe...".format(durchgang))
    durchgang += 1
    jetzt = time.time()

Das kannst Du so machen, weil time.time() einen Wert in Sekunden abhängig von ... liefert. Die Dokumentation zu time.time() liefert die Details (auch ...), was ich mir hier gespart habe. Möglicherweise ist es noch von Interesse.

[jan.b]

verdammt da hätte ich auch selbst drauf kommen können danke.

[jan.b]

vielen dank.

[snafu]

Fragt sich halt nur, in welchem Zusammenhang das gebraucht wird. In seiner jetzigen Form ist es doch eher sinnlos.

[snafu]

Hier mal (zur eigenen Übung) eine Uhr implementiert mit dem asyncio-Framework:

Code: Alles auswählen

import asyncio
from sys import stdout
from time import strftime

def update_clock(loop):
    now = strftime('%H:%M:%S')
    stdout.write('\r{}'.format(now))
    next_tick = int(loop.time()) + 1
    loop.call_at(next_tick, update_clock, loop)

def show_clock():
    loop = asyncio.get_event_loop()
    loop.call_soon(update_clock, loop)
    try:
        loop.run_forever()
    except KeyboardInterrupt:
        print('')
    finally:
        loop.close()

def main():
    print('Current time:')
    show_clock()

if __name__ == '__main__':
    main()

[Sirius3]

@pixewakb: jetzt hat es jan.b wieder geschafft, mit 0 Eigeninitiative eine Lösung präsentiert zu bekommen. Wenn man einen Zähler braucht, nimmt man `itertools.count`:

Code: Alles auswählen

import time
from itertools import count
 
startzeit = time.time()
for durchgang in count():
    print("{: 8d}. Ausgabe...".format(durchgang))
    if time.time() - startzeit > 5:
        break

Und weil wir ja bei Benchmarks sind, bei 5 Sekunden komme ich bis 100000.

[BlackJack]

Mein Rechner kommt bis ca. 600.000. Aber wie gesagt ist der Vergleich nicht wirklich sinnvoll, weil man dazu sagen müsste wie die Ausgabe aussieht (hier X-Server, KDE's Konsole, irgend so ein integrierter Intel Grafikchip).

Edit: Sicher das Du nicht eine 0 vergessen hast? Der Rechner hier ist schon etwas älter.

[kbr]

Ja, vermutlich fehlt eine Null. Mit einem nicht mehr ganz frischen i5 komme ich auf 1.000.000. Und wenn ich print aus der Schleife raus nehme, auf 18.000.000. Das ist zwar kein sinnvoller Benchmark, zeigt aber zumindest, was der Aufruf von print kostet. Zumindest auf meinem System.

[BlackJack]

@snafu: Da fehlt ein `stdout.flush()`, sonst wird das erst ausgegeben wenn der Puffer voll ist.

Ich hab's mal mit dem `sched`-Modul nachgebaut:

Code: Alles auswählen

from __future__ import absolute_import, division, print_function
import sched
from sys import stdout
from time import sleep, strftime, time


def print_time(scheduler):
    print('\r{0}'.format(strftime('%H:%M:%S')), end='')
    stdout.flush()
    scheduler.enter(0.5, 0, print_time, [scheduler])


def main():
    try:
        scheduler = sched.scheduler(time, sleep)
        print_time(scheduler)
        scheduler.run()
    except KeyboardInterrupt:
        print()


if __name__ == '__main__':
    main()

[snafu]

@snafu: Da fehlt ein `stdout.flush()`, sonst wird das erst ausgegeben wenn der Puffer voll ist.

Unter Windows funktioniert es auch ohne zu flushen. Für Linux hatte ich nicht dran gedacht, dass es mit der Anzeige dort anders läuft.

Wenn man schon die print()-Funktion benutzt, dann kann man auch so ein Flushen veranlassen:

Code: Alles auswählen

print('\r' + text, end='', flush=True)

[BlackJack]

@snafu: TypeError: 'flush' is an invalid keyword argument for this function

Ist mir also zu neumodisch.

[snafu]

Da hab ich wohl vergessen, dass du ja noch die Lochkarten-Version von Python verwendest...

[jan.b]

selbst wenn ich gefragt hätte wie lange der rechner für 1 mal print ausgeben brauch, dann hätte ich trotzdem gedacht, dass es ein verwertbares Ergebnis ist, weil man es ja mit anderen rechnern vergleichen kann

[snafu]

Ohne die Hardware zu kennen, ist das aber doch ziemlich nichtssagend. Du weißt dann nur, dass Forenmitglied XY den Code so-und-so schnell laufen lassen konnte. Was bringt dir das?

Benchmarks sind normalerweise dafür gedacht, technische Vergleiche anstellen zu können. Entweder weil man wissen will, unter welchen System-Bedingungen etwas schneller oder langsamer läuft. Oder weil man möglichst schnellen Code haben will und dann eben unterschiedliche Herangehensweisen für die selbe Sache misst.

[BlackJack]

@jan.b: Dir Messung von *einem* Ausführen eines sehr kurzen/schnellen Stück Code sind überhaupt nicht verwert- oder vergleichbar. Du musst auch wissen wie stark die Abweichung von der Zeit auf dem selben Rechner ist und ob die überhaupt so stabil ist, dass sie überhaupt aussagekräftig ist.

Und bei `print()` gibt es wie schon gesagt viel zu viele externe Faktoren die den Grossteil der Laufzeit verbrauchen, als das man das wirklich sinnvoll vergleichen kann.

Python ist hier bei mir übrigens schneller als Tcl. Damit komme ich nur bis ca. 450.000.
[codebox=tcl file=Unbenannt.txt]#!/usr/bin/env tclsh

set end [expr [clock seconds] + 5]
set i 0

while {[clock seconds] < $end} {
puts [format "% 8d. Ausgabe..." $i]
incr i
}[/code]