In [8]:

    

import time
import timeit


    

In [9]:

    

help(timeit.Timer)


    

    




Help on class Timer in module timeit:

class Timer(builtins.object)
 |  Class for timing execution speed of small code snippets.
 |  
 |  The constructor takes a statement to be timed, an additional
 |  statement used for setup, and a timer function.  Both statements
 |  default to 'pass'; the timer function is platform-dependent (see
 |  module doc string).  If 'globals' is specified, the code will be
 |  executed within that namespace (as opposed to inside timeit's
 |  namespace).
 |  
 |  To measure the execution time of the first statement, use the
 |  timeit() method.  The repeat() method is a convenience to call
 |  timeit() multiple times and return a list of results.
 |  
 |  The statements may contain newlines, as long as they don't contain
 |  multi-line string literals.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, stmt='pass', setup='pass', timer=<built-in function perf_counter>, globals=None)
 |      Constructor.  See class doc string.
 |  
 |  print_exc(self, file=None)
 |      Helper to print a traceback from the timed code.
 |      
 |      Typical use:
 |      
 |          t = Timer(...)       # outside the try/except
 |          try:
 |              t.timeit(...)    # or t.repeat(...)
 |          except:
 |              t.print_exc()
 |      
 |      The advantage over the standard traceback is that source lines
 |      in the compiled template will be displayed.
 |      
 |      The optional file argument directs where the traceback is
 |      sent; it defaults to sys.stderr.
 |  
 |  repeat(self, repeat=3, number=1000000)
 |      Call timeit() a few times.
 |      
 |      This is a convenience function that calls the timeit()
 |      repeatedly, returning a list of results.  The first argument
 |      specifies how many times to call timeit(), defaulting to 3;
 |      the second argument specifies the timer argument, defaulting
 |      to one million.
 |      
 |      Note: it's tempting to calculate mean and standard deviation
 |      from the result vector and report these.  However, this is not
 |      very useful.  In a typical case, the lowest value gives a
 |      lower bound for how fast your machine can run the given code
 |      snippet; higher values in the result vector are typically not
 |      caused by variability in Python's speed, but by other
 |      processes interfering with your timing accuracy.  So the min()
 |      of the result is probably the only number you should be
 |      interested in.  After that, you should look at the entire
 |      vector and apply common sense rather than statistics.
 |  
 |  timeit(self, number=1000000)
 |      Time 'number' executions of the main statement.
 |      
 |      To be precise, this executes the setup statement once, and
 |      then returns the time it takes to execute the main statement
 |      a number of times, as a float measured in seconds.  The
 |      argument is the number of times through the loop, defaulting
 |      to one million.  The main statement, the setup statement and
 |      the timer function to be used are passed to the constructor.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

In [10]:

    

help(timeit.timeit)


    

    




Help on function timeit in module timeit:

timeit(stmt='pass', setup='pass', timer=<built-in function perf_counter>, number=1000000, globals=None)
    Convenience function to create Timer object and call timeit method.

In [11]:

    

setup_sum='sum=0'
run_sum="""
for i in range(1,1000):
    if i % 3 ==0:
        sum = sum + i
"""
print(timeit.Timer(run_sum, setup="sum=0").repeat(1,10000))


    

    




[2.1555415100001483]

In [12]:

    

t=timeit.timeit(run_sum,setup_sum,number=10000)


    

In [13]:

    

print("Time for built-in sum(): {}".format(t))


    

    




Time for built-in sum(): 2.1465617119999933

In [14]:

    

start=time.time()


    

In [15]:

    

sum=0
for i in range(1,10000):
    if i % 3==0:
        sum+=i


    

In [16]:

    

end=time.time()


    

In [17]:

    

print("Time for trading way to count the time is %f"%(end-start))


    

    




Time for trading way to count the time is 0.166277

In [ ]: