Python Timeit gebruiken om uw code te timen

In deze tutorial leer je hoe je de timeit-functie uit de timeit-module van Python gebruikt. Je leert hoe je eenvoudige uitdrukkingen en functies kunt timen in Python.

Door uw code te timen, kunt u een schatting krijgen van de uitvoeringstijd van een stuk code en kunt u ook de delen van de code identificeren die moeten worden geoptimaliseerd.

We beginnen met het leren van de syntaxis van de timeit-functie van Python. En dan zullen we codevoorbeelden maken om te begrijpen hoe je het kunt gebruiken om codeblokken en functies in je Python-module te timen. Laten we beginnen.

Hoe de Python timeit-functie te gebruiken

De timeit-module maakt deel uit van de Python-standaardbibliotheek en u kunt deze importeren:

import timeit

De syntaxis om de timeit-functie uit de timeit-module te gebruiken is als volgt:

timeit.timeit(stmt, setup, number)

Hier:

  • stmt is het stuk code waarvan de uitvoeringstijd moet worden gemeten. U kunt het specificeren als een eenvoudige Python-string of een string met meerdere regels, of u kunt de naam van de callable doorgeven.
  • Zoals de naam al doet vermoeden, geeft setup het stuk code aan dat slechts één keer hoeft te worden uitgevoerd, vaak als voorwaarde voor het uitvoeren van stmt. Stel dat u de uitvoeringstijd berekent voor het maken van een NumPy-array. In dit geval is het importeren van numpy de setup-code en de eigenlijke creatie is de instructie die moet worden getimed.
  • Het parameternummer geeft het aantal keren aan dat de stmt is uitgevoerd. De standaardwaarde van getal is 1 miljoen (1000000), maar u kunt deze parameter ook instellen op een andere waarde naar keuze.

Nu we de syntaxis hebben geleerd om de functie timeit() te gebruiken, gaan we enkele voorbeelden coderen.

Timing van eenvoudige Python-expressies

In deze sectie proberen we de uitvoeringstijd van eenvoudige Python-expressies te meten met behulp van timeit.

Start een Python REPL en voer de volgende codevoorbeelden uit. Hier berekenen we de uitvoeringstijd van bewerkingen voor machtsverheffen en vloerverdeling voor 10.000 en 100.000 runs.

Merk op dat we de instructie doorgeven om te worden getimed als een Python-string en een puntkomma gebruiken om de verschillende expressies in de instructie te scheiden.

>>> import timeit
>>> timeit.timeit('3**4;3//4',number=10000)
0.0004020999999738706

>>> timeit.timeit('3**4;3//4',number=100000)
0.0013780000000451764

Python timeit uitvoeren op de opdrachtregel

U kunt timeit ook gebruiken op de opdrachtregel. Hier is het opdrachtregelequivalent van de timeit-functieaanroep:

$ python-m timeit -n [number] -s [setup] [stmt]
  • python -m timeit geeft aan dat we timeit uitvoeren als de hoofdmodule.
  • n is een opdrachtregeloptie die aangeeft hoe vaak de code moet worden uitgevoerd. Dit komt overeen met het getalargument in de functieaanroep timeit().
  • U kunt de optie -s gebruiken om de instellingscode te definiëren.
  Waarom Remote Team Password Manager nodig heeft [+4 Tools]

Hier herschrijven we het vorige voorbeeld met behulp van het opdrachtregelequivalent:

$ python -m timeit -n 100000 '3**4;3//4'
100000 loops, best of 5: 35.8 nsec per loop

In dit voorbeeld berekenen we de uitvoeringstijd van de ingebouwde len()-functie. De initialisatie van de tekenreeks is de instellingscode die wordt doorgegeven met de optie s.

$ python -m timeit -n 100000 -s "string_1 = 'coding'" 'len(string_1)'
100000 loops, best of 5: 239 nsec per loop

