Чтобы понять, что делает yield
, вы должны понимать, что такое генераторы . И прежде чем вы сможете понять генераторы, вы должны понять итерации .
Итерационные объекты
Когда вы создаете список, вы можете читать его элементы один за другим. Чтение его элементов по одному называется итерацией:
>>> mylist = [1, 2, 3]
>>> for i in mylist:
... print(i)
1
2
3
mylist
- это итерируемый . Когда вы используете понимание списка, вы создаете список и, следовательно, повторяемый:
>>> mylist = [x*x for x in range(3)]
>>> for i in mylist:
... print(i)
0
1
4
Все, что вы можете использовать для «for... in...
», является итерируемым; lists
, strings
, файлы ...
Эти итерации удобны, потому что вы можете читать их сколько угодно, но вы храните все значения в памяти, и это не всегда то, что вам нужно, когда у вас много значений.
Генераторы
Генераторы - это итераторы, своего рода итерируемые , которые можно выполнять только один раз . Генераторы не хранят все значения в памяти, они генерируют значения на лету :
>>> mygenerator = (x*x for x in range(3))
>>> for i in mygenerator:
... print(i)
0
1
4
Это то же самое, за исключением того, что вы использовали ()
вместо []
. НО, вы не можете выполнить for i in mygenerator
второй раз, поскольку генераторы можно использовать только один раз: они вычисляют 0, затем забывают об этом и вычисляют 1, и заканчивают вычисление 4, один за другим.
Доходность
yield
- ключевое слово, которое используется как return
, за исключением того, что функция вернет генератор.
>>> def create_generator():
... mylist = range(3)
... for i in mylist:
... yield i*i
...
>>> mygenerator = create_generator() # create a generator
>>> print(mygenerator) # mygenerator is an object!
<generator object create_generator at 0xb7555c34>
>>> for i in mygenerator:
... print(i)
0
1
4
Вот это бесполезный пример, но он удобен, когда вы знаете, что ваша функция вернет огромный набор значений, которые вам нужно будет прочитать только один раз.
Чтобы освоить yield
, вы должны понимать, что , когда вы вызываете функцию, код, который вы написали в теле функции, не запускается. Функция возвращает только объект генератора, это немного сложно.
Затем ваш код будет продолжаться с того места, где он остановился, каждый раз, когда for
использует генератор.
Теперь самая сложная часть:
В первый раз, когда for
вызывает объект-генератор, созданный из вашей функции, он запускает код в вашей функции с самого начала, пока не достигнет yield
, а затем вернет первое значение цикла. Затем каждый последующий вызов будет запускать другую итерацию цикла, который вы написали в функции, и возвращать следующее значение. Это будет продолжаться до тех пор, пока генератор не будет считаться пустым, что происходит, когда функция выполняется без нажатия yield
. Это может быть из-за того, что цикл подошел к концу, или из-за того, что вы больше не удовлетворяете "if/else"
.
Ваш код объяснил
Генератор :
# Here you create the method of the node object that will return the generator
def _get_child_candidates(self, distance, min_dist, max_dist):
# Here is the code that will be called each time you use the generator object:
# If there is still a child of the node object on its left
# AND if the distance is ok, return the next child
if self._leftchild and distance - max_dist < self._median:
yield self._leftchild
# If there is still a child of the node object on its right
# AND if the distance is ok, return the next child
if self._rightchild and distance + max_dist >= self._median:
yield self._rightchild
# If the function arrives here, the generator will be considered empty
# there is no more than two values: the left and the right children
Вызывающий :
# Create an empty list and a list with the current object reference
result, candidates = list(), [self]
# Loop on candidates (they contain only one element at the beginning)
while candidates:
# Get the last candidate and remove it from the list
node = candidates.pop()
# Get the distance between obj and the candidate
distance = node._get_dist(obj)
# If distance is ok, then you can fill the result
if distance <= max_dist and distance >= min_dist:
result.extend(node._values)
# Add the children of the candidate in the candidate's list
# so the loop will keep running until it will have looked
# at all the children of the children of the children, etc. of the candidate
candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))
return result
Этот код содержит несколько умных частей:
-
Цикл повторяется по списку, но список расширяется во время итерации цикла. Это краткий способ просмотреть все эти вложенные данные, даже если это немного опасно, поскольку вы можете получить бесконечный цикл. В этом случае candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))
исчерпывает все значения генератора, но while
продолжает создавать новые объекты генератора, которые будут выдавать значения, отличные от предыдущих, поскольку он не применяется к тому же узлу.
-
Метод extend()
- это метод объекта списка, который ожидает итерацию и добавляет свои значения в список.
Обычно мы передаем ему список:
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.extend(b)
>>> print(a)
[1, 2, 3, 4]
Но в вашем коде он получает генератор, что хорошо, потому что:
- Вам не нужно читать значения дважды.
- У вас может быть много детей, и вы не хотите, чтобы они все хранились в памяти.
И это работает, потому что Python не заботится, является ли аргумент метода списком или нет. Python ожидает итераций, поэтому он будет работать со строками, списками, кортежами и генераторами! Это называется утиной типизацией и является одной из причин, по которой Python такой крутой. Но это уже другая история, другой вопрос ...
На этом можно остановиться или немного почитать, чтобы увидеть расширенное использование генератора:
Контроль истощения генератора
>>> class Bank(): # Let's create a bank, building ATMs
... crisis = False
... def create_atm(self):
... while not self.crisis:
... yield "$100"
>>> hsbc = Bank() # When everything's ok the ATM gives you as much as you want
>>> corner_street_atm = hsbc.create_atm()
>>> print(corner_street_atm.next())
$100
>>> print(corner_street_atm.next())
$100
>>> print([corner_street_atm.next() for cash in range(5)])
['$100', '$100', '$100', '$100', '$100']
>>> hsbc.crisis = True # Crisis is coming, no more money!
>>> print(corner_street_atm.next())
<type 'exceptions.StopIteration'>
>>> wall_street_atm = hsbc.create_atm() # It's even true for new ATMs
>>> print(wall_street_atm.next())
<type 'exceptions.StopIteration'>
>>> hsbc.crisis = False # The trouble is, even post-crisis the ATM remains empty
>>> print(corner_street_atm.next())
<type 'exceptions.StopIteration'>
>>> brand_new_atm = hsbc.create_atm() # Build a new one to get back in business
>>> for cash in brand_new_atm:
... print cash
$100
$100
$100
$100
$100
$100
$100
$100
$100
...
Примечание: Для Python 3 используйте print(corner_street_atm.__next__())
или print(next(corner_street_atm))
Это может быть полезно для различных вещей, например, для управления доступом к ресурсу.
Itertools, ваш лучший друг
Модуль itertools содержит специальные функции для управления итерациями. Вы когда-нибудь хотели продублировать генератор?
Связать два генератора? Сгруппировать значения во вложенном списке с однострочником? Map / Zip
без создания другого списка?
Тогда просто import itertools
.
Пример? Посмотрим возможные порядки прибытия для скачки на четырех лошадях:
>>> horses = [1, 2, 3, 4]
>>> races = itertools.permutations(horses)
>>> print(races)
<itertools.permutations object at 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)]
Понимание внутренних механизмов итерации
Итерация - это процесс, включающий итераторы (реализующие метод __iter__()
) и итераторы (реализующие метод __next__()
).
Итерируемые объекты - это любые объекты, из которых вы можете получить итератор. Итераторы - это объекты, которые позволяют выполнять итерацию по итерациям.
Подробнее об этом в этой статье: как работают for
циклы.
yield не волшебный, как предполагает главный ответ. Отличный комментарий @ mattias-fripp:
When you call a function that has a yield statement, you get a generator object, but no code runs. Then each time you extract an object from the generator, Python executes the function until it reaches a yield statement, then pauses and delivers the object. When you extract another object, Python resumes just after the yield and continues until it reaches another yield (often the same one, but one iteration later). This continues until the function runs off the end, at which point the generator is deemed exhausted.