python - What does the "yield" keyword do? -

what use of yield keyword in python? do?

for example, i'm trying understand code¹:

def _get_child_candidates(self, distance, min_dist, max_dist):     if self._leftchild , distance - max_dist < self._median:         yield self._leftchild     if self._rightchild , distance + max_dist >= self._median:         yield self._rightchild

and caller:

result, candidates = list(), [self] while candidates:     node = candidates.pop()     distance = node._get_dist(obj)     if distance <= max_dist , distance >= min_dist:         result.extend(node._values)     candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) return result

what happens when method _get_child_candidates called? list returned? single element? called again? when subsequent calls stop?

_{1. code comes jochen schulz (jrschulz), made great python library metric spaces. link complete source: module mspace.}

to understand yield does, must understand generators are. , before generators come iterables.

iterables

when create list, can read items 1 one. reading items 1 one called iteration:

>>> mylist = [1, 2, 3] >>> in mylist: ...    print(i) 1 2 3

mylist iterable. when use list comprehension, create list, , iterable:

>>> mylist = [x*x x in range(3)] >>> in mylist: ...    print(i) 0 1 4

everything can use "for... in..." on iterable; lists, strings, files...

these iterables handy because can read them as wish, store values in memory , not want when have lot of values.

generators

generators iterators, you can iterate on them once. it's because not store values in memory, they generate values on fly:

>>> mygenerator = (x*x x in range(3)) >>> in mygenerator: ...    print(i) 0 1 4

it same except used () instead of []. but, cannot perform for in mygenerator second time since generators can used once: calculate 0, forget , calculate 1, , end calculating 4, 1 one.

yield

yield keyword used return, except function return generator.

>>> def creategenerator(): ...    mylist = range(3) ...    in mylist: ...        yield i*i ... >>> mygenerator = creategenerator() # create generator >>> print(mygenerator) # mygenerator object! <generator object creategenerator @ 0xb7555c34> >>> in mygenerator: ...     print(i) 0 1 4

here it's useless example, it's handy when know function return huge set of values need read once.

to master yield, must understand when call function, code have written in function body not run. function returns generator object, bit tricky :-)

then, code run each time for uses generator.

now hard part:

the first time for calls generator object created function, run code in function beginning until hits yield, it'll return first value of loop. then, each other call run loop have written in function 1 more time, , return next value, until there no value return.

the generator considered empty once function runs not hit yield anymore. can because loop had come end, or because not satisfy "if/else" anymore.

your code explained

generator:

# here create method of node object return generator def _get_child_candidates(self, distance, min_dist, max_dist):      # here code called each time use generator object:      # if there still child of node object on left     # , if distance ok, return next child     if self._leftchild , distance - max_dist < self._median:         yield self._leftchild      # if there still child of node object on right     # , if distance ok, return next child     if self._rightchild , distance + max_dist >= self._median:         yield self._rightchild      # if function arrives here, generator considered empty     # there no more 2 values: left , right children

caller:

# create empty list , list current object reference result, candidates = list(), [self]  # loop on candidates (they contain 1 element @ beginning) while candidates:      # last candidate , remove list     node = candidates.pop()      # distance between obj , candidate     distance = node._get_dist(obj)      # if distance ok, can fill result     if distance <= max_dist , distance >= min_dist:         result.extend(node._values)      # add children of candidate in candidates list     # loop keep running until have looked     # @ children of children of children, etc. of candidate     candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))  return result

this code contains several smart parts:

the loop iterates on list list expands while loop being iterated :-) it's concise way go through these nested data if it's bit dangerous since can end infinite loop. in case, candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) exhausts values of generator, while keeps creating new generator objects produce different values previous ones since it's not applied on same node.
the extend() method list object method expects iterable , adds values list.

usually pass list it:

>>> = [1, 2] >>> b = [3, 4] >>> a.extend(b) >>> print(a) [1, 2, 3, 4]

but in code gets generator, because:

you don't need read values twice.
you may have lot of children , don't want them stored in memory.

and works because python not care if argument of method list or not. python expects iterables work strings, lists, tuples , generators! called duck typing , 1 of reason why python cool. story, question...

you can stop here, or read little bit see advanced use of generator:

controlling generator exhaustion

>>> class bank(): # let's create bank, building atms ...    crisis = false ...    def create_atm(self): ...        while not self.crisis: ...            yield "$100" >>> hsbc = bank() # when everything's ok atm gives as want >>> corner_street_atm = hsbc.create_atm() >>> print(corner_street_atm.next()) $100 >>> print(corner_street_atm.next()) $100 >>> print([corner_street_atm.next() cash in range(5)]) ['$100', '$100', '$100', '$100', '$100'] >>> hsbc.crisis = true # crisis coming, no more money! >>> print(corner_street_atm.next()) <type 'exceptions.stopiteration'> >>> wall_street_atm = hsbc.create_atm() # it's true new atms >>> print(wall_street_atm.next()) <type 'exceptions.stopiteration'> >>> hsbc.crisis = false # trouble is, post-crisis atm remains empty >>> print(corner_street_atm.next()) <type 'exceptions.stopiteration'> >>> brand_new_atm = hsbc.create_atm() # build new 1 in business >>> cash in brand_new_atm: ...    print cash $100 $100 $100 $100 $100 $100 $100 $100 $100 ...

it can useful various things controlling access resource.

itertools, best friend

the itertools module contains special functions manipulate iterables. ever wish duplicate generator? chain 2 generators? group values in nested list 1 liner? map / zip without creating list?

then import itertools.

an example? let's see possible orders of arrival 4 horse race:

>>> horses = [1, 2, 3, 4] >>> races = itertools.permutations(horses) >>> print(races) <itertools.permutations object @ 0xb754f1dc> >>> print(list(itertools.permutations(horses))) [(1, 2, 3, 4),  (1, 2, 4, 3),  (1, 3, 2, 4),  (1, 3, 4, 2),  (1, 4, 2, 3),  (1, 4, 3, 2),  (2, 1, 3, 4),  (2, 1, 4, 3),  (2, 3, 1, 4),  (2, 3, 4, 1),  (2, 4, 1, 3),  (2, 4, 3, 1),  (3, 1, 2, 4),  (3, 1, 4, 2),  (3, 2, 1, 4),  (3, 2, 4, 1),  (3, 4, 1, 2),  (3, 4, 2, 1),  (4, 1, 2, 3),  (4, 1, 3, 2),  (4, 2, 1, 3),  (4, 2, 3, 1),  (4, 3, 1, 2),  (4, 3, 2, 1)]

understanding inner mechanisms of iteration

iteration process implying iterables (implementing __iter__() method) , iterators (implementing __next__() method). iterables objects can iterator from. iterators objects let iterate on iterables.

Search This Blog

tL