Trình tạo so với Python coroutine

Một phương pháp mới cho trình tạo vòng lặp được đề xuất, được gọi là

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

def close[self]:
    try:
        self.throw[GeneratorExit]
    except [GeneratorExit, StopIteration]:
        pass
    else:
        raise RuntimeError["generator ignored GeneratorExit"]
    # Other exceptions are not caught

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

Bởi vì trình tạo lặp bắt đầu thực thi ở đầu thân hàm của trình tạo, không có biểu thức năng suất nào để nhận giá trị khi trình tạo vừa được tạo. Do đó, việc gọi

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

def close[self]:
    try:
        self.throw[GeneratorExit]
    except [GeneratorExit, StopIteration]:
        pass
    else:
        raise RuntimeError["generator ignored GeneratorExit"]
    # Other exceptions are not caught

Cũng như phương thức

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

Tuyên bố năng suất sẽ được phép sử dụng ở phía bên tay phải của một nhiệm vụ; . Giá trị của biểu thức năng suất này là ____6_______1 trừ khi ____6_______3 được gọi với một đối số không ____6_______1;

Một biểu thức năng suất phải luôn được đặt trong ngoặc đơn trừ khi nó xuất hiện ở biểu thức cấp cao nhất ở phía bên tay phải của một phép gán. Vì thế

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

đều hợp pháp, nhưng

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

