Giv efter Python tutorial: Generator & Yield vs Return Eksempel
Logan Young
Hvad er Python udbytte?
Udbytte søgeordet i python fungerer som et afkast med den eneste
forskellen er, at i stedet for at returnere en værdi, giver den et generatorobjekt tilbage til den, der ringer.
Når en funktion kaldes, og udførelsestråden finder et yield-nøgleord i funktionen, stopper funktionsudførelsen ved selve den linje, og den returnerer et generatorobjekt tilbage til den, der ringer.
Syntaks
yield expression
Description
Python yield returnerer et generatorobjekt. Generators er specielle funktioner, der skal gentages for at få værdierne.
Nøgleordet yield konverterer udtrykket givet til en generatorfunktion, der giver et generatorobjekt tilbage. For at få værdierne af objektet, skal det gentages for at aflæse værdierne givet til udbyttet.
Eksempel: Udbyttemetode
Her er et simpelt eksempel på udbytte. Funktionen testyield() har et yield nøgleord med strengen "Welcome to Guru99 Python Vejledninger“. Når funktionen kaldes, udskrives output, og det giver et generatorobjekt i stedet for den faktiske værdi.
def testyield(): yield "Welcome to Guru99 Python Tutorials" output = testyield() print(output)
Output:
<generator object testyield at 0x00000028265EB9A8>
Det givne output er et generatorobjekt, som har den værdi, vi har givet for at give.
Men vi får ikke den besked, vi skal give for at give efter i output!
For at udskrive meddelelsen givet til udbytte skal generatorobjektet gentages som vist i eksemplet nedenfor:
def testyield():
yield "Welcome to Guru99 Python Tutorials"
output = testyield()
for i in output:
print(i)
Output:
Welcome to Guru99 Python Tutorials
Hvad er Generatorsi Python?
Generators er funktioner, der returnerer et iterabelt generatorobjekt. Værdierne fra generatorobjektet hentes en ad gangen i stedet for den fulde liste sammen, og for at få de faktiske værdier kan du derfor bruge en for-loop ved at bruge next() eller list() metoden.
Ved brug af Generator funktion
Du kan oprette generatorer ved hjælp af generatorfunktion og ved hjælp af generatorudtryk.
En generatorfunktion er som en normal funktion, i stedet for at have en returværdi vil den have et udbytte-nøgleord.
For at oprette en generatorfunktion skal du tilføje et nøgleord for udbytte. De følgende eksempler viser, hvordan man opretter en generatorfunktion.
def generator():
yield "H"
yield "E"
yield "L"
yield "L"
yield "O"
test = generator()
for i in test:
print(i)
Output:
H E L L O
Forskellen mellem normal funktion v/s Generator funktion.
Lad os forstå, hvordan en generatorfunktion er forskellig fra en normal funktion.
Der er 2 funktioner normal_test() og generator_test().
Begge funktioner formodes at returnere strengen "Hello World". Normal_test() bruger return og generator_test() bruger udbytte.
# Normal function
def normal_test():
return "Hello World"
#Generator function
def generator_test():
yield "Hello World"
print(normal_test()) #call to normal function
print(generator_test()) # call to generator function
Output:
Hello World <generator object generator_test at 0x00000012F2F5BA20>
Outputtet viser, at når du kalder den normale funktion normal_test() returnerer den Hello World-streng. For en generatorfunktion med nøgleordet udbytte vender den tilbage og ikke strengen.
Dette er hovedforskellen mellem en generatorfunktion og en normal funktion. For nu at få værdien fra generatorobjektet skal vi enten bruge objektet inde for loop eller bruge next() metoden eller gøre brug af list().
print(next(generator_test())) # will output Hello World
Endnu en forskel at tilføje til normal funktion v/s generatorfunktion er, at når du kalder en normal funktion, vil udførelsen starte og stoppe, når den når afkast og værdien returneres til den, der ringer. Så når eksekveringen starter, kan du ikke stoppe den normale funktion ind imellem, og den stopper først, når den støder på et returnerende søgeord.
Men i tilfælde af generatorfunktion, når udførelsen starter, når den får det første udbytte, stopper den udførelsen og giver generatorobjektet tilbage. Du kan bruge generatorobjektet til at få værdierne og også pause og genoptage tilbage i henhold til dit krav.
Hvordan aflæses værdierne fra generatoren?
Du kan læse værdierne fra et generatorobjekt ved hjælp af en list(), for-loop og næste() metode.
Brug af: list()
En liste er et iterabelt objekt, der har sine elementer inden for parentes. Brug af list() på et generatorobjekt vil give alle de værdier, som generatoren har.
def even_numbers(n):
for x in range(n):
if (x%2==0):
yield x
num = even_numbers(10)
print(list(num))
Output:
[0, 2, 4, 6, 8]
Bruger: for-in
I eksemplet er der en funktion defineret lige_numre(), som vil give dig alle lige tal for de n definerede. Kaldet til funktionen even_numbers() vil returnere et generatorobjekt, som bruges inde i for-loop.
Eksempel:
def even_numbers(n):
for x in range(n):
if (x%2==0):
yield x
num = even_numbers(10)
for i in num:
print(i)
Output:
0 2 4 6 8
Brug af next()
Next()-metoden giver dig det næste element i listen, arrayet eller objektet. Når listen er tom, og hvis next() kaldes, vil den give en fejl tilbage med stopIteration-signal. Denne fejl fra next() indikerer, at der ikke er flere elementer på listen.
def even_numbers(n):
for x in range(n):
if (x%2==0):
yield x
num = even_numbers(10)
print(next(num))
print(next(num))
print(next(num))
print(next(num))
print(next(num))
print(next(num))
Output:
0
2
4
6
8
Traceback (most recent call last):
File "main.py", line 11, in <module>
print(next(num))
StopIteration
Generators er engangsbrug
I tilfælde af generatorer er de kun tilgængelige til brug én gang. Hvis du prøver at bruge dem igen, vil den være tom.
For eksempel:
def even_numbers(n):
for x in range(n):
if (x%2==0):
yield x
num = even_numbers(10)
for i in num:
print(i)
print("\n")
print("Calling the generator again: ", list(num))
Output:
0 2 4 6 8 Calling the generator again: []
Hvis du ønsker, at outputtet skal bruges igen, bliver du nødt til at foretage opkaldet for at fungere igen.
Eksempel: Generators og udbytte for Fibonacci-serien
Følgende eksempel viser, hvordan man bruger generatorer og udbytte i Python. Eksemplet vil generere Fibonacci-serien.
def getFibonnaciSeries(num):
c1, c2 = 0, 1
count = 0
while count < num:
yield c1
c3 = c1 + c2
c1 = c2
c2 = c3
count += 1
fin = getFibonnaciSeries(7)
print(fin)
for i in fin:
print(i)
Output:
<generator object getFibonnaciSeries at 0x0000007F39C8BA20> 0 1 1 2 3 5 8
Eksempel: Opkaldsfunktion med Yield
I dette eksempel vil se, hvordan man kalder en funktion med udbytte.
Nedenstående eksempel har en funktion kaldet test(), der returnerer kvadratet af det givne tal. Der er en anden funktion kaldet getSquare() der bruger test() med yield nøgleord. Outputtet giver kvadratværdien for et givet talområde.
def test(n):
return n*n
def getSquare(n):
for i in range(n):
yield test(i)
sq = getSquare(10)
for i in sq:
print(i)
Output:
0 1 4 9 16 25 36 49 64 81
Hvornår skal du bruge Yield i stedet for Return in Python
Python3 Udbytte nøgleordet returnerer en generator til den, der ringer, og udførelsen af koden starter først, når generatoren gentages.
A afkast i en funktion er slutningen af funktionsudførelsen, og en enkelt værdi gives tilbage til den, der ringer.
Her er situationen, hvor du skal bruge Yield i stedet for Return
- Brug udbytte i stedet for afkast, når datastørrelsen er stor
- Yield er det bedste valg, når du har brug for, at din eksekvering er hurtigere på store datasæt
- Brug udbytte, når du vil returnere et stort sæt værdier til den kaldende funktion
- Yield er en effektiv måde at producere data, der er store eller uendelige.
Udbytte vs. afkast
Her er forskellene mellem udbytte og afkast
| Udbytte | Returnering |
|---|---|
| Yield returnerer et generatorobjekt til den, der ringer, og udførelsen af koden starter først, når generatoren itereres. | Et retur i en funktion er slutningen af funktionsudførelsen, og en enkelt værdi gives tilbage til den, der ringer. |
| Når funktionen kaldes, og den støder på nøgleordet yield, stopper funktionsudførelsen. Det returnerer generatorobjektet tilbage til den, der ringer. Funktionsudførelsen starter først, når generatorobjektet udføres. | Når funktionen kaldes, starter eksekveringen, og værdien gives tilbage til den, der ringer, hvis der er returnøgleord. Returen inde i funktionen markerer slutningen af funktionsudførelsen. |
| udbytte udtryk | returnere udtryk |
| Der bruges ingen hukommelse, når nøgleordet udbytte bruges. | Hukommelsen er allokeret til den returnerede værdi. |
| Meget nyttig, hvis du skal håndtere stor datastørrelse, da hukommelsen ikke bruges. | Praktisk til meget lille datastørrelse. |
| Ydeevnen er bedre, hvis nøgleordet yield bruges til stor datastørrelse. | Der bruges meget hukommelse, hvis datastørrelsen er enorm, hvilket vil hæmme ydeevnen. |
| Udførelsestiden er hurtigere i tilfælde af udbytte for store datastørrelser. | Den anvendte udførelsestid er mere, da der er ekstra behandling udført i tilfælde af, at hvis din datastørrelse er enorm, vil den fungere fint for små datastørrelser. |
Resumé
- Nøgleordet yield i python fungerer som et retur, med den eneste forskel er, at i stedet for at returnere en værdi, giver det en generatorfunktion tilbage til den, der ringer.
- En generator er en speciel type iterator, som, når den er brugt, ikke vil være tilgængelig igen. Værdierne gemmes ikke i hukommelsen og er kun tilgængelige, når de kaldes op.
- Værdierne fra generatoren kan læses ved hjælp af for-in, list() og next() metoden.
- Den største forskel mellem udbytte og afkast er, at udbytte returnerer en generatorfunktion til den, der ringer, og retur giver en enkelt værdi til den, der ringer.
- Yield gemmer ingen af værdierne i hukommelsen, og fordelen er, at det er nyttigt, når datastørrelsen er stor, da ingen af værdierne er gemt i hukommelsen.
- Ydeevnen er bedre, hvis nøgleordet yield bruges i sammenligning med at vende tilbage for store datastørrelser.
