1

I wrote this function a while back:

def faster_print(*args, sep=" ", end="\n", file=stdout):
    file.write(sep.join(map(str, args))+end)

and I tested it:

from sys import stdout
from time import perf_counter

def faster_print(*args, sep=" ", end="\n", file=stdout):
    file.write(sep.join(map(str, args))+end)

def time(function, *args, **kwargs):
    start = perf_counter()
    function(*args, **kwargs)
    return perf_counter()-start

def using_normal_print(number):
    for i in range(number):
        print("Hello world.", 5, 5.0, ..., str)

def using_faster_print(number):
    for i in range(number):
        faster_print("Hello world.", 5, 5.0, ..., str)

normal_time = time(using_normal_print, number=100)
faster_time = time(using_faster_print, number=100)

print("Normal print:", normal_time)
print("My print function", faster_time)

It turns out that it is only faster in IDLE and not cmd. I know that IDLE creates its own objects for sys.stdout, sys.stdin and sys.stderr but I don't get why it only slows down python's built in print function. This answer says that the built in print function is written in c. Shouldn't that make it faster as my function needs to be compiled from python bytecode into machine code?

I am using Python 3.7.9 and IDLE version 3.7.9

Improve this question
12
  • 1
    datetime.now() is not necessarily accurate for this purpose; you should use time.perf_counter as this "a clock with the highest available resolution to measure a short duration", or rather than rolling your own timing code you could use the timeit module. Commented Feb 19, 2021 at 23:43
  • Don't benchmark with datetime.now(). You should use time.process_time instead. Commented Feb 19, 2021 at 23:43
  • Ok I will try that and update the question Commented Feb 19, 2021 at 23:44
  • 1
    using timeit they are both roughly the same for 1k iterations Commented Feb 19, 2021 at 23:45
  • @TeejayBruno Are you using IDLE? What version? Commented Feb 19, 2021 at 23:46

1 Answer 1

Reset to default
1

TheLizard, thank you for reporting and amending your experiments. As an IDLE maintainer, am concerned about IDLE speed. I noticed that printing to screen is sometimes much slower than in the Python terminal/console REPL. In the latter, Python executes in the same process as the screen window and screen.write directly writes to the screen buffer. IDLE, on the other hand, executes user code in a separate process. In that process, the replacement sys.stdout send output through a socket to the IDLE GUI process, which then call tkinter text.insert, which calls tcl/tk functions that write to a screen bugger. But until now, I have not properly investigated.

I ran your code in 3.10.0a5 on my Win 10 machine. In the REPL, normal and fast print took .05 seconds. In IDLE, they took about 1.1 and .3 seconds. The factor of 6 (.3/.05) is explained by the overhead above. But the additional factor of about 3.7 (1.1/.3)?

To test kaya3's 2nd hypothesis, I defined s = 'a'*75 and replaced your print arguments by s. In REPL, times are still .05 and .05. In IDLE, they are about .41 and .31. I conclude that there is a little internal print function overhead, but that most of the 3.7 is additional socket-to-screen overhead. When print is writing to a buffer, there is no reason to pre-join little strings, because multiple stdout.writes are essentially doing a join, whether to the screen buffer or a disk buffer.

To further test this, I altered the test to write 3 blocks of 40 lines. The REPL times remain the same. In IDLE, they average about .058 and .05, about as fast as in the REPL.

Conclusion: I should document that if one prints in code written to run regularly in IDLE and one cares about speed, one should pre-assemble everything one wants displayed together into one string first and just print that string. IDLE does this for tracebacks, which is why they display 'all at once'.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

Thanks for the detailed answer. So the only way to make IDLE faster is to force cpython into joining the args passed into its print function before writing to stdout.
What I suggested is that users who care should join args and possibly lines and call print with a single string argument. I am adding a paragraph about this to the IDLE docs now. I once filled Shell with 500000 40 char lines to see if scrolling still worked OK (yes it did). Printing 1000 lines at once would have been faster ;-). I considered the possibility of replacing built-in print, but this would have the problem of exact emulation and making IDLE different even if the emulation were perfect.
I don't think this is a good suggestion but what if IDLE took all of the stdout and wrote that to a buffer that is written a few milliseconds later to tkinter. It shouldn't be hard to implement with a <tkinter.Tk>.after script. Otherwise everyone should just join the print args if they are printing a lot of stuff.
Part of the reason for running user code is a 2nd process is so that user tkinter code and IDLE's GUI tkinter code do not interfere. So idlelib.run, which sets up the execution process and its connection to the gui process, does not run tkinter/tk code.
The connection is handled in a separate thread, so I thought of having that thread sleep while waiting, but I doubt that would not work either, because sleep cannot be interrupted and the Windows' minimum sleep is, I believe at least 16 milleseconds.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.