Python lặp qua các đoạn danh sách

chức năng itertool

Các chức năng mô-đun sau đây tất cả các trình vòng lặp xây dựng và trả về. Một số cung cấp luồng có độ dài vô hạn, vì vậy chúng chỉ nên được truy cập bằng các hàm hoặc vòng lặp cắt bớt luồng

Tạo một trình lặp trả về tổng tích lũy hoặc kết quả tích lũy của các hàm nhị phân khác (được chỉ định thông qua đối số func tùy chọn)

Nếu func được cung cấp, nó phải là hàm của hai đối số. Các phần tử của đầu vào có thể lặp lại có thể là bất kỳ loại nào có thể được chấp nhận làm đối số cho func. (Ví dụ: với hoạt động mặc định của phép cộng, các phần tử có thể là bất kỳ loại có thể thêm nào bao gồm hoặc. )

Thông thường, số lượng phần tử đầu ra khớp với đầu vào có thể lặp lại. Tuy nhiên, nếu đối số từ khóa ban đầu được cung cấp, thì quá trình tích lũy sẽ dẫn đến giá trị ban đầu để đầu ra có nhiều phần tử hơn đầu vào có thể lặp lại

Gần tương đương với

def accumulate(iterable, func=operator.add, *, initial=None):
    'Return running totals'
    # accumulate([1,2,3,4,5]) --> 1 3 6 10 15
    # accumulate([1,2,3,4,5], initial=100) --> 100 101 103 106 110 115
    # accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120
    it = iter(iterable)
    total = initial
    if initial is None:
        try:
            total = next(it)
        except StopIteration:
            return
    yield total
    for element in it:
        total = func(total, element)
        yield total

Có một số cách sử dụng đối số func. Nó có thể được đặt thành cho mức tối thiểu đang chạy, cho mức tối đa đang chạy hoặc cho một sản phẩm đang chạy. Bảng khấu hao có thể được xây dựng bằng cách tích lũy tiền lãi và áp dụng các khoản thanh toán

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Xem một hàm tương tự chỉ trả về giá trị tích lũy cuối cùng

Mới trong phiên bản 3. 2

Đã thay đổi trong phiên bản 3. 3. Đã thêm tham số func tùy chọn.

Đã thay đổi trong phiên bản 3. 8. Đã thêm tham số ban đầu tùy chọn.

Tạo một trình lặp trả về các phần tử từ lần lặp đầu tiên cho đến khi hết, sau đó chuyển sang lần lặp tiếp theo, cho đến khi tất cả các lần lặp đã hết. Được sử dụng để coi các chuỗi liên tiếp là một chuỗi duy nhất. Gần tương đương với

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Hàm tạo thay thế cho. Nhận các đầu vào được xâu chuỗi từ một đối số có thể lặp lại duy nhất được đánh giá một cách lười biếng. Gần tương đương với

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Trả về các chuỗi con độ dài r của các phần tử từ đầu vào có thể lặp lại

Các bộ dữ liệu kết hợp được phát ra theo thứ tự từ điển theo thứ tự của đầu vào có thể lặp lại. Vì vậy, nếu lần lặp đầu vào được sắp xếp, các bộ dữ liệu đầu ra sẽ được tạo theo thứ tự đã sắp xếp

Các yếu tố được coi là duy nhất dựa trên vị trí của chúng, không dựa trên giá trị của chúng. Vì vậy, nếu các phần tử đầu vào là duy nhất, sẽ không có giá trị lặp lại trong mỗi kết hợp

Gần tương đương với

def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = list(range(r))
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)

Mã cho cũng có thể được biểu thị dưới dạng một chuỗi sau khi lọc các mục trong đó các phần tử không được sắp xếp theo thứ tự (theo vị trí của chúng trong nhóm đầu vào)

def combinations(iterable, r):
    pool = tuple(iterable)
    n = len(pool)
    for indices in permutations(range(n), r):
        if sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)

Số lượng mặt hàng được trả lại là

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)

Trả về các chuỗi con có độ dài r của các phần tử từ đầu vào có thể lặp lại cho phép các phần tử riêng lẻ được lặp lại nhiều lần

Các bộ dữ liệu kết hợp được phát ra theo thứ tự từ điển theo thứ tự của đầu vào có thể lặp lại. Vì vậy, nếu lần lặp đầu vào được sắp xếp, các bộ dữ liệu đầu ra sẽ được tạo theo thứ tự đã sắp xếp

Các yếu tố được coi là duy nhất dựa trên vị trí của chúng, không dựa trên giá trị của chúng. Vì vậy, nếu các phần tử đầu vào là duy nhất, thì các kết hợp được tạo cũng sẽ là duy nhất

Gần tương đương với

def combinations_with_replacement(iterable, r):
    # combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
    pool = tuple(iterable)
    n = len(pool)
    if not n and r:
        return
    indices = [0] * r
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != n - 1:
                break
        else:
            return
        indices[i:] = [indices[i] + 1] * (r - i)
        yield tuple(pool[i] for i in indices)

