Vad är Python-avkastning?
Avkastningsnyckelordet i python fungerar som en retur med det 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 avkastningsnyckelord i funktionen stannar funktionsutförandet vid själva linjen och den returnerar ett generatorobjekt tillbaka till uppringaren.
I denna Python-handledning lär du dig:
- Vad är Python-avkastning?
- Syntax
- Vad är generatorer i Python?
- Skillnad mellan Normal funktion v / s Generatorfunktion.
- Hur läser man värdena från generatorn?
- Generatorer är engångsanvändning
- Exempel: Generatorer och avkastning för Fibonacci-serien
- Exempel: Samtalsfunktion med avkastning
- När ska du använda Yield istället för Return i Python
- Avkastning kontra avkastning
Syntax
yield expression
Beskrivning
Python-avkastning returnerar ett generatorobjekt. Generatorer är specialfunktioner som måste upprepas för att få värdena.
Avkastningsnyckelordet konverterar uttrycket som ges till en generatorfunktion som ger tillbaka ett generatorobjekt. För att få objektets värden måste det upprepas för att avläsa värdena som ges till avkastningen.
Exempel: Avkastningsmetod
Här är ett enkelt exempel på avkastning. Funktionen testyield () har ett nyckelord med strängen "Välkommen till Guru99 Python Tutorials". När funktionen anropas skrivs utgången ut och den ger ett generatorobjekt istället för det verkliga värdet.
def testyield():yield "Welcome to Guru99 Python Tutorials"output = testyield()print(output)
Produktion:
Den angivna 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 för att ge måste du upprepa generatorobjektet 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 generatorer i Python?
Generatorer är funktioner som returnerar ett iterabelt generatorobjekt. Värdena från generatorobjektet hämtas en i taget istället för hela listan tillsammans och därmed för att få de faktiska värdena kan du använda en for-loop, med hjälp av nästa () eller list () -metod.
Använda generatorfunktionen
Du kan skapa generatorer med hjälp av generatorfunktion och med generatoruttryck.
En generatorfunktion är som en normal funktion, istället för att ha ett returvärde har den ett avkastningsnyckelord.
För att skapa en generatorfunktion måste du lägga till ett nyckelord. 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:
HELLO
Skillnad mellan Normal funktion v / s Generatorfunktion.
Låt oss förstå hur en generatorfunktion skiljer sig från en normal funktion.
Det finns två funktioner normal_test () och generator_test ().
Båda funktionerna antar att du ska återställa strängen "Hello World". Normal_test () använder retur och generator_test () använder avkastning.
# Normal functiondef normal_test():return "Hello World"#Generator functiondef generator_test():yield "Hello World"print(normal_test()) #call to normal functionprint(generator_test()) # call to generator function
Produktion:
Hello World
Utgången visar att när du anropar normalfunktionen normal_test () returneras Hello World-strängen. För en generatorfunktion med avkastningsnyckelord returnerar den
Detta är den största skillnaden mellan en generatorfunktion och en normal funktion. Nu för att få värdet från generatorobjektet måste vi antingen använda objektet inuti för loop eller använda nästa () -metod 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 ringer till en normal funktion kommer körningen att starta och stoppa när den kommer tillbaka och värdet returneras till den som ringer. Så när körningen startar kan du inte stoppa den normala funktionen däremellan och den kommer bara att stoppa när den stöter på returord.
Men i händelse av generatorfunktion när körningen startar när den får den första avkastningen stoppar den körningen och ger tillbaka generatorobjektet. Du kan använda generatorobjektet för att få värdena och också, pausa och återuppta enligt dina krav.
Hur läser man värdena från generatorn?
Du kan läsa värdena från ett generatorobjekt med hjälp av en lista (), for-loop och nästa () -metod.
Använda: list ()
En lista är ett iterabelt objekt som har sina element inom parentes. Att använda listan () på ett generatorobjekt ger alla värden som generatorn har.
def even_numbers(n):for x in range(n):if (x%2==0):yield xnum = even_numbers(10)print(list(num))
Produktion:
[0, 2, 4, 6, 8]
Använda: for-in
I exemplet finns en funktion definierad jämnt antal () som ger dig alla jämna siffror för den definierade n. Samtalet till funktionen even_numbers () returnerar ett generatorobjekt som används inuti for-loop.
Exempel:
def even_numbers(n):for x in range(n):if (x%2==0):yield xnum = even_numbers(10)for i in num:print(i)
Produktion:
02468
Använda nästa ()
Nästa () -metod ger dig nästa objekt i listan, arrayen eller objektet. När listan är tom och om nästa () anropas kommer den att ge tillbaka ett fel med stopIteration-signal. Det här felet från nästa () indikerar att det inte finns fler objekt i listan.
def even_numbers(n):for x in range(n):if (x%2==0):yield xnum = even_numbers(10)print(next(num))print(next(num))print(next(num))print(next(num))print(next(num))print(next(num))
Produktion:
02468Traceback (most recent call last):File "main.py", line 11, inprint(next(num))StopIteration
Generatorer är engångsanvändning
I fall av generatorer är de endast tillgängliga för användning en gång. Om du försöker använda dem igen kommer de att vara tomma.
Till exempel:
def even_numbers(n):for x in range(n):if (x%2==0):yield xnum = even_numbers(10)for i in num:print(i)print("\n")print("Calling the generator again: ", list(num))
Produktion:
02468Calling the generator again: []
Om du vill att utgången ska användas igen måste du ringa samtalet för att fungera igen.
Exempel: Generatorer och avkastning för Fibonacci-serien
Följande exempel visar hur man använder generatorer och avkastning i Python. Exemplet genererar Fibonacci-serien.
def getFibonnaciSeries(num):c1, c2 = 0, 1count = 0while count < num:yield c1c3 = c1 + c2c1 = c2c2 = c3count += 1fin = getFibonnaciSeries(7)print(fin)for i in fin:print(i)
Produktion:
0112358
Exempel: Samtalsfunktion med avkastning
I det här exemplet ser vi hur man anropar en funktion med avkastning.
Nedanstående exempel har en funktion som kallas test () som returnerar kvadraten för det angivna numret. Det finns en annan funktion som heter getSquare () som använder test () med avkastningsnyckelord. Utgången ger kvadratvärdet för ett visst antalintervall.
def test(n):return n*ndef getSquare(n):for i in range(n):yield test(i)sq = getSquare(10)for i in sq:print(i)
Produktion:
0149162536496481
När ska du använda Yield istället för Return i Python
Python3 Yield- nyckelord returnerar en generator till den som ringer och körningen av koden startar först när generatorn itereras.
En avkastning i en funktion är slutet på funktionskörningen, 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
- Avkastning är det bästa valet när du behöver att din körning ska vara snabbare på stora datamängder
- Använd avkastning när du vill returnera en stor uppsättning värden till anropsfunktionen
- Avkastning är ett effektivt sätt att producera data som är stora eller oändliga.
Avkastning kontra avkastning
Här är skillnaderna mellan avkastning och avkastning
| Avkastning | Lämna tillbaka |
| Yield returnerar ett generatorobjekt till den som ringer och körningen av koden startar först när generatorn itereras. | En avkastning i en funktion är slutet på funktionens utförande, och ett enda värde ges tillbaka till den som ringer. |
| När funktionen anropas och den möter avkastningsnyckelordet, slutar funktionen att köras. Det returnerar generatorobjektet tillbaka till den som ringer. Funktionskörningen startar bara när generatorobjektet körs. | När funktionen anropas startar körningen och värdet ges tillbaka till den som ringer om det finns returnyckelord. Avkastningen inuti funktionen markerar slutet på funktionens utförande. |
| ge uttryck | återvänd uttryck |
| Inget minne används när avkastningsnyckelordet används. | Minnet tilldelas det returnerade värdet. |
| Mycket användbart om du måste hantera enorm datastorlek eftersom minnet inte används. | Bekvämt för mycket liten datastorlek. |
| Prestandan är bättre om avkastningsnyckelordet används för stor datastorlek. | Mycket minne används om datastorleken är enorm som kommer att hämma prestanda. |
| Exekveringstiden är snabbare vid avkastning för stor datastorlek. | Exekveringstiden som används är mer eftersom det görs extra bearbetning om din datastorlek är enorm, den fungerar bra för liten datastorlek. |
Sammanfattning:
- Avkastningsnyckelordet i python fungerar som en avkastning med den enda skillnaden är att i stä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 används, inte kommer att vara tillgänglig igen. Värdena lagras inte i minnet och är bara tillgängliga när de anropas.
- Värdena från generatorn kan läsas med hjälp av for-in, list () och nästa () metod.
- Huvudskillnaden mellan avkastning och avkastning är att avkastning returnerar en generatorfunktion till den som ringer och avkastningen ger uppringaren ett enda värde.
- Utbytet lagrar inga värden 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 avkastningsnyckelordet används i jämförelse för att returnera för stor datastorlek.