Unix - module time : temps d'une fonction algorithmique avec time() et clock()

Commenter

Contenu du snippet

Ce code source, présente les fonctions clock() et time() présent dans le module time.
J'ai écris cette source pour mettre en avant ces deux fonctions, comprendre leur légère différence, et permettre simplement de tester ses fonctions algorithmiques à travers.
En effet il est important de savoir, si son code est optimisé ou pas en le soumettant à un test de temps (bien sûr, il est nécessaire de disposer d'au moins deux algorihtmes pour les comparer).

On aurait pu aussi inclure le test de pytone (peut être pour une prochaine fois)
Il existe une autre méthode (surement la plus utilisé), qui permet de tester la vitesse d'un programme sous linux.
C'est la commande "time monprogramme". Je vous laisse vous renseigner ;).
Néanmoins ca pose des problèmes sur l'isolement de l'algo en question du reste du programme.

Bref, en espérant que cette première contribution à CS soit utile :)

NB : Je l'ai mis dans "Tutoriaux", car j'explique au début les deux fonctions, et comme c'est très important de réaliser ces tests qui peuvent être négligé, je pense qu'elle y trouvera sa plaçe

Source / Exemple : 


## Unix -- Rapidité d'algorithme --
"""
clock();
    On Unix, return the current processor time as a floating point
    number expressed in seconds. The precision, and in fact the very
    definition of the meaning of ``processor time'', depends on that
    of the C function of the same name, but in any case, this is the
    function to use for benchmarking Python or timing algorithms.

Time():
    Return the time as a floating point number expressed in seconds since
    the epoch, in UTC. Note that even though the time is always returned
    as a floating point number, not all systems provide time with a better
    precision than 1 second. While this function normally returns
    non-decreasing values, it can return a lower value than a previous
    call if the system clock has been set back between the two calls. 

En français :

Clock():
    Sous Unix, retourne le temps en valeur décimal(type float) exprimé
    en seconde du temps du processeur courant
    La précision, est la signification même du temps exprimé par le processeur,
    elle dépend de celle de la fonction de C du même nom, mais de toute façon,
    c'est la fonction à employer pour le benchmark sous python, ou le test sur
    la rapidité des algorithmes.
    
Time():
    Retoune le temps en valeur décimal(type float) exprimé en seconde depuis la
    date d'Epoch, de l'UTC.
    Notez que même si le temps est retourné en nombre décimal, les systèmes
    n'ont pas tous une précision plus petite qu'une seconde. 
    Attention toutefois, cette fonction renvoie normalement des valeurs 
    croissantes à chaque appel, sauf si l'horloge du système a été modifié 
    entre deux appels de fonction.

'UTC' : Coordinated Universal Time (UTC) est une grande précision du temps
international, utilise partout dans le monde. C'est un standard.

'Epoch' : représente la date initiale à partir de laquelle est mesuré le
temps par les systèmes d'exploitation
-sous UNIX, c'est 1er janvier 1970 à 0 heure (UTC)
(source : wikipédia)

Ce sont les deux fonctions temps les plus utilisés.
Néanmoins la fonction clock(), n'est pas assez précise. 
Sa précision après la virgule n'excède pas le centième.
Il sera arrondis.

Ma fonction propose d'utiliser les deux fonctions, de les appellé 10fois,
et faire une moyenne.
(lorsque bien sur le résultat de clock est différent de 0)

Pour effectuer le test d'une de vos fonctions, remplacez "testb" par votre
fonction.

Pensez à fermez vos programmes

"""

import time

#Fonction inutile, juste pour le test (à remplaçer par votre algo)
def testb():
    for i in range(500):
        for i2 in range(100):
            v=(i*i2)

def getTime(mfunc, verbose=0):

    t0=time.time()
    mfunc()
    t1=time.time()
    t=t1-t0
    
    c0=time.clock()
    mfunc()
    c1=time.clock()
    c=c1-c0

    if (verbose):
        print "time() : ",t
        print "clock() : ",c

    if (c > 0):
        result=(t+c)/2
    else :
        result=t

    return result

print "Demarrage du test, veuillez patientez..."

# On stock nos temps dans la liste
tab_result=[]

# On appel 10 fois la fonction getTime pour stocker son résultat dans tab_result
for i in range(10):
    tab_result.append(getTime(testb,0))

moy=0
for num in tab_result:
    moy=moy+num
moy=moy/len(tab_result)

print moy

Conclusion :


Le code est simple. Aucune surprise ou complexité.
On appel 10 fois la fonction getTime, pour avoir le temps d'execution de notre fonction testb.
Une fois les 10 valeurs stocké, on en fait une moyenne.

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (loupmagic)