Mã cho cũng có thể được biểu thị dưới dạng một chuỗi sau khi lọc các mục trong đó các phần tử không được sắp xếp theo thứ tự (theo vị trí của chúng trong nhóm đầu vào)

def combinations_with_replacement(iterable, r):
    pool = tuple(iterable)
    n = len(pool)
    for indices in product(range(n), repeat=r):
        if sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)

Số mặt hàng được trả lại là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Mới trong phiên bản 3. 1

Tạo một trình vòng lặp lọc các phần tử từ dữ liệu chỉ trả về những phần tử có phần tử tương ứng trong bộ chọn có giá trị là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)

Mới trong phiên bản 3. 1

Tạo một trình vòng lặp trả về các giá trị cách đều nhau bắt đầu bằng số bắt đầu. Thường được sử dụng làm đối số để tạo các điểm dữ liệu liên tiếp. Ngoài ra, được sử dụng với để thêm số thứ tự. Gần tương đương với

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Khi đếm với các số dấu phẩy động, đôi khi có thể đạt được độ chính xác cao hơn bằng cách thay thế mã nhân như.

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Đã thay đổi trong phiên bản 3. 1. Đã thêm đối số bước và cho phép đối số không phải là số nguyên.

Tạo một iterator trả về các phần tử từ iterable và lưu một bản sao của từng phần tử. Khi iterable cạn kiệt, hãy trả lại các phần tử từ bản sao đã lưu. Lặp lại vô thời hạn. Gần tương đương với

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Lưu ý, thành viên này của bộ công cụ có thể yêu cầu bộ nhớ phụ đáng kể (tùy thuộc vào độ dài của lần lặp)

Tạo một trình vòng lặp loại bỏ các phần tử khỏi vòng lặp miễn là vị từ là đúng; . Lưu ý, trình vòng lặp không tạo ra bất kỳ đầu ra nào cho đến khi vị từ đầu tiên trở thành sai, do đó, nó có thể có thời gian khởi động lâu. Gần tương đương với

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Tạo một iterator lọc các phần tử từ iterable chỉ trả lại những phần tử có vị từ là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Tạo một trình vòng lặp trả về các khóa và nhóm liên tiếp từ vòng lặp. Khóa là một hàm tính toán giá trị khóa cho từng phần tử. Nếu không được chỉ định hoặc là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Hoạt động của tương tự như bộ lọc

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Nhóm được trả về tự nó là một iterator chia sẻ iterable bên dưới với. Vì nguồn được chia sẻ nên khi đối tượng được nâng cao, nhóm trước đó không còn hiển thị. Vì vậy, nếu dữ liệu đó cần thiết sau này, nó sẽ được lưu trữ dưới dạng danh sách

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

gần tương đương với

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Tạo một trình lặp trả về các phần tử đã chọn từ có thể lặp lại. Nếu start khác 0, thì các phần tử từ iterable sẽ bị bỏ qua cho đến khi bắt đầu. Sau đó, các phần tử được trả về liên tiếp trừ khi bước được đặt cao hơn bước dẫn đến các mục bị bỏ qua. Nếu điểm dừng là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Nếu bắt đầu là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Không giống như cắt thông thường, không hỗ trợ các giá trị âm cho bắt đầu, dừng hoặc bước. Có thể được sử dụng để trích xuất các trường liên quan từ dữ liệu có cấu trúc bên trong đã được làm phẳng (ví dụ: báo cáo nhiều dòng có thể liệt kê một trường tên trên mỗi dòng thứ ba)

Gần tương đương với

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Trả về các cặp chồng chéo liên tiếp được lấy từ đầu vào có thể lặp lại

Số lượng 2 bộ trong trình vòng lặp đầu ra sẽ ít hơn một lần so với số lượng đầu vào. Nó sẽ trống nếu đầu vào có thể lặp lại có ít hơn hai giá trị

Gần tương đương với

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Mới trong phiên bản 3. 10

Trả về các hoán vị chiều dài r liên tiếp của các phần tử trong iterable

Nếu r không được chỉ định hoặc là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Các bộ hoán vị được phát ra theo thứ tự từ điển theo thứ tự của đầu vào có thể lặp lại. Vì vậy, nếu lần lặp đầu vào được sắp xếp, các bộ dữ liệu đầu ra sẽ được tạo theo thứ tự đã sắp xếp

Các yếu tố được coi là duy nhất dựa trên vị trí của chúng, không dựa trên giá trị của chúng. Vì vậy, nếu các phần tử đầu vào là duy nhất, sẽ không có giá trị lặp lại trong một hoán vị

Gần tương đương với

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Mã cho cũng có thể được biểu thị dưới dạng một chuỗi con của , được lọc để loại trừ các mục có phần tử lặp lại (những mục từ cùng một vị trí trong nhóm đầu vào)

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Số lượng mặt hàng được trả lại là

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)

