"yield"키워드의 기능은 무엇입니까?

질문

 

Python에서 yield 키워드의 용도는 무엇이며 어떤 역할을합니까?

예를 들어 다음 코드를 이해하려고합니다 ¹ :

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

발신자입니다.

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

_get_child_candidates 메소드가 호출되면 어떻게 되나요? 목록이 반환됩니까? 단일 요소? 또 불려? 후속 통화는 언제 중단 되나요?

---

_{1.이 코드는 메트릭 공간을위한 훌륭한 Python 라이브러리를 만든 Jochen Schulz (jrschulz)가 작성했습니다. 다음은 전체 소스에 대한 링크입니다. Module mspace .}</p >

답변

yield의 기능을 이해하려면 생성자가 무엇인지 이해해야합니다. 생성기를 이해하기 전에 반복 가능 요소를 이해해야합니다.

iterable

목록을 만들 때 항목을 하나씩 읽을 수 있습니다. 항목을 하나씩 읽는 것을 반복이라고합니다.

>>> 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 ..."을 사용할 수있는 모든 것은 반복 가능합니다. 목록, 문자열, 파일 ...

이러한 반복 가능 항목은 원하는만큼 읽을 수 있지만 모든 값을 메모리에 저장하기 때문에 편리합니다. 값이 많을 때 항상 원하는 것은 아닙니다.

생성자

생성자는 iterator이며 일종의 반복 가능한 한 번만 반복 할 수 있습니다. 생성기는 모든 값을 메모리에 저장하지 않으며 즉시 값을 생성합니다 :

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

yield는 함수가 생성기를 반환한다는 점을 제외하고 return과 같이 사용되는 키워드입니다.

>>> def createGenerator():
...    mylist = range(3)
...    for i in mylist:
...        yield i*i
...
>>> mygenerator = createGenerator() # create a generator
>>> print(mygenerator) # mygenerator is an object!
<generator object createGenerator 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

Caller :

# 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))는 생성기의 모든 값을 소진하지만 동안은 새로운 생성기 객체를 계속 생성합니다. 동일한 노드에 적용되지 않기 때문에 이전 값과 다른 값을 생성합니다.

• extend () 메소드는 이터 러블을 예상하고 그 값을 목록에 추가하는 목록 객체 메소드입니다.

일반적으로 목록을 전달합니다.

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

하지만 코드에서 생성기를 가져옵니다. 다음과 같은 이유로 좋습니다.

1. 값을 두 번 읽을 필요가 없습니다.
2. 많은 자녀가있을 수 있으며 모두 메모리에 저장되는 것을 원하지 않습니다.

그리고 파이썬은 메소드의 인수가 목록인지 아닌지 상관하지 않기 때문에 작동합니다. 파이썬은 이터 러블을 기대하므로 문자열, 목록, 튜플 및 생성기와 함께 작동합니다! 이것은 덕 타이핑이라고 불리며 파이썬이 멋진 이유 중 하나입니다. 하지만 이것은 또 다른 이야기입니다. 또 다른 질문입니다 ...

여기에서 멈추거나 발전기의 고급 사용법을 확인하기 위해 조금 읽어보세요.

생성자 고갈 제어

>>> 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))</p를 사용합니다. >

리소스에 대한 액세스 제어와 같은 다양한 작업에 유용 할 수 있습니다.

Itertools, 가장 친한 친구

itertools 모듈에는 iterable을 조작하는 특수 함수가 포함되어 있습니다. 생성기를 복제하고 싶습니까? 두 개의 발전기를 연결 하시겠습니까? 한 줄로 중첩 된 목록의 값을 그룹화 하시겠습니까? 다른 목록을 만들지 않고 지도 / 우편?

그런 다음 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 __ () 메소드 구현)를 암시하는 프로세스입니다. 이터 러블은 이터레이터를 가져올 수있는 모든 객체입니다. 반복자는 반복 가능한 항목을 반복 할 수있는 객체입니다.

어떻게 용에 대해 자세히 설명합니다. 루프가 작동합니다 .

출처 : http://stackoverflow.com/questions/231767