Python 자동화 개발 학습 4-2

목록 생 성식
2 단 코드 먼저 볼 게 요.
a = [ i*2 for i in range(10) ]print(a)#b = []for i in range(10):    b.append(i*2)print(b)
a 와 b 의 효 과 는 같 지만 a 가 사용 하 는 코드 는 더욱 간결 하 다.
목록 생 성식 도 함 수 를 사용 하여 더욱 복잡 한 목록 을 생 성 할 수 있 습 니 다.

a = [ max(i,6) for i in range(10) ]
print(a)

위의 것 은 깔개 이 고,주로 아래 의 생 성 기 를 말한다.
생 성기
목록 생 성식 으로 목록 을 직접 만 들 수 있 습 니 다.목록 이 만들어 지면 목록 에 있 는 요 소 를 방문 할 수 있 습 니 다.하지만 이 건 목록 이 생 성 될 때 까지 기 다 려 야 합 니 다.목록 이 매우 복잡 하 다 면,많은 시간 과 메모리 공간 을 소모 한 후에 야 우 리 는 목록 의 요 소 를 방문 할 수 있 습 니 다.
목록 요 소 를 특정한 알고리즘 에 따라 계산 할 수 있다 면,우 리 는 목록 을 만 들 고 후속 작업 을 할 필요 가 없 으 며,순환 하면 서 새로 만 든 요 소 를 참조 합 니 다.Python 에서 순환 하면 서 계산 하 는 메커니즘 을 생 성기:generator 라 고 합 니 다.

a = [ i*2 for i in range(10) ]
for i in a:
    print(i)
b = ( i*2 for i in range(10) )  #       
for i in b:
    print(i)
print(type(a),type(b))

위의 코드 에서 a 와 b 의 효 과 는 같다.그러나 a 의 메커니즘 은 전체 목록 을 만 들 고 for 순환 을 실행 하 는 것 입 니 다.b 에 하나의 알고리즘 만 기 록 했 을 뿐 데이터 가 생 성 되 지 않 았 습 니 다.for 순환 이 b 를 호출 할 때 까지 기 다 렸 다가 순환 하면 서 모든 요 소 를 계산 합 니 다.
여기 서 우 리 는 두 가지 메커니즘 의 차 이 를 느끼 지 못 하지만 목록 이 크 거나 계산 이 복잡 한 상황 에서 이들 의 차 이 를 발견 할 수 있다.우 리 는 목록 을 만 드 는 시간 을 강제로 늘 렸 다.

import time
def f(n):
    time.sleep(1)
    return n*2
a = [ f(i) for i in range(10) ]
for i in a:
    print(i)
b = ( f(i) for i in range(10) )  #       
for i in b:
    print(i)

이 를 통 해 차이 점 을 발견 할 수 있 습 니 다.a 는 목록 을 만 들 기 위해 오랫동안 기 다 렸 다가 결 과 를 빠르게 출력 합 니 다.한편,b 는 하나의 요 소 를 계산 하고 하나의 요 소 를 출력 하 며 시작 하 는 데 오래 기다 리 지 않 았 지만 매번 출력 사이 에 1 초 를 기 다 려 서 새로운 요 소 를 생 성 해 야 합 니 다.
참고 로 저 는 이들 의 효율 을 살 펴 보 았 습 니 다.이론 적 으로 차이 가 많 지 않 지만 테스트 를 해 보면 a 는 10.02 초,b 는 10.005 초 가 걸 립 니 다.매번 결 과 는 다 르 지만 이 숫자 등급 에 있다.

import time
def f(n):
    time.sleep(1)
    return n*2
t = time.time()
a = [ f(i) for i in range(10) ]
for i in a:
    print(i)
print(time.time()-t)
t = time.time()
b = ( f(i) for i in range(10) )  #       
for i in b:
    print(i)
print(time.time()-t)

보아하니 생 성 기 를 사용 하 는 것 도 더욱 효율 적 인 방법 인 것 같다.
생 성 기 는 순환 하면 서 계산 하 는 것 으로 모든 요 소 는 하나씩 계산 해 야 한다.한 개 씩 만 계산 할 수 있 고 현재 위치 만 기억 합 니 다.현재 위치 에서 다음 값 만 가 져 올 수 있 습 니 다.되 돌아 갈 수도 없고 건 너 뛸 수도 없습니다.
그래서 생 성 기 는 방법 이 하나 밖 에 없어 요.next__

b = ( i*2 for i in range(10) )
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
#        

위 에 좋 은 LOW,보통 순환 으로,next__많이 쓰 지 는 않 았 어 요.
계속 하기 전에 먼저 함수 로 피 보 나치 수열 을 쓰 세 요.
피 보 나치 수열 은 이런 수열 1,1,2,3,5,8,13,21 을 말한다.이 수열 은 3 항 부터 시작 하여 모든 항목 이 앞의 두 항목 의 합 과 같다.

def fib(n):
    i,a,b = 0,0,1
    while i  
  
       print(b)   yield b，              。
 
  
def fib(n):
    i,a,b = 0,0,1
    while i  
  
             。           yield   ，                ，       。
 
  
          yield      ，          ，     .__next__()            。               ，       。                ，                           。          return      。   ，                 。
 
  
def fib(n):
    i,a,b = 0,0,1
    while i  
  
        ，    。          ，   StopIteration:       return   。     try           return  。try    ，       。
 
  
def fib(n):
    i,a,b = 0,0,1
    while i  
  
  x=next(f) x=f,__next__()    。      ，          。
 
  
  yield              ，      ，   。    ，         。
 
  
import time
def consumer(name):
    print("%s       !" %name)
    while True:
       baozi = yield  #     ，  send        
       print("  [%s]  , [%s]  !" %(baozi,name))
def producer(name):
    c = consumer('A')  #      consumer('A')，       
    c2 = consumer('B')  #      consumer('B')
    c.__next__()  # consumer('A')    ，   yield  ，  "      "
    c2.__next__()  # consumer('B')    
    print("          !")
    for i in range(10):
        time.sleep(1)
        print("  2   !")
        c.send(i)  # send  yield  
        c2.send(i)
producer("C")
  
위의 예 에서.send(i)는 전에 말 하지 않 았 습 니 다.그리고.next__()같 지만 sent 는 값 을 돌려 줄 수 있 습 니 다.
위의 예 는 프로듀서 가 시 작 된 후에 두 개의 consumer 를 다시 시작 한 것 이다.consumer 가 yield 가 중단 되 고 기다 릴 때 까지 실행 합 니 다.producer 는 send 를 통 해 consumer 에 게 값 을 전달 한 후 consumer 는 순환 을 한 번 실행 한 다음 에 중단 하고 새로운 값 이 들 어 올 때 까지 기 다 립 니 다.
교체 기
for 순환 대상 에 직접 작용 할 수 있 으 며,교체 가능 대상:Iterable 이 라 고 통칭 합 니 다.
아래 의 이 방법 을 사용 하면 한 대상 의 교체 여 부 를 판단 할 수 있다.
from collections import Iterable
print(isinstance('',Iterable))  #       
print(isinstance(123,Iterable))  #       
print(isinstance((),Iterable))
print(isinstance([],Iterable))
print(isinstance({},Iterable))
print(isinstance((x for x in range(10)),Iterable))  #       ，   
  
생 성 기 는 for 순환 뿐만 아니 라 next 도 사용 하여 다음 값 으로 계속 호출 할 수 있 습 니 다.
 에 게.next__()다음 값 을 호출 하고 계속 되 돌려 주 는 대상 을 교체 기:Iterator 라 고 합 니 다.
아래 의 방법 을 사용 하여 이전의 대상 이 교체 기 인지 아 닌 지 를 다시 한 번 판단 하 다.
from collections import Iterator
print(isinstance('',Iterator))
print(isinstance(123,Iterator))
print(isinstance((),Iterator))
print(isinstance([],Iterator))
print(isinstance({},Iterator))
print(isinstance((x for x in range(10)),Iterator))
  
마지막 하나만 가능 합 니 다next__()，마지막 하나만 트 루,교체 기.
위의 이러한 교체 가능 한 대상 들 은 현재 모두 교체 기 가 아니다.iter()를 통 해 이 교체 가능 한 대상 을 교체 기로 바 꿀 수 있다.
from collections import Iterator
a = [1,2,3,4,5,6]
print(isinstance(a,Iterator))
b = iter(a)
print(isinstance(b,Iterator))
print(b.__next__())
print(b.__next__())
print(b.__next__())
  
Python 의 Iterator 대상 은 데이터 흐름 을 표시 합 니 다.Iterator 대상 은 next()함수 에 의 해 호출 되 고 다음 데 이 터 를 계속 되 돌려 줍 니 다.데이터 가 없 을 때 까지 StopIteration 오 류 를 던 질 수 있 습 니 다.이 데이터 흐름 을 질서 있 는 서열 로 볼 수 있 지만 우 리 는 서열 의 길 이 를 미리 알 수 없고 next()함 수 를 통 해 다음 데 이 터 를 계속 계산 할 수 있 기 때문에 Iterator 의 계산 은 타성 이 고 다음 데 이 터 를 되 돌려 야 할 때 만 계산 할 수 있 습 니 다.이렇게 하면 교체 기 는 심지어 무한 한 데이터 흐름 을 나 타 낼 수 있다.
우리 의 for 순환 은 본질 적 으로 next 를 계속 호출 하여 이 루어 진 것 이다.