Would like to write code in idle that I have in Jupyter notebook. It is using Timeit

Question

code big_array= np.random.rand(1000000) %timeit sum(big_array)

this code above is done in jupyter notebook how do I use this code in idle

Answer 1

With IDLE

The most direct is to build the timer into your Python code and then run it using IDLE based on here:

Using IDLE as you do run this based on the code you provided:

import time
start = time.process_time()
import numpy as np
big_array= np.random.rand(1000000)
sum(big_array)  
print(time.process_time() - start)

If you wanted to use Pyinstrument (see below section), that is possible, too. The documentation suggests with your code that would be:

from pyinstrument import Profiler
profiler = Profiler()
profiler.start()
import numpy as np
big_array= np.random.rand(1000000)
sum(big_array)  
profiler.stop()
profiler.print()

---

---

Alternative using Python installed on your system with the Python Profiler tool Pyinstrument and your code as a script

(I'm adding this because this is the more mature route. You won't really want weave the time/profiling into your code as you start develop more capable code and functions. And you probably won't use IDLE much down the road.)

The easiest is to make your code a script and then time it using pure Python and not Jupyter/IPython magics. I gather based on your code provided, you'd save your script, my_script.py with the following contents:

import numpy as np
big_array= np.random.rand(1000000)
sum(big_array)

I tried using the cProfiler suggested here and wasn't having much luck adapting that code example, and so I used a more modern profiler, pyinstrument, I had seen suggested by somebody much more knowledgeable about Python than myself. (Later, saw here I could just use python -m cProfile my_script.py to use the cProfiler, but after using pyinstrument first I could quickly see why pyinstrument was recommended.)

I installed that easily with pip install pyinstrument. And then ran the following on the command line/terminal:

pyinstrument my_script.py 

That's meant to be the equivalent of running python my_script.py on your command line/terminal, now with wrapping it in the pyinstrument profiling, see the documentation.

You'll see lots of profiling information including the time:

jovyan@jupyter-binder-2dexamples-2drequirements-2dfg42zx6b:~$ pyinstrument my_script.py

  _     ._   __/__   _ _  _  _ _/_   Recorded: 15:05:41  Samples:  96
 /_//_/// /_\ / //_// / //_'/ //     Duration: 0.424     CPU time: 0.416
/   _/                      v4.1.1

Program: my_script.py

0.423 <module>  <string>:1
   [4 frames hidden]  <string>, runpy
      0.423 _run_code  runpy.py:64
      └─ 0.423 <module>  sum_test.py:1
         ├─ 0.224 <module>  numpy/__init__.py:1
         │     [231 frames hidden]  numpy, pickle, struct, <built-in>, pa...
         │        0.088 create_dynamic  <built-in>:0
         ├─ 0.176 sum  <built-in>:0
         │     [2 frames hidden]  <built-in>
         └─ 0.024 RandomState.rand  <built-in>:0
               [2 frames hidden]  <built-in>

To view this report with different options, run:
    pyinstrument --load-prev 2022-05-27T15-05-41 [options]

Add some more zeros to the number in big_array= np.random.rand(1000000) and you can really see the sum() step become the rate-limiting one in the whole process of running that code.