¿Cómo se sincroniza el tiempo de ejecución de un lote de código en Python?

Question

Encontré esta pregunta y respuesta aquí en StackOverflow.

Python - time.clock() vs. time.time() - accuracy?

Aquí hay un código que estoy tratando de ejecutar:

import sys 
import time 
import timeit 

if (len(sys.argv) > 1): 
    folder_path = sys.argv[1] 
    if not os.path.isdir(folder_path): 
    print "The folder you provided doesn't exist"  
    else: 
    print_console_headers()  
    rename_files_to_title_case(folder_path) 
    #start the timer. 
    #do some freaky magic here. 
    #end the timer. 

else: 
    print "You must provide a path to a folder." 

def print_console_headers(): 
    print "Renaming files..." 
    print "--------------------" 
    return 

def rename_files_to_title_case(): 
    """this is just for testing purposes""" 
    L = [] 
    for i in range(100): 
     L.append(i) 

if __name__ == '__main__': 
    from timeit import Timer 
    t = Timer("test()", "from __main__ import test") 
    print t.timeit() 

¿Cómo me timeit dar una función con un parámetro que se ha guardado en otro lugar?

Esto es algo que he escrito en Ruby que me dio resultados en código limpio, tal vez esto ayude con sugerencias.

start_time = Time.now 

folder_path = ARGV[0] 
i = 0 
Dir.glob(folder_path + "/*").sort.each do |f| 
    filename = File.basename(f, File.extname(f)) 
    File.rename(f, folder_path + "/" + filename.gsub(/\b\w/){$&.upcase} + File.extname(f)) 
    i += 1 
end 

puts "Renaming complete." 
puts "The script renamed #{i} file(s) correctly." 
puts "----------" 
puts "Running time is #{Time.now - start_time} seconds" 

Answer 1

Esto es como normalmente escribo código de medición de tiempo en Python:

start_time = time.time() 

# ... do stuff 

end_time = time.time() 
print("Elapsed time was %g seconds" % (end_time - start_time)) 

Como se mencionó en la entrada que está conectado, time.clock() no es apropiado para medir el tiempo transcurrido desde que informa de la cantidad de CPU tiempo utilizado por su proceso solamente (al menos en sistemas Unix). El uso de time.time() es multiplataforma y confiable.

Answer 2

Una manera divertida de sincronizar las funciones es mediante el uso de decoradores y funciones de envoltura. Una de las funciones que uso para esto es:

import time 

def print_timing(func): 
    def wrapper(*arg): 
     t1 = time.time() 
     res = func(*arg) 
     t2 = time.time() 
     string = '| %s took %0.3f ms |' % (func.func_name, (t2-t1)*1000.0) 
     print 
     print '-'*len(string) 
     print string 
     print '-'*len(string) 
     print 
     return res 
    return wrapper 

Cualquier función decorado por @print_timing, imprimirá imprimir el tiempo que le llevó a la salida estándar

@print_timing 
def some_function(text): 
    print text 

Esto hace que sea muy conveniente para funciones específicas de tiempo.

Answer 3

Usaría un decorador de tiempo y colocaría el código que desea sincronizar en una función.

import time 

def timeit(f): 

    def timed(*args, **kw): 

     ts = time.time() 
     result = f(*args, **kw) 
     te = time.time() 

     print 'func:%r args:[%r, %r] took: %2.4f sec' % \ 
      (f.__name__, args, kw, te-ts) 
     return result 

    return timed 

Usando el decorador es fácil usar anotaciones.

@timeit 
def compute_magic(n): 
    #function definition 
    #.... 

O alias la función que desea medir el tiempo.

compute_magic = timeit(compute_magic) 

Mi publicación del blog aquí contiene más información. http://blog.mattalcock.com/2013/2/24/timing-python-code/

Answer 4

Si tiene que medir un momento de líneas específicas de código dentro de la función, cuando decorador no puede ayudar a que hay una solución

import time 
from time import sleep 

class TT(object): 
    def __init__(self): 
     self.start = time.time() 
    def __str__(self): 
     return str(time.time() - self.start) 


timeit = TT() 

sleep(1) 
print timeit 

sleep(2) 
print timeit 

imprimirá:

1.0 
3.00