tất cả đều bất hợp pháp. [Một số trường hợp cạnh được thúc đẩy bởi tính hợp pháp hiện tại của

def consumer[func]:
    def wrapper[*args,**kw]:
        gen = func[*args, **kw]
        gen.next[]
        return gen
    wrapper.__name__ = func.__name__
    wrapper.__dict__ = func.__dict__
    wrapper.__doc__  = func.__doc__
    return wrapper

Lưu ý rằng một tuyên bố năng suất hoặc biểu thức năng suất không có biểu thức hiện là hợp pháp. Điều này thật ý nghĩa. khi luồng thông tin trong lệnh gọi

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

@consumer
def thumbnail_pager[pagesize, thumbsize, destination]:
    while True:
        page = new_image[pagesize]
        rows, columns = pagesize / thumbsize
        pending = False
        try:
            for row in xrange[rows]:
                for column in xrange[columns]:
                    thumb = create_thumbnail[[yield], thumbsize]
                    page.write[
                        thumb, col*thumbsize.x, row*thumbsize.y ]
                    pending = True
        except GeneratorExit:
            # close[] was called, so flush any pending output
            if pending:
                destination.send[page]

            # then close the downstream consumer, and exit
            destination.close[]
            return
        else:
            # we finished a page full of thumbnails, so send it
            # downstream and keep on looping
            destination.send[page]

@consumer
def jpeg_writer[dirname]:
    fileno = 1
    while True:
        filename = os.path.join[dirname,"page%04d.jpg" % fileno]
        write_jpeg[[yield], filename]
        fileno += 1


# Put them together to make a function that makes thumbnail
# pages from a list of images and other parameters.
#
def write_thumbnails[pagesize, thumbsize, images, output_dir]:
    pipeline = thumbnail_pager[
        pagesize, thumbsize, jpeg_writer[output_dir]
    ]

    for image in images:
        pipeline.send[image]

    pipeline.close[]

Khi send[value] được gọi, biểu thức năng suất mà nó tiếp tục sẽ trả về giá trị được truyền vào. Khi ___6_______2 được gọi, biểu thức năng suất được tiếp tục sẽ trả về ___6_______1. Nếu biểu thức năng suất là một câu lệnh năng suất, thì giá trị được trả về này sẽ bị bỏ qua, tương tự như việc bỏ qua giá trị được trả về bởi lệnh gọi hàm được sử dụng làm câu lệnh

Trên thực tế, một biểu thức năng suất giống như một lệnh gọi hàm đảo ngược;

Ghi chú. các phần mở rộng cú pháp để yield làm cho việc sử dụng nó rất giống với phần mở rộng trong Ruby. Đây là cố ý. Xin lưu ý rằng trong Python, khối chuyển một giá trị cho trình tạo bằng cách sử dụng

@consumer
def thumbnail_pager[pagesize, thumbsize, destination]:
    while True:
        page = new_image[pagesize]
        rows, columns = pagesize / thumbsize
        pending = False
        try:
            for row in xrange[rows]:
                for column in xrange[columns]:
                    thumb = create_thumbnail[[yield], thumbsize]
                    page.write[
                        thumb, col*thumbsize.x, row*thumbsize.y ]
                    pending = True
        except GeneratorExit:
            # close[] was called, so flush any pending output
            if pending:
                destination.send[page]

            # then close the downstream consumer, and exit
            destination.close[]
            return
        else:
            # we finished a page full of thumbnails, so send it
            # downstream and keep on looping
            destination.send[page]

@consumer
def jpeg_writer[dirname]:
    fileno = 1
    while True:
        filename = os.path.join[dirname,"page%04d.jpg" % fileno]
        write_jpeg[[yield], filename]
        fileno += 1


# Put them together to make a function that makes thumbnail
# pages from a list of images and other parameters.
#
def write_thumbnails[pagesize, thumbsize, images, output_dir]:
    pipeline = thumbnail_pager[
        pagesize, thumbsize, jpeg_writer[output_dir]
    ]

    for image in images:
        pipeline.send[image]

    pipeline.close[]

@consumer
def thumbnail_pager[pagesize, thumbsize, destination]:
    while True:
        page = new_image[pagesize]
        rows, columns = pagesize / thumbsize
        pending = False
        try:
            for row in xrange[rows]:
                for column in xrange[columns]:
                    thumb = create_thumbnail[[yield], thumbsize]
                    page.write[
                        thumb, col*thumbsize.x, row*thumbsize.y ]
                    pending = True
        except GeneratorExit:
            # close[] was called, so flush any pending output
            if pending:
                destination.send[page]

            # then close the downstream consumer, and exit
            destination.close[]
            return
        else:
            # we finished a page full of thumbnails, so send it
            # downstream and keep on looping
            destination.send[page]

@consumer
def jpeg_writer[dirname]:
    fileno = 1
    while True:
        filename = os.path.join[dirname,"page%04d.jpg" % fileno]
        write_jpeg[[yield], filename]
        fileno += 1


# Put them together to make a function that makes thumbnail
# pages from a list of images and other parameters.
#
def write_thumbnails[pagesize, thumbsize, images, output_dir]:
    pipeline = thumbnail_pager[
        pagesize, thumbsize, jpeg_writer[output_dir]
    ]

    for image in images:
        pipeline.send[image]

    pipeline.close[]

Cú pháp cho các hàm tạo được mở rộng để cho phép một tuyên bố năng suất bên trong một câu lệnh

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

import collections

class Trampoline:
    """Manage communications between coroutines"""

    running = False

    def __init__[self]:
        self.queue = collections.deque[]

    def add[self, coroutine]:
        """Request that a coroutine be executed"""
        self.schedule[coroutine]

    def run[self]:
        result = None
        self.running = True
        try:
            while self.running and self.queue:
               func = self.queue.popleft[]
               result = func[]
            return result
        finally:
            self.running = False

    def stop[self]:
        self.running = False

    def schedule[self, coroutine, stack=[], val=None, *exc]:
        def resume[]:
            value = val
            try:
                if exc:
                    value = coroutine.throw[value,*exc]
                else:
                    value = coroutine.send[value]
            except:
                if stack:
                    # send the error back to the "caller"
                    self.schedule[
                        stack[0], stack[1], *sys.exc_info[]
                    ]
                else:
                    # Nothing left in this pseudothread to
                    # handle it, let it propagate to the
                    # run loop
                    raise

            if isinstance[value, types.GeneratorType]:
                # Yielded to a specific coroutine, push the
                # current one on the stack, and call the new
                # one with no args
                self.schedule[value, [coroutine,stack]]

            elif stack:
                # Yielded a result, pop the stack and send the
                # value to the caller
                self.schedule[stack[0], stack[1], value]

            # else: this pseudothread has ended

        self.queue.append[resume]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

import collections

class Trampoline:
    """Manage communications between coroutines"""

    running = False

    def __init__[self]:
        self.queue = collections.deque[]

    def add[self, coroutine]:
        """Request that a coroutine be executed"""
        self.schedule[coroutine]

    def run[self]:
        result = None
        self.running = True
        try:
            while self.running and self.queue:
               func = self.queue.popleft[]
               result = func[]
            return result
        finally:
            self.running = False

    def stop[self]:
        self.running = False

    def schedule[self, coroutine, stack=[], val=None, *exc]:
        def resume[]:
            value = val
            try:
                if exc:
                    value = coroutine.throw[value,*exc]
                else:
                    value = coroutine.send[value]
            except:
                if stack:
                    # send the error back to the "caller"
                    self.schedule[
                        stack[0], stack[1], *sys.exc_info[]
                    ]
                else:
                    # Nothing left in this pseudothread to
                    # handle it, let it propagate to the
                    # run loop
                    raise

            if isinstance[value, types.GeneratorType]:
                # Yielded to a specific coroutine, push the
                # current one on the stack, and call the new
                # one with no args
                self.schedule[value, [coroutine,stack]]

            elif stack:
                # Yielded a result, pop the stack and send the
                # value to the caller
                self.schedule[stack[0], stack[1], value]

            # else: this pseudothread has ended

        self.queue.append[resume]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

Hiệu quả của việc tăng ngoại lệ chính xác như thể câu lệnh

raise type, value, traceback

đã được thực hiện tại điểm đình chỉ. Đối số loại không được là

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

# coroutine function that echos data back on a connected
# socket
#
def echo_handler[sock]:
    while True:
        try:
            data = yield nonblocking_read[sock]
            yield nonblocking_write[sock, data]
        except ConnectionLost:
            pass  # exit normally if connection lost

# coroutine function that listens for connections on a
# socket, and then launches a service "handler" coroutine
# to service the connection
#
def listen_on[trampoline, sock, handler]:
    while True:
        # get the next incoming connection
        connected_socket = yield nonblocking_accept[sock]

        # start another coroutine to handle the connection
        trampoline.add[ handler[connected_socket] ]

# Create a scheduler to manage all our coroutines
t = Trampoline[]

# Create a coroutine instance to run the echo_handler on
# incoming connections
#
server = listen_on[
    t, listening_socket["localhost","echo"], echo_handler
]

# Add the coroutine to the scheduler
t.add[server]

# loop forever, accepting connections and servicing them
# "in parallel"
#
t.run[]

def close[self]:
    try:
        self.throw[GeneratorExit]
    except [GeneratorExit, StopIteration]:
        pass
    else:
        raise RuntimeError["generator ignored GeneratorExit"]
    # Other exceptions are not caught

Ghi chú. Tên của phương pháp

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

# coroutine function that echos data back on a connected
# socket
#
def echo_handler[sock]:
    while True:
        try:
            data = yield nonblocking_read[sock]
            yield nonblocking_write[sock, data]
        except ConnectionLost:
            pass  # exit normally if connection lost

# coroutine function that listens for connections on a
# socket, and then launches a service "handler" coroutine
# to service the connection
#
def listen_on[trampoline, sock, handler]:
    while True:
        # get the next incoming connection
        connected_socket = yield nonblocking_accept[sock]

        # start another coroutine to handle the connection
        trampoline.add[ handler[connected_socket] ]

# Create a scheduler to manage all our coroutines
t = Trampoline[]

# Create a coroutine instance to run the echo_handler on
# incoming connections
#
server = listen_on[
    t, listening_socket["localhost","echo"], echo_handler
]

# Add the coroutine to the scheduler
t.add[server]

# loop forever, accepting connections and servicing them
# "in parallel"
#
t.run[]

# coroutine function that echos data back on a connected
# socket
#
def echo_handler[sock]:
    while True:
        try:
            data = yield nonblocking_read[sock]
            yield nonblocking_write[sock, data]
        except ConnectionLost:
            pass  # exit normally if connection lost

# coroutine function that listens for connections on a
# socket, and then launches a service "handler" coroutine
# to service the connection
#
def listen_on[trampoline, sock, handler]:
    while True:
        # get the next incoming connection
        connected_socket = yield nonblocking_accept[sock]

        # start another coroutine to handle the connection
        trampoline.add[ handler[connected_socket] ]

# Create a scheduler to manage all our coroutines
t = Trampoline[]

# Create a coroutine instance to run the echo_handler on
# incoming connections
#
server = listen_on[
    t, listening_socket["localhost","echo"], echo_handler
]

# Add the coroutine to the scheduler
t.add[server]

# loop forever, accepting connections and servicing them
# "in parallel"
#
t.run[]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

tên phương pháp thay thế đã được xem xét.

# coroutine function that echos data back on a connected
# socket
#
def echo_handler[sock]:
    while True:
        try:
            data = yield nonblocking_read[sock]
            yield nonblocking_write[sock, data]
        except ConnectionLost:
            pass  # exit normally if connection lost

# coroutine function that listens for connections on a
# socket, and then launches a service "handler" coroutine
# to service the connection
#
def listen_on[trampoline, sock, handler]:
    while True:
        # get the next incoming connection
        connected_socket = yield nonblocking_accept[sock]

        # start another coroutine to handle the connection
        trampoline.add[ handler[connected_socket] ]

# Create a scheduler to manage all our coroutines
t = Trampoline[]

# Create a coroutine instance to run the echo_handler on
# incoming connections
#
server = listen_on[
    t, listening_socket["localhost","echo"], echo_handler
]

# Add the coroutine to the scheduler
t.add[server]

# loop forever, accepting connections and servicing them
# "in parallel"
#
t.run[]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

Một ngoại lệ tiêu chuẩn mới được xác định,

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = 12 + yield 42
x = 12 + yield
foo[yield 42, 12]
foo[yield, 12]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

def close[self]:
    try:
        self.throw[GeneratorExit]
    except [GeneratorExit, StopIteration]:
        pass
    else:
        raise RuntimeError["generator ignored GeneratorExit"]
    # Other exceptions are not caught

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

Nếu đối tượng trình tạo tham gia vào một chu trình, thì có thể không gọi được

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

Lưu ý rằng không có khả năng thấy một đối tượng trình tạo tham gia vào một chu trình trong thực tế. Tuy nhiên, việc lưu trữ một đối tượng trình tạo trong một biến toàn cục sẽ tạo ra một chu trình thông qua con trỏ

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

Ngoài ra, trong quá trình triển khai CPython của PEP này, đối tượng khung được trình tạo sử dụng sẽ được giải phóng bất cứ khi nào quá trình thực thi của nó bị chấm dứt do lỗi hoặc thoát bình thường. Điều này sẽ đảm bảo rằng các trình tạo không thể tiếp tục hoạt động sẽ không nằm trong chu kỳ tham chiếu không thể thu thập được. Điều này cho phép mã khác có khả năng sử dụng

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]

Bản nháp trước đó của PEP này đã đề xuất một cú pháp

x = yield 42
x = yield
x = 12 + [yield 42]
x = 12 + [yield]
foo[yield 42]
foo[yield]