Opbrengst in Python-zelfstudie:voorbeeld van generator en rendement versus rendement

Wat is Python-opbrengst?

Het yield-zoekwoord in python werkt als een rendement met de enige

het verschil is dat in plaats van een waarde terug te geven, het een generatorobject teruggeeft aan de beller.

Wanneer een functie wordt aangeroepen en de uitvoeringsthread een yield-sleutelwoord in de functie vindt, stopt de uitvoering van de functie bij die regel zelf en retourneert het een generatorobject terug naar de aanroeper.

In deze Python-tutorial leer je:

• Wat is Python-opbrengst?
• Syntaxis
• Wat zijn generatoren in Python?
• Verschil tussen de normale functie en de generatorfunctie.
• Hoe lees ik de waarden van de generator?
• Generators zijn eenmalig gebruik
• Voorbeeld:generatoren en opbrengst voor Fibonacci-reeks
• Voorbeeld:oproepfunctie met opbrengst
• Wanneer rendement gebruiken in plaats van rendement in Python
• Opbrengst versus rendement

Syntaxis

yield expression

Beschrijving

Python yield retourneert een generatorobject. Generatoren zijn speciale functies die moeten worden herhaald om de waarden te krijgen.

Het yield-sleutelwoord zet de gegeven uitdrukking om in een generatorfunctie die een generatorobject teruggeeft. Om de waarden van het object te krijgen, moet het worden herhaald om de waarden te lezen die aan de opbrengst zijn gegeven.

Voorbeeld:opbrengstmethode

Hier is een eenvoudig voorbeeld van opbrengst. De functie testyield() heeft een yield-sleutelwoord met de string "Welcome to Guru99 Python Tutorials". Wanneer de functie wordt aangeroepen, wordt de uitvoer afgedrukt en wordt een generatorobject weergegeven in plaats van de werkelijke waarde.

def testyield():
  yield "Welcome to Guru99 Python Tutorials"
output = testyield()
print(output)

Uitvoer:

<generator object testyield at 0x00000028265EB9A8>

De gegeven uitvoer is een generatorobject, dat de waarde heeft die we hebben gegeven om op te leveren.

Maar we krijgen niet de boodschap die we moeten geven om in output te leveren!

Om het bericht dat aan opbrengst wordt gegeven af ​​te drukken, moet het generatorobject worden herhaald, zoals weergegeven in het onderstaande voorbeeld:

def testyield():
  yield "Welcome to Guru99 Python Tutorials"

output = testyield()
for i in output:
    print(i)

Uitgang

Welcome to Guru99 Python Tutorials

Wat zijn generatoren in Python?

Generatoren zijn functies die een itereerbaar generatorobject retourneren. De waarden van het generatorobject worden één voor één opgehaald in plaats van de volledige lijst samen. Om de werkelijke waarden te krijgen, kunt u een for-lus gebruiken met de methode next() of list().

Generatorfunctie gebruiken

U kunt generatoren maken met behulp van de generatorfunctie en met behulp van generatorexpressie.

Een generatorfunctie is als een normale functie, in plaats van een retourwaarde heeft deze een yield-sleutelwoord.

Om een ​​generatorfunctie te maken, moet u een yield-trefwoord toevoegen. De volgende voorbeelden laten zien hoe u een generatorfunctie maakt.

def generator():
    yield "H"
    yield "E"
    yield "L"
    yield "L"
    yield "O"

test = generator()
for i in test:
    print(i)

Uitgang:

H
E
L
L
O

Verschil tussen de normale functie en de generatorfunctie.

Laten we begrijpen hoe een generatorfunctie verschilt van een normale functie.

Er zijn 2 functies normal_test() en generator_test().

Beide functies zouden de tekenreeks "Hallo wereld" teruggeven. De normal_test() gebruikt return en generator_test() gebruikt yield.

# 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

Uitvoer:

Hello World
<generator object generator_test at 0x00000012F2F5BA20>

De uitvoer laat zien dat wanneer u de normale functie normal_test() aanroept, deze de Hello World-tekenreeks retourneert. Voor een generatorfunctie met yield-sleutelwoord retourneert het en niet de string.

Dit is het belangrijkste verschil tussen een generatorfunctie en een normale functie. Om nu de waarde van het generatorobject te krijgen, moeten we ofwel het object inside for loop gebruiken of de methode next() gebruiken of gebruik maken van list().

print(next(generator_test()))  # will output Hello World

Nog een verschil om toe te voegen aan de normale functie versus de generatorfunctie is dat wanneer u een normale functie aanroept, de uitvoering start en stopt wanneer het op retour komt en de waarde wordt teruggegeven aan de beller. Dus wanneer de uitvoering begint, kun je de normale functie tussendoor niet stoppen en stopt het alleen als het return-trefwoord tegenkomt.

Maar in het geval van een generatorfunctie, zodra de uitvoering begint wanneer het de eerste opbrengst krijgt, stopt het de uitvoering en geeft het het generatorobject terug. U kunt het generatorobject gebruiken om de waarden op te halen en ook pauzeren en hervatten volgens uw vereisten.

Hoe lees ik de waarden van de generator?

U kunt de waarden van een generatorobject lezen met behulp van een list(), for-loop en met de methode next().

Gebruik:list()

Een lijst is een itereerbaar object waarvan de elementen tussen haakjes staan. Het gebruik van list() op een generatorobject geeft alle waarden die de generator bevat.

def even_numbers(n):
    for x in range(n):
       if (x%2==0): 
           yield x       
num = even_numbers(10)
print(list(num))

Uitvoer:

[0, 2, 4, 6, 8]

Gebruik:for-in

In het voorbeeld is er een functie gedefinieerd even_getallen() die u alle even getallen geeft voor de gedefinieerde n. De aanroep van de functie even_numbers() retourneert een generatorobject, dat wordt gebruikt in de for-loop.

Voorbeeld:

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)

Uitvoer:

0
2
4
6
8

Volgende() gebruiken

De next() methode geeft je het volgende item in de lijst, array of object. Zodra de lijst leeg is, en als next() wordt aangeroepen, geeft het een foutmelding met het stopIteration-signaal. Deze fout, from next() geeft aan dat er geen items meer in de lijst staan.

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))

Uitvoer:

0
2
4
6
8
Traceback (most recent call last):
  File "main.py", line 11, in <module>
    print(next(num))
StopIteration

Generatoren zijn eenmalig gebruik

In het geval van generatoren zijn ze slechts eenmaal beschikbaar voor gebruik. Als je ze opnieuw probeert te gebruiken, zijn ze leeg.

Bijvoorbeeld:

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))

Uitvoer:

0
2
4
6
8
Calling the generator again:  []

Als u wilt dat de uitgang opnieuw wordt gebruikt, moet u de aanroep opnieuw doen om te functioneren.

Voorbeeld:generatoren en opbrengst voor Fibonacci-reeks

Het volgende voorbeeld laat zien hoe u generatoren en opbrengst gebruikt in Python. Het voorbeeld genereert de Fibonacci-reeks.

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)

Uitvoer:

<generator object getFibonnaciSeries at 0x0000007F39C8BA20>
0
1
1
2
3
5
8

Voorbeeld:oproepfunctie met opbrengst

In dit voorbeeld zie je hoe je een functie met opbrengst aanroept.

Het onderstaande voorbeeld heeft een functie genaamd test() die het kwadraat van het gegeven getal retourneert. Er is nog een functie genaamd getSquare() die test() gebruikt met het yield-sleutelwoord. De uitvoer geeft de kwadratische waarde voor het gegeven nummerbereik.

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)

Uitgang:

0
1
4
9
16
25
36
49
64
81

Wanneer rendement gebruiken in plaats van rendement in Python

Python3-opbrengst trefwoord retourneert een generator naar de beller en de uitvoering van de code begint alleen wanneer de generator wordt herhaald.

Een retour in een functie is het einde van de uitvoering van de functie, en een enkele waarde wordt teruggegeven aan de aanroeper.

Dit is de situatie waarin u Yield zou moeten gebruiken in plaats van Return

• Gebruik rendement in plaats van rendement als de gegevensomvang groot is
• Rendement is de beste keuze wanneer u uw uitvoering sneller wilt laten verlopen op grote datasets
• Gebruik opbrengst wanneer u een grote reeks waarden wilt teruggeven aan de aanroepende functie
• Opbrengst is een efficiënte manier om gegevens te produceren die groot of oneindig zijn.

Rendement versus rendement

Dit zijn de verschillen tussen opbrengst en rendement

Samenvatting:

• Het yield-sleutelwoord in python werkt als een retour, met het enige verschil is dat in plaats van een waarde terug te geven, het een generatorfunctie teruggeeft aan de beller.
• Een generator is een speciaal type iterator die, eenmaal gebruikt, niet meer beschikbaar zal zijn. De waarden worden niet in het geheugen opgeslagen en zijn alleen beschikbaar als ze worden opgeroepen.
• De waarden van de generator kunnen worden gelezen met de methode for-in, list() en next().
• Het belangrijkste verschil tussen opbrengst en rendement is dat opbrengst een generatorfunctie teruggeeft aan de beller en return een enkele waarde aan de beller geeft.
• Opbrengst slaat geen van de waarden op in het geheugen, en het voordeel is dat het handig is als de gegevensgrootte groot is, omdat geen van de waarden in het geheugen wordt opgeslagen.
• De prestaties zijn beter als het rendementszoekwoord wordt gebruikt in vergelijking met rendement voor grote gegevensomvang.