I denne tutorial lærer du, hvordan du bruger timeit-funktionen fra Pythons timeit-modul. Du lærer at time simple udtryk og funktioner i Python.
Timing af din kode kan hjælpe dig med at få et skøn over udførelsestiden for et stykke kode og også identificere de dele af koden, der skal optimeres.
Vi starter med at lære syntaksen for Pythons timeit-funktion. Og så vil vi kode eksempler for at forstå, hvordan du bruger det til at tidskode blokke af kode og funktioner i dit Python-modul. Lad os begynde.
Indholdsfortegnelse
Sådan bruger du Python timeit-funktionen
Timeit-modulet er en del af Python-standardbiblioteket, og du kan importere det:
import timeit
Syntaksen for at bruge timeit-funktionen fra timeit-modulet er som vist nedenfor:
timeit.timeit(stmt, setup, number)
Her:
- stmt er det stykke kode, hvis eksekveringstid skal måles. Du kan angive det som en simpel Python-streng eller en flerlinjet streng, eller du kan indtaste navnet på den, der kan kaldes.
- Som navnet antyder, angiver opsætning det stykke kode, der kun skal køre én gang, ofte som en forudsætning for, at stmt’en kan køre. Antag for eksempel, at du beregner udførelsestiden for oprettelsen af et NumPy-array. I dette tilfælde er import af numpy opsætningskoden, og den faktiske oprettelse er den erklæring, der skal times.
- Parameternummeret angiver antallet af gange stmt’en køres. Standardværdien for tal er 1 million (1000000), men du kan også indstille denne parameter til en hvilken som helst anden værdi efter eget valg.
Nu hvor vi har lært syntaksen til at bruge timeit()-funktionen, lad os begynde at kode nogle eksempler.
Timing Simple Python-udtryk
I dette afsnit vil vi prøve at måle udførelsestiden for simple Python-udtryk ved hjælp af timeit.
Start en Python REPL og kør følgende kodeeksempler. Her beregner vi eksekveringstiden for eksponentierings- og etagedelingsoperationer for 10000 og 100000 kørsler.
Bemærk, at vi sender sætningen til at blive timet som en Python-streng og bruger et semikolon til at adskille de forskellige udtryk i sætningen.
>>> import timeit
>>> timeit.timeit('3**4;3//4',number=10000)
0.0004020999999738706
>>> timeit.timeit('3**4;3//4',number=100000)
0.0013780000000451764
Kører Python timeit på kommandolinjen
Du kan også bruge timeit på kommandolinjen. Her er kommandolinjeækvivalenten til timeit-funktionskaldet:
$ python-m timeit -n [number] -s [setup] [stmt]
- python -m timeit repræsenterer, at vi kører timeit som hovedmodulet.
- n er en kommandolinjeindstilling, der angiver antallet af gange, koden skal køre. Dette svarer til tal-argumentet i timeit()-funktionskaldet.
- Du kan bruge indstillingerne -s til at definere opsætningskoden.
Her omskriver vi det forrige eksempel ved at bruge kommandolinjeækvivalenten:
$ python -m timeit -n 100000 '3**4;3//4' 100000 loops, best of 5: 35.8 nsec per loop
I dette eksempel beregner vi udførelsestiden for den indbyggede len() funktion. Initialiseringen af strengen er den opsætningskode, der sendes ind ved hjælp af s-indstillingen.
$ python -m timeit -n 100000 -s "string_1 = 'coding'" 'len(string_1)' 100000 loops, best of 5: 239 nsec per loop
Bemærk i outputtet, at vi får udførelsestiden for bedst af 5 kørsler. Hvad betyder det? Når du kører timeit på kommandolinjen, er gentagelsesindstillingen r sat til standardværdien på 5. Det betyder, at udførelse af stmt i det angivne antal gange gentages fem gange, og den bedste af udførelsestiderne returneres.
Analyse af strengvendingsmetoder ved hjælp af timeit
Når du arbejder med Python-strenge, vil du måske vende dem om. De to mest almindelige tilgange til strengvending er som følger:
- Ved hjælp af snoreudskæring
- Brug af reversed()-funktionen og join()-metoden
Omvendt Python-strenge ved hjælp af strengskæring
Lad os gennemgå, hvordan udskæring af strenge fungerer, og hvordan du kan bruge det til at vende en Python-streng. Brug af syntaksen nogle-streng[start:stop] returnerer et udsnit af strengen, der starter ved indeksstart og strækker sig op til indeksstop-1. Lad os tage et eksempel.
Overvej følgende streng ‘Python’. Strengen har længden 6, og listen over indekser er 0, 1, 2 op til 5.
>>> string_1 = 'Python'
Når du angiver både start- og stopværdierne, får du en strengskive, der strækker sig fra start til stop-1. Derfor, string_1[1:4] returnerer ‘yth’.
>>> string_1 = 'Python' >>> string_1[1:4] 'yth'
Når du ikke angiver startværdien, bruges standardstartværdien nul, og udsnittet starter ved indeks nul og strækker sig op til stop – 1.
Her er stopværdien 3, så skiven starter ved indeks 0 og går op til indeks 2.
>>> string_1[:3] 'Pyt'
Når du ikke inkluderer stopindekset, ser du, at udsnittet starter fra startindekset (1) og strækker sig op til slutningen af strengen.
>>> string_1[1:] 'ython'
Ignorerer både start- og stopværdierne returneres et udsnit af hele strengen.
>>> string_1[::] 'Python'
Lad os oprette et udsnit med trinværdien. Indstil start-, stop- og trinværdierne til henholdsvis 1, 5 og 2. Vi får et stykke af strengen, der starter ved 1, der strækker sig op til 4 (eksklusive slutpunktet 5), der indeholder hvert andet tegn.
>>> string_1[1:5:2] 'yh'
Når du bruger et negativt trin, kan du få en skive, der starter for enden af strengen. Med trinnet sat til -2, string_1[5:2:-2] giver følgende udsnit:
>>> string_1[5:2:-2] 'nh'
Så for at få en omvendt kopi af strengen springer vi start- og stopværdierne over og indstiller trinnet til -1, som vist:
>>> string_1[::-1] 'nohtyP'
Sammenfattende: streng[::-1] returnerer en omvendt kopi af strengen.
Reversering af strenge ved hjælp af indbyggede funktioner og strengemetoder
Den indbyggede reversed() funktion i Python vil returnere en omvendt iterator over elementerne i strengen.
>>> string_1 = 'Python' >>> reversed(string_1) <reversed object at 0x00BEAF70>
Så du kan sløjfe gennem den omvendte iterator ved hjælp af en for-løkke:
for char in reversed(string_1):
print(char)
Og få adgang til elementerne i strengen i omvendt rækkefølge.
# Output n o h t y P
Dernæst kan du kalde join()-metoden på den omvendte iterator med syntaksen:
Kodestykket nedenfor viser et par eksempler, hvor separatoren er henholdsvis en bindestreg og et mellemrum.
>>> '-'.join(reversed(string1)) 'n-o-h-t-y-P' >>> ' '.join(reversed(string1)) 'n o h t y P'
Her ønsker vi ikke nogen separator; så sæt separatoren til en tom streng for at få en omvendt kopi af strengen:
>>> ''.join(reversed(string1)) 'nohtyP'
Brug af ”.join(reversed(some-string)) returnerer en omvendt kopi af strengen.
Sammenligning af udførelsestider ved hjælp af timeit
Indtil videre har vi lært to tilgange til at vende Python-strenge. Men hvem af dem er hurtigst? Lad os finde ud af det.
I et tidligere eksempel, hvor vi timede simple Python-udtryk, havde vi ikke nogen opsætningskode. Her vender vi Python-strengen. Mens strengvendingsoperationen kører i det antal gange, der er angivet ved nummer, er opsætningskoden initialiseringen af strengen, der kun kører én gang.
>>> 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
For det samme antal kørsler for at vende den givne streng, er strengudskæringsmetoden hurtigere end at bruge join()-metoden og reversed()-funktionen.
Timing Python-funktioner Brug af timeit
Lad os i dette afsnit lære at time Python-funktioner med timeit-funktionen. Givet en liste over strenge, returnerer følgende funktion hasDigit listen over strenge, der har mindst ét ciffer.
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 vil vi gerne måle udførelsestiden for denne Python-funktion hasDigit() ved hjælp af timeit.
Lad os først identificere det udsagn, der skal times (stmt). Det er kaldet til funktionen hasDigit() med en liste af strenge som argument. Lad os derefter definere opsætningskoden. Kan du gætte, hvad opsætningskoden skal være?
For at funktionskaldet kan køre med succes, skal opsætningskoden indeholde følgende:
- Definitionen af funktionen hasDigit()
- Initialisering af argumentlisten over strenge
Lad os definere opsætningskoden i opsætningsstrengen, som vist nedenfor:
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']
"""
Dernæst kan vi bruge timeit-funktionen og få eksekveringstiden for hasDigit()-funktionen for 100000 kørsler.
import timeit
timeit.timeit('hasDigit(thislist)',setup=setup,number=100000)
# Output 0.2810094920000097
Konklusion
Du har lært, hvordan du bruger Pythons timeit-funktion til at time udtryk, funktioner og andre callables. Dette kan hjælpe dig med at benchmarke din kode, sammenligne udførelsestiderne for forskellige implementeringer af den samme funktion og mere.
Lad os gennemgå, hvad vi har lært i denne tutorial. Du kan bruge timeit()-funktionen med syntaksen timeit.timeit(stmt=…,setup=…,number=…). Alternativt kan du køre timeit på kommandolinjen for at time korte kodestykker.
Som et næste trin kan du udforske, hvordan du bruger andre Python-profileringspakker som line-profiler og memprofiler til at profilere din kode for henholdsvis tid og hukommelse.
Lær derefter, hvordan du beregner tidsforskel i Python.