Sản phẩm Descartes của các lần lặp đầu vào

Gần tương đương với các vòng lặp for lồng nhau trong biểu thức trình tạo. Ví dụ:

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Các vòng lặp lồng nhau giống như một máy đo đường với phần tử ngoài cùng bên phải tăng dần trên mỗi lần lặp. Mẫu này tạo ra một thứ tự từ điển để nếu các lần lặp của đầu vào được sắp xếp, các bộ sản phẩm được phát ra theo thứ tự đã sắp xếp

Để tính tích của một lần lặp với chính nó, hãy chỉ định số lần lặp lại với đối số từ khóa lặp lại tùy chọn. Ví dụ:

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Hàm này gần tương đương với đoạn mã sau, ngoại trừ việc triển khai thực tế không tạo kết quả trung gian trong bộ nhớ

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Trước khi chạy, nó tiêu thụ hoàn toàn các lần lặp đầu vào, giữ các nhóm giá trị trong bộ nhớ để tạo ra các sản phẩm. Theo đó, nó chỉ hữu ích với đầu vào hữu hạn

Tạo một trình vòng lặp trả về đối tượng nhiều lần. Chạy vô thời hạn trừ khi đối số lần được chỉ định

Gần tương đương với

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Một cách sử dụng phổ biến để lặp lại là cung cấp một luồng giá trị không đổi cho ánh xạ hoặc zip

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Tạo một trình lặp tính toán hàm bằng cách sử dụng các đối số thu được từ trình lặp. Được sử dụng thay cho khi các tham số đối số đã được nhóm trong các bộ dữ liệu từ một lần lặp duy nhất (khi dữ liệu đã được “nén trước”)

Sự khác biệt giữa và tương đồng với sự khác biệt giữa

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Tạo một iterator trả về các phần tử từ iterable miễn là vị từ là đúng. Gần tương đương với

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Trả về n trình vòng lặp độc lập từ một lần lặp duy nhất

Mã Python sau đây giúp giải thích chức năng của tee (mặc dù việc triển khai thực tế phức tạp hơn và chỉ sử dụng một hàng đợi FIFO bên dưới)

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Sau khi a đã được tạo, bản gốc có thể lặp lại không được sử dụng ở bất kỳ nơi nào khác;

Trình vòng lặp

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Itertool này có thể yêu cầu bộ nhớ phụ đáng kể (tùy thuộc vào lượng dữ liệu tạm thời cần được lưu trữ). Nói chung, nếu một trình vòng lặp sử dụng hầu hết hoặc tất cả dữ liệu trước khi một trình vòng lặp khác bắt đầu, thì việc sử dụng nó sẽ nhanh hơn thay vì

Tạo một trình lặp tổng hợp các phần tử từ mỗi lần lặp. Nếu các lần lặp có độ dài không đồng đều, các giá trị bị thiếu sẽ được điền vào bằng giá trị điền. Lặp lại tiếp tục cho đến khi hết lần lặp dài nhất. Gần tương đương với

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Nếu một trong các lần lặp có khả năng là vô hạn, thì chức năng đó sẽ được bao bọc bằng thứ gì đó giới hạn số lượng lệnh gọi (ví dụ: hoặc ). Nếu không được chỉ định, giá trị điền mặc định là

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) --> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

Công thức Itertools

Phần này hiển thị các công thức để tạo bộ công cụ mở rộng bằng cách sử dụng các công cụ lặp hiện có làm khối xây dựng

Mục đích chính của công thức itertools là giáo dục. Các công thức cho thấy nhiều cách suy nghĩ khác nhau về các công cụ riêng lẻ - ví dụ:

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = list(range(r))
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Mục đích phụ của các công thức nấu ăn là để phục vụ như một lồng ấp. Các công cụ lặp

def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = list(range(r))
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)

def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = list(range(r))
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)

def combinations(iterable, r):
    pool = tuple(iterable)
    n = len(pool)
    for indices in permutations(range(n), r):
        if sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # running product
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # running maximum
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Amortize a 5% loan of 1000 with 4 annual payments of 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

Về cơ bản, tất cả các công thức này và nhiều, rất nhiều công thức khác có thể được cài đặt từ dự án more-itertools được tìm thấy trên Chỉ mục gói Python

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Nhiều công thức cung cấp hiệu suất cao giống như bộ công cụ cơ bản. Hiệu suất bộ nhớ vượt trội được duy trì bằng cách xử lý từng phần tử một thay vì đưa toàn bộ phần tử có thể lặp lại vào bộ nhớ cùng một lúc. Khối lượng mã được giữ ở mức nhỏ bằng cách liên kết các công cụ với nhau theo kiểu chức năng giúp loại bỏ các biến tạm thời. Tốc độ cao được duy trì bằng cách ưu tiên sử dụng các khối xây dựng “được véc tơ hóa” hơn là sử dụng các vòng lặp for và s làm phát sinh chi phí phiên dịch