Merk op dat we in de uitvoer de uitvoeringstijd krijgen voor de beste van 5 uitvoeringen. Wat betekent dit? Wanneer u timeit op de opdrachtregel uitvoert, wordt de herhalingsoptie r ingesteld op de standaardwaarde van 5. Dit betekent dat de uitvoering van de stmt voor het opgegeven aantal keren vijf keer wordt herhaald en dat de beste uitvoeringstijden worden geretourneerd.

Analyse van methoden voor het omkeren van strings met behulp van timeit

Wanneer u met Python-strings werkt, wilt u ze misschien omkeren. De twee meest gebruikelijke benaderingen van tekenreeksomkering zijn als volgt:

  • String-slicing gebruiken
  • De functie reversed() en de methode join() gebruiken

Omgekeerde Python-strings met behulp van String Slicing

Laten we eens kijken hoe string slicing werkt en hoe je het kunt gebruiken om een ​​Python-string om te keren. Met behulp van de syntaxis some-string[start:stop] geeft een deel van de tekenreeks terug, beginnend bij de indexstart en doorlopend tot indexstop-1. Laten we een voorbeeld nemen.

Beschouw de volgende string ‘Python’. De string heeft een lengte van 6 en de lijst met indices is 0, 1, 2 tot 5.

>>> string_1 = 'Python'

Wanneer u zowel de start- als de stopwaarde opgeeft, krijgt u een stringsegment dat zich uitstrekt van start tot stop-1. Daarom tekenreeks_1[1:4] geeft ‘yth’ terug.

>>> string_1 = 'Python'
>>> string_1[1:4]
'yth'

Als u de startwaarde niet opgeeft, wordt de standaard startwaarde van nul gebruikt en begint het segment bij index nul en loopt door tot stop – 1.

Hier is de stopwaarde 3, dus de slice begint bij index 0 en gaat omhoog naar index 2.

>>> string_1[:3]
'Pyt'

Als u de stopindex niet opneemt, ziet u dat de slice begint vanaf de startindex (1) en zich uitstrekt tot aan het einde van de string.

  Genereer Heap Dump, Java Core & System Dump in WebSphere

>>> string_1[1:]
'ython'

Als u zowel de start- als de stopwaarde negeert, wordt een deel van de hele tekenreeks geretourneerd.

>>> string_1[::]
'Python'

Laten we een segment maken met de stapwaarde. Stel de start-, stop- en stapwaarden in op respectievelijk 1, 5 en 2. We krijgen een deel van de string die begint bij 1 en zich uitstrekt tot 4 (exclusief het eindpunt 5) met elk tweede teken.

>>> string_1[1:5:2]
'yh'

Wanneer u een negatieve stap gebruikt, kunt u een segment krijgen dat aan het einde van de tekenreeks begint. Met de stap ingesteld op -2, string_1[5:2:-2] geeft het volgende stukje:

>>> string_1[5:2:-2]
'nh'

Dus om een ​​omgekeerde kopie van de tekenreeks te krijgen, slaan we de start- en stopwaarden over en stellen we de stap in op -1, zoals weergegeven:

>>> string_1[::-1]
'nohtyP'

Samengevat: string[::-1] retourneert een omgekeerde kopie van de tekenreeks.

Tekenreeksen omkeren met behulp van ingebouwde functies en tekenreeksmethoden

De ingebouwde functie reversed() in Python retourneert een omgekeerde iterator over de elementen van de string.

>>> string_1 = 'Python'
>>> reversed(string_1)
<reversed object at 0x00BEAF70>

U kunt dus de omgekeerde iterator doorlopen met een for-lus:

for char in reversed(string_1):
    print(char)

En krijg toegang tot de elementen van de string in omgekeerde volgorde.

# Output
n
o
h
t
y
P

Vervolgens kunt u de methode join() aanroepen op de omgekeerde iterator met de syntaxis: .join(reversed(some-string)).

Het onderstaande codefragment toont een aantal voorbeelden waarbij het scheidingsteken respectievelijk een koppelteken en een spatie is.

>>> '-'.join(reversed(string1))
'n-o-h-t-y-P'
>>> ' '.join(reversed(string1))
'n o h t y P'

Hier willen we geen scheidingsteken; dus stel het scheidingsteken in op een lege string om een ​​omgekeerde kopie van de string te krijgen:

>>> ''.join(reversed(string1))
'nohtyP'

Het gebruik van .join(reversed(some-string)) retourneert een omgekeerde kopie van de string.

Uitvoeringstijden vergelijken met behulp van timeit

Tot nu toe hebben we twee benaderingen geleerd om Python-strings om te keren. Maar welke van hen is sneller? Laten wij het uitzoeken.

In een eerder voorbeeld waarin we eenvoudige Python-expressies timen, hadden we geen setup-code. Hier keren we de Python-string om. Terwijl de bewerking voor het omkeren van tekenreeksen wordt uitgevoerd voor het aantal keren dat is opgegeven door nummer, is de installatiecode de initialisatie van de tekenreeks die slechts één keer wordt uitgevoerd.

>>> import timeit
>>> timeit.timeit(stmt="string_1[::-1]", setup = "string_1 = 'Python'", number = 100000)
0.04951830000001678
>>> timeit.timeit(stmt = "''.join(reversed(string_1))", setup = "string_1 = 'Python'", number = 100000)
0.12858760000000302

Voor hetzelfde aantal runs voor het omkeren van de gegeven tekenreeks, is de string-slicingbenadering sneller dan het gebruik van de methode join() en de functie reversed().

  Hoe u Nintendo Switch-screenshots draadloos naar een smartphone kunt overbrengen

Timing Python-functies Timeit gebruiken

Laten we in deze sectie leren hoe we Python-functies kunnen timen met de timeit-functie. Gegeven een lijst met tekenreeksen, retourneert de volgende functie hasDigit de lijst met tekenreeksen die ten minste één cijfer hebben.

def hasDigit(somelist):
     str_with_digit = []
     for string in somelist:
         check_char = [char.isdigit() for char in string]
         if any(check_char):
            str_with_digit.append(string)
     return str_with_digit

Nu willen we de uitvoeringstijd van deze Python-functie hasDigit() meten met behulp van timeit.

Laten we eerst de instructie identificeren die moet worden getimed (stmt). Het is de aanroep van de functie hasDigit() met een lijst met strings als argument. Laten we vervolgens de instellingscode definiëren. Kun jij raden wat de setup-code zou moeten zijn?

Voor een succesvolle uitvoering van de functieaanroep moet de installatiecode het volgende bevatten:

  • De definitie van de functie hasDigit()
  • De initialisatie van de argumentlijst met tekenreeksen

Laten we de setup-code definiëren in de setup-string, zoals hieronder weergegeven:

setup = """
def hasDigit(somelist):
    str_with_digit = []
    for string in somelist:
      check_char = [char.isdigit() for char in string]
      if any(check_char):
        str_with_digit.append(string)
    return str_with_digit
thislist=['puffin3','7frost','blue']
     """

Vervolgens kunnen we de timeit-functie gebruiken en de uitvoeringstijd van de hasDigit()-functie voor 100.000 runs ophalen.

import timeit
timeit.timeit('hasDigit(thislist)',setup=setup,number=100000)
# Output
0.2810094920000097

Gevolgtrekking

Je hebt geleerd hoe je de timeit-functie van Python kunt gebruiken om uitdrukkingen, functies en andere callables te timen. Dit kan u helpen uw code te benchmarken, de uitvoeringstijden van verschillende implementaties van dezelfde functie te vergelijken en meer.

Laten we eens kijken wat we in deze zelfstudie hebben geleerd. U kunt de functie timeit() gebruiken met de syntaxis timeit.timeit(stmt=…,setup=…,number=…). U kunt ook timeit uitvoeren op de opdrachtregel om korte codefragmenten te timen.

Als volgende stap kunt u onderzoeken hoe u andere Python-profileringspakketten, zoals line-profiler en memprofiler, kunt gebruiken om uw code te profileren voor respectievelijk tijd en geheugen.

Leer vervolgens hoe u het tijdsverschil in Python kunt berekenen.

gerelateerde berichten