Engedd be Python bemutató: Generator & Hozam vs hozam példa

Mi Python hozam?

A pythonban a hozam kulcsszó úgy működik, mint egy return az egyetlen

A különbség az, hogy ahelyett, hogy értéket adna vissza, egy generátor objektumot ad vissza a hívónak.

Amikor egy függvényt meghívunk, és a végrehajtási szál egy hozamkulcsszót talál a függvényben, a függvény végrehajtása azon a soron áll meg, és egy generátor objektumot ad vissza a hívónak.

Szintaxis

yield expression

Description

Python A hozam egy generátor objektumot ad vissza. Generators speciális függvények, amelyeket ismételni kell az értékek eléréséhez.

A hozam kulcsszó a megadott kifejezést generátorfüggvénnyel konvertálja, amely egy generátor objektumot ad vissza. Az objektum értékeinek megszerzéséhez iterálni kell a hozamnak adott értékeket.

Példa: Hozammódszer

Íme egy egyszerű példa a hozamra. A testyield() függvénynek van egy hozamkulcsszója a következővel: „Üdvözöljük a Guru99-ben Python oktatóanyagok“. A függvény meghívásakor a kimenet kinyomtatásra kerül, és a tényleges érték helyett egy generátor objektumot ad meg.

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

output:

<generator object testyield at 0x00000028265EB9A8>

A megadott kimenet egy generátor objektum, amelynek értéke az általunk megadott hozam.

De nem azt az üzenetet kapjuk, amelyet át kell adnunk ahhoz, hogy hozzunk eredményt!

A hozamnak adott üzenet kinyomtatásához meg kell ismételni a generátor objektumot az alábbi példában látható módon:

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

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

output:

Welcome to Guru99 Python Tutorials

Mik Generators Python?

Generators olyan függvények, amelyek egy iterálható generátor objektumot adnak vissza. A generátor objektum értékeit a rendszer egyenként kéri le a teljes lista helyett, így a tényleges értékekhez használhatja a for-loopot a next() vagy list() metódussal.

<p></p> Generator funkció

Generátorokat generátor függvény és generátor kifejezés használatával hozhat létre.

A generátor függvény olyan, mint egy normál függvény, visszatérési értéke helyett hozamkulcsszóval rendelkezik.

Generátor függvény létrehozásához hozzá kell adnia egy hozamkulcsszót. A következő példák bemutatják, hogyan lehet generátorfüggvényt létrehozni.

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

Különbség a normál funkció v/s között Generator funkciót.

Nézzük meg, miben különbözik egy generátorfüggvény a normál függvénytől.

Két függvény létezik: normal_test() és generator_test().

Mindkét függvény visszaadja a „Hello World” karakterláncot. A normal_test() a return-t, a generator_test() pedig a hozamot használja.

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

A kimenet azt mutatja, hogy a normal_test() normál függvény meghívásakor a Hello World karakterláncot adja vissza. A hozam kulcsszóval rendelkező generátorfüggvény esetén ez ad vissza és nem a húr.

Ez a fő különbség a generátor funkció és a normál funkció között. Most, hogy megkapjuk az értéket a generátor objektumtól, vagy a for loop belsejében lévő objektumot kell használnunk, vagy a next() metódust, vagy a list()-t kell használnunk.

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

Még egy különbség a normál függvény v/s generátor függvényhez az, hogy amikor meghívunk egy normál függvényt, a végrehajtás elindul és leáll, amikor elér visszatérés és az érték visszakerül a hívóhoz. Tehát amikor a végrehajtás elindul, nem állíthatja le a normál függvényt közben, és csak akkor áll le, ha a return kulcsszóval találkozik.

De generátor függvény esetén, ha a végrehajtás elindul, amikor megkapja az első hozamot, leállítja a végrehajtást és visszaadja a generátor objektumot. Használhatja a generátor objektumot az értékek lekéréséhez, valamint a szüneteltetést és a folytatást igény szerint.

Hogyan lehet kiolvasni az értékeket a generátorból?

Az értékeket egy generátor objektumból list(), for-loop és next() metódussal olvashatja ki.

Használata: list()

A lista egy iterálható objektum, amelynek elemei zárójelben vannak. A list() használata egy generátor objektumon megadja az összes értéket, amelyet a generátor tárol.

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]

Használata: for-in

A példában van egy páros_számok() definiált függvény, amely megadja az összes páros számot a definiált n-hez. A páros_számok() függvény hívása egy generátor objektumot ad vissza, amelyet a for-cikluson belül használnak.

Példa:

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

A next() használata

A next() metódus a lista, tömb vagy objektum következő elemét adja meg. Ha a lista üres, és ha a next() meghívásra kerül, akkor stopIteration jelzéssel hibát ad vissza. Ez a next() hiba azt jelzi, hogy nincs több elem a listában.

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 egyszeri használatúak

Generátorok esetén csak egyszer használhatók. Ha újra megpróbálja használni őket, üres lesz.

Például:

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:  []

Abban az esetben, ha a kimenetet újra használni szeretné, újra meg kell hívnia a működést.

Példa: Generators és a Fibonacci-sorozat hozama

A következő példa bemutatja, hogyan kell használni a generátorokat, és hogyan kell hozni Python. A példa létrehozza a Fibonacci sorozatot.

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

Példa: Funkció hívása hozammal

Ebben a példában látni fogjuk, hogyan lehet függvényt hívni hozammal.

Az alábbi példában van egy test() nevű függvény, amely az adott szám négyzetét adja vissza. Van egy másik függvény, a getSquare(), amely a test() függvényt hozamkulcsszóval használja. A kimenet az adott számtartomány négyzetes értékét adja meg.

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

Mikor érdemes a hozamot használni a visszatérés helyett? Python

Python3 Hozam A kulcsszó egy generátort ad vissza a hívónak, és a kód végrehajtása csak a generátor iterációja után indul el.

A visszatérés függvényben a függvény végrehajtásának vége, és egyetlen értéket kap vissza a hívó.

Itt van az a helyzet, amikor a Return helyett a Hozamot kell használnia

• Használja a hozamot a return helyett, ha nagy az adatméret
• A hozam a legjobb választás, ha nagyobb adathalmazokon gyorsabb végrehajtásra van szüksége
• Használja a hozamot, ha nagy értékkészletet szeretne visszaadni a hívó függvénynek
• A hozam hatékony módja nagy vagy végtelen adatok előállításának.

Hozam kontra hozam

Itt vannak a különbségek a hozam és a megtérülés között

Hozam	Visszatérés
A Yield egy generátor objektumot ad vissza a hívónak, és a kód végrehajtása csak a generátor iterációja után indul el.	A függvényben a visszatérés a függvény végrehajtásának vége, és egyetlen értéket kap vissza a hívó.
Amikor a függvény meghívódik, és találkozik a hozam kulcsszóval, a függvény végrehajtása leáll. A generátor objektumot visszaküldi a hívónak. A függvény végrehajtása csak a generátor objektum végrehajtásakor indul el.	A függvény meghívásakor a végrehajtás elindul, és az értéket visszaadja a hívónak, ha van return kulcsszó. A függvényen belüli visszatérés a függvény végrehajtásának végét jelzi.
hozam kifejezés	kifejezést adja vissza
A hozamkulcsszó használatakor nincs memóriahasználat.	A visszaadott értékhez a memória le van foglalva.
Nagyon hasznos, ha hatalmas adatmennyiséggel kell megküzdenie, mivel a memória nincs kihasználva.	Kényelmes nagyon kis adatmérethez.
A teljesítmény jobb, ha a hozam kulcsszót nagy adatmérethez használja.	Sok memóriát használnak, ha az adatok mérete hatalmas, ami akadályozza a teljesítményt.
A végrehajtási idő gyorsabb nagy adatméret esetén hozam esetén.	A felhasznált végrehajtási idő több, mivel extra feldolgozás történik arra az esetre, ha az adat mérete nagy, akkor kis adatméret esetén jól működik.

Összegzésként

• A pythonban a hozam kulcsszó úgy működik, mint egy return, azzal az egyetlen különbséggel, hogy ahelyett, hogy értéket adna vissza, egy generátor függvényt ad vissza a hívónak.
• A generátor az iterátor egy speciális típusa, amely használat után nem lesz többé elérhető. Az értékek nem tárolódnak a memóriában, és csak híváskor érhetők el.
• A generátor értékei a for-in, list() és next() metódusokkal olvashatók ki.
• A fő különbség a hozam és a megtérülés között az, hogy a hozam egy generátor függvényt ad vissza a hívónak, a return pedig egyetlen értéket ad a hívónak.
• A Yield egyik értéket sem tárolja a memóriában, és az az előnye, hogy nagy adatméret esetén hasznos, mivel egyik érték sem tárolódik a memóriában.
• A teljesítmény jobb, ha a hozam kulcsszót használja, összehasonlítva a nagy adatmennyiség megtérülésével.

Ez a kód szerkeszthető. Kattintson a Futtatás a végrehajtáshoz gombra