Ge efter Python Handledning: Generator & avkastning vs avkastning exempel
Logan Young
Vad är Python avkastning?
Nyckelordet yield i python fungerar som en retur med den enda
Skillnaden är att istället för att returnera ett värde, ger det tillbaka ett generatorobjekt till den som ringer.
När en funktion anropas och exekveringstråden hittar ett yield-nyckelord i funktionen, stannar funktionsexekveringen vid själva raden och den returnerar ett generatorobjekt tillbaka till anroparen.
syntax
yield expression
Description
Python yield returnerar ett generatorobjekt. Generators är specialfunktioner som måste itereras för att få värdena.
Nyckelordet yield omvandlar uttrycket som ges till en generatorfunktion som ger tillbaka ett generatorobjekt. För att få fram värdena på objektet måste det itereras för att läsa de värden som ges till avkastningen.
Exempel: Avkastningsmetod
Här är ett enkelt exempel på avkastning. Funktionen testyield() har ett yield nyckelord med strängen "Welcome to Guru99 Python Tips och trix". När funktionen anropas skrivs utdata ut och det ger ett generatorobjekt istället för det faktiska värdet.
def testyield(): yield "Welcome to Guru99 Python Tutorials" output = testyield() print(output)
Produktion:
<generator object testyield at 0x00000028265EB9A8>
Den givna utgången är ett generatorobjekt, som har det värde vi har gett för att ge.
Men vi får inte det budskap vi måste ge för att ge resultat!
För att skriva ut meddelandet som ges till avkastning måste generatorobjektet itereras som visas i exemplet nedan:
def testyield():
yield "Welcome to Guru99 Python Tutorials"
output = testyield()
for i in output:
print(i)
Produktion:
Welcome to Guru99 Python Tutorials
Vad är Generatorsi Python?
Generators är funktioner som returnerar ett itererbart generatorobjekt. Värdena från generatorobjektet hämtas ett i taget istället för hela listan tillsammans och för att få de faktiska värdena kan du använda en for-loop, med hjälp av metoden next() eller list().
Använda Generator fungera
Du kan skapa generatorer med generatorfunktion och med generatoruttryck.
En generatorfunktion är som en normal funktion, istället för att ha ett returvärde kommer den att ha ett nyckelord för avkastning.
För att skapa en generatorfunktion måste du lägga till ett nyckelord för avkastning. Följande exempel visar hur man skapar en generatorfunktion.
def generator():
yield "H"
yield "E"
yield "L"
yield "L"
yield "O"
test = generator()
for i in test:
print(i)
Produktion:
H E L L O
Skillnad mellan normal funktion v/s Generator funktion.
Låt oss förstå hur en generatorfunktion skiljer sig från en normal funktion.
Det finns 2 funktioner normal_test() och generator_test().
Båda funktionerna är tänkt att returnera strängen "Hello World". Normal_test() använder retur och generator_test() använder avkastning.
# 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
Produktion:
Hello World <generator object generator_test at 0x00000012F2F5BA20>
Utdata visar att när du anropar den normala funktionen normal_test() returnerar den Hello World-sträng. För en generatorfunktion med nyckelord avkastning returnerar den och inte strängen.
Detta är huvudskillnaden mellan en generatorfunktion och en normal funktion. För att nu få värdet från generatorobjektet måste vi antingen använda objektet inuti för loop eller använda metoden next() eller använda list().
print(next(generator_test())) # will output Hello World
Ytterligare en skillnad att lägga till normal funktion v/s generatorfunktion är att när du anropar en normal funktion kommer exekveringen att starta och stoppa när den kommer till avkastning och värdet returneras till den som ringer. Så när exekveringen startar kan du inte stoppa den normala funktionen däremellan och den kommer bara att sluta när den stöter på returnera nyckelord.
Men i händelse av generatorfunktion när exekveringen väl startar när den får den första avkastningen stoppar den exekveringen och ger tillbaka generatorobjektet. Du kan använda generatorobjektet för att få värdena och även pausa och återuppta enligt dina krav.
Hur läser man av värdena från generatorn?
Du kan läsa värdena från ett generatorobjekt med hjälp av en list(), for-loop och nästa()-metoden.
Använder: list()
En lista är ett itererbart objekt som har sina element inom parentes. Att använda list() på ett generatorobjekt kommer att ge alla värden som generatorn har.
def even_numbers(n):
for x in range(n):
if (x%2==0):
yield x
num = even_numbers(10)
print(list(num))
Produktion:
[0, 2, 4, 6, 8]
Använder: for-in
I exemplet finns det en funktion definierad even_numbers() som ger dig alla jämna tal för n definierade. Anropet till funktionen even_numbers() kommer att returnera ett generatorobjekt, som används inuti for-loop.
Exempelvis:
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)
Produktion:
0 2 4 6 8
Använder nästa()
Next()-metoden ger dig nästa objekt i listan, arrayen eller objektet. När listan är tom, och om next() anropas, kommer den att ge tillbaka ett fel med stopIteration-signal. Det här felet, från next() indikerar att det inte finns fler objekt i listan.
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))
Produktion:
0
2
4
6
8
Traceback (most recent call last):
File "main.py", line 11, in <module>
print(next(num))
StopIteration
Generators är engångsanvändning
Om generatorer är tillgängliga för användning endast en gång. Om du försöker använda dem igen kommer det att vara tomt.
Till exempel:
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))
Produktion:
0 2 4 6 8 Calling the generator again: []
Om du vill att utgången ska användas igen, måste du ringa för att fungera igen.
Exempelvis: Generators och avkastning för Fibonacci-serien
Följande exempel visar hur man använder generatorer och ger in Python. Exemplet kommer att generera 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)
Produktion:
<generator object getFibonnaciSeries at 0x0000007F39C8BA20> 0 1 1 2 3 5 8
Exempel: Anropsfunktion med avkastning
I det här exemplet kommer vi att se hur man anropar en funktion med avkastning.
Exemplet nedan har en funktion som heter test() som returnerar kvadraten på det givna talet. Det finns en annan funktion som heter getSquare() som använder test() med nyckelordet yield. Utdata ger kvadratvärdet för ett 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)
Produktion:
0 1 4 9 16 25 36 49 64 81
När ska man använda Yield istället för Return in Python
Python3 Utbyte nyckelordet returnerar en generator till den som ringer och exekveringen av koden startar först när generatorn itereras.
A avkastning i en funktion är slutet av funktionsexekveringen, och ett enda värde ges tillbaka till den som ringer.
Här är situationen när du ska använda Yield istället för Return
- Använd avkastning istället för avkastning när datastorleken är stor
- Yield är det bästa valet när du behöver att din exekvering ska vara snabbare på stora datamängder
- Använd avkastning när du vill returnera en stor uppsättning värden till den anropande funktionen
- Yield är ett effektivt sätt att producera data som är stor eller oändlig.
Avkastning vs. avkastning
Här är skillnaderna mellan avkastning och avkastning
| Avkastning | Retur |
|---|---|
| Yield returnerar ett generatorobjekt till den som ringer, och exekveringen av koden startar först när generatorn itereras. | En retur i en funktion är slutet på funktionsexekveringen, och ett enda värde ges tillbaka till den som ringer. |
| När funktionen anropas och den stöter på nyckelordet yield, stoppas funktionsexekveringen. Det returnerar generatorobjektet tillbaka till den som ringer. Funktionsexekveringen startar först när generatorobjektet exekveras. | När funktionen anropas startar exekveringen och värdet ges tillbaka till den som ringer om det finns retur nyckelord. Returen inuti funktionen markerar slutet på funktionskörningen. |
| avkastningsuttryck | returnera uttryck |
| Inget minne används när nyckelordet yield används. | Minnet tilldelas för det returnerade värdet. |
| Mycket användbart om du måste hantera enorma datastorlekar eftersom minnet inte används. | Bekvämt för mycket liten datastorlek. |
| Prestandan är bättre om nyckelordet yield används för stor datastorlek. | Mycket minne används om datastorleken är enorm vilket kommer att hämma prestandan. |
| Exekveringstiden är snabbare i händelse av avkastning för stor datastorlek. | Exekveringstiden som används är längre eftersom det görs extra bearbetning i fall om din datastorlek är enorm, kommer den att fungera bra för liten datastorlek. |
Sammanfattning
- Nyckelordet yield i python fungerar som en retur med den enda skillnaden är att istället för att returnera ett värde, ger det tillbaka en generatorfunktion till den som ringer.
- En generator är en speciell typ av iterator som, när den väl har använts, inte kommer att vara tillgänglig igen. Värdena lagras inte i minnet och är endast tillgängliga vid uppringning.
- Värdena från generatorn kan läsas med metoderna for-in, list() och next().
- Den största skillnaden mellan avkastning och avkastning är att avkastning returnerar en generatorfunktion till den som ringer och retur ger ett enda värde till den som ringer.
- Yield lagrar inte några av värdena i minnet, och fördelen är att det är användbart när datastorleken är stor, eftersom inget av värdena lagras i minnet.
- Prestandan är bättre om nyckelordet yield används i jämförelse med avkastning för stor datastorlek.
