Tại sao Itertool được sử dụng trong Python?

Các loại vòng lặp

Các loại trình vòng lặp khác nhau được cung cấp bởi mô-đun này là

• Trình vòng lặp vô hạn
• vòng lặp tổ hợp
• Chấm dứt vòng lặp

1. Trình vòng lặp vô hạn

Iterator trong python là một đối tượng có thể được sử dụng với một vòng lặp để duyệt qua một iterable. Danh sách, bộ, từ điển và bộ dữ liệu là một số trình vòng lặp được sử dụng rộng rãi trong python. Không nhất thiết một trình vòng lặp phải cạn kiệt nó có thể chứa vô số phần tử, các loại trình vòng lặp như vậy được gọi là Trình vòng lặp vô hạn

đếm, chu kỳ và lặp lại là ba loại trình lặp vô hạn trong python

1. đếm [bắt đầu, bước] Trình lặp này in giá trị từ đầu và tiếp tục vô tận. Nó nhận một đối số bước tùy chọn, nếu được cung cấp sẽ bỏ qua số lượng giá trị đã cho. Nếu các đối số này không được cung cấp, thì theo mặc định, giá trị bắt đầu là 0 và bước là 1

Thí dụ

    import itertools
   
    for i in itertools.count[3, 5]:
        if i == 33:
            break
        else:
            print[i]
đầu ra
Trong chương trình trên, chúng tôi lặp qua một trình lặp đếm có start = 3 và step = 5. Trong lần lặp đầu tiên, giá trị của i là 3. Trong bước tiếp theo, chúng tôi thêm 5. Do đó giá trị của i bây giờ là 8. Điều này sẽ tiếp tục vô hạn, nhưng chúng tôi đã thêm một khoảng ngắt khi i == 33
chu kỳ [có thể lặp lại] Trình lặp này lấy một đối số có thể lặp lại làm đối số và in nó vô thời hạn theo cách tuần hoàn
Thí dụ
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
đầu ra
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
Trong chương trình trên, chúng tôi đã tạo một danh sách l. Thông thường, một vòng lặp for đi qua một vòng lặp có thể lặp lại cho đến khi nó cạn kiệt. Vì danh sách này có 2 mục nên vòng lặp for sẽ chỉ lặp lại 2 lần. Nhưng trong trường hợp này, chúng tôi đã sử dụng trình vòng lặp vô hạn Cycle[], trong trường hợp này khi hết danh sách, chúng tôi bắt đầu lại từ đầu
lặp lại [đối tượng, lần] Trình lặp này lấy một đối tượng và lặp lại nó vô hạn. Phải mất một tham số lần tùy chọn được sử dụng làm điều kiện kết thúc. Thí dụ
    import itertools
   
    for i in itertools.repeat["scaler", 5]:
        print[i]
đầu ra

  

    scaler
    scaler
    scaler
    scaler
    scaler
Trong chương trình trên, chúng tôi đã tạo một trình vòng lặp chỉ lặp lại bộ chia tỷ lệ vô hạn. Nhưng bởi vì chúng tôi cũng đã cho nó một đối số times = 5, chúng tôi đã giới hạn đầu ra ở mức 5 lần
2. vòng lặp tổ hợp
Hoán vị, Tổ hợp và Tích Đề các là một số trình tạo đệ quy còn được gọi là trình lặp Tổ hợp được sử dụng để đơn giản hóa các cấu trúc tổ hợp phức tạp
Product[], Permutations[], Combinations[] và Combinations_with_replacement[] là 4 trình lặp Combinataric
Product[] Iterator này được sử dụng để tính tích cartesian của chuỗi đầu vào của iterables. Nó nhận một đối số tùy chọn lặp lại, xác định số lần lặp lại cho tích của một lần lặp với chính nó. Đầu ra ở dạng các bộ dữ liệu được sắp xếp
Thí dụ
    from itertools import product
   
    print["Using repeat:"]
    print[list[product[['Scaler', 'Academy'], repeat = 2]]]

    print["Cartesian product of the iterables:"]
    print[list[product[[3, 4],'AB']]]
đầu ra
    Using repeat:
    [['Scaler', 'Scaler'], ['Scaler', 'Academy'], ['Academy', 'Scaler'], ['Academy', 'Academy']]

    Cartesian product of the iterables:
    [[3, 'A'], [3, 'B'], [4, 'A'], [4, 'B']]
Permutations[iterable, group_size] Iterator này được sử dụng để tạo ra tất cả các hoán vị có thể có của một iterable. Mỗi phần tử được quyết định là duy nhất dựa trên vị trí của nó chứ không phải giá trị của nó. Permutations[] lấy iterable và group_size làm hai trong số các đối số của nó, nếu giá trị group_size không được cung cấp hoặc là Không, thì group_size sẽ lấy độ dài của iterable làm giá trị của nó
Thí dụ
    import itertools
   
    print [list[itertools.permutations[['Scaler','Academy'], 2]]]

    print[list[itertools.permutations[range[3]]]]
đầu ra
________số 8
Kết hợp [có thể lặp lại, kích thước nhóm] Trình lặp này được sử dụng để tạo tất cả các kết hợp duy nhất có thể có cho khả năng lặp được truyền dưới dạng đối số cùng với kích thước nhóm được chỉ định theo thứ tự được sắp xếp
Thí dụ
    import itertools
   
    data = ['array', 'Linked List', 'Trees']

    print[list[itertools.combinations[data, 2]]]

    print[list[itertools.combinations['ABC', 2]]]
đầu ra
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
0
Combinations_with_replacement[iterable, group_size] Trình lặp này tương tự như tổ hợp[], nhưng trình lặp này cho phép các phần tử riêng lẻ trong một lần lặp được lặp lại nhiều lần
Thí dụ
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
1
đầu ra
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
2
3. Chấm dứt vòng lặp
Các loại trình vòng lặp này được sử dụng để hoạt động với các chuỗi đầu vào nhỏ và tạo đầu ra bằng cách sử dụng chức năng được triển khai trong trình vòng lặp
Có nhiều loại trình vòng lặp kết thúc khác nhau
tích lũy [lặp lại, chức năng]
Trình lặp hữu hạn này lấy một hàm có thể lặp lại và một hàm làm đối số và hàm được triển khai ở mỗi lần lặp để trả về kết quả tích lũy. Nếu không có chức năng nào được chuyển đến trình vòng lặp tích lũy, thì việc bổ sung được thực hiện theo mặc định

  

Thí dụ
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
3
đầu ra
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
4
Trong ví dụ đầu tiên, không có chức năng nào được truyền, do đó, phép cộng liên tiếp được thực hiện trên lần lặp đã truyền. Trong khi ở ví dụ thứ hai, toán tử. mul lấy hai số và nhân chúng liên tiếp để in kết quả tích lũy
chain[iterable1, iterable2] Trình vòng lặp hữu hạn này hiển thị tất cả các giá trị được truyền dưới dạng các lần lặp ở dạng chuỗi
Thí dụ
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
5
đầu ra
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
6
chuỗi. from_iterable[iterable1] Trình vòng lặp hữu hạn này được triển khai tương tự như chain[] nhưng ở đây chỉ có một bộ chứa bộ lặp được truyền thay vì nhiều
Thí dụ
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
7
đầu ra
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
6
nén[có thể lặp lại, bộ chọn] Trình lặp hữu hạn này lọc giá trị từ khả năng lặp đã truyền dựa trên danh sách boolean được truyền dưới dạng đối số thứ hai. Các giá trị tương ứng với 1 hoặc True được chọn trong khi tất cả các giá trị còn lại đều bị bỏ qua
Thí dụ
    import itertools
   
    # to prevent it from running indefinitely
    count = 0

    l = ['Scaler', 'Academy']

    for i in itertools.cycle[l]:
        # break out of loop when count > 7
        if count > 7:
            break
        else:
            print[i]
            # increment count
            count += 1
9
đầu ra
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
0
dropwhile[hàm, chuỗi] Trình lặp hữu hạn này loại bỏ các phần tử chuỗi miễn là hàm được truyền trả về True, nhưng một khi hàm trả về Sai, tất cả các phần tử còn lại sau đó sẽ được in
Thí dụ
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
1
đầu ra
Trong chương trình trên, lệnh dropwhile[] loại bỏ từng phần tử khi nó nhỏ hơn 4. Khi nó gặp một phần tử không nhỏ hơn 4, nó sẽ trả về tất cả các phần tử còn lại. Đó là lý do tại sao phần tử 2 cuối cùng cũng được in
filterfalse[hàm, trình tự] Trình vòng lặp hữu hạn này chỉ in những giá trị mà hàm đã truyền trả về Sai
Thí dụ
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
2
đầu ra

  

islice[iterable, start, stop, step] Trình vòng lặp hữu hạn này cho phép người dùng cắt phần có thể lặp được truyền dựa trên ba đối số start, stop, step khác
Thí dụ
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
3
đầu ra
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
4
Chương trình trên thực hiện islice[] để cắt danh sách đã truyền bắt đầu từ phần tử thứ 0 cho đến phần tử thứ 6 cùng với việc thực hiện bước 2
starmap[function, iterable] Trình vòng lặp hữu hạn này tính toán giá trị hàm trên các đối số của vòng lặp đã truyền
Thí dụ
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
5
đầu ra
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
6
takewhile[function, iterable] Trình vòng lặp hữu hạn này ngược lại với dropwhile[], vì nó in các giá trị đó từ iterable mà hàm đã truyền trả về True cho đến khi hàm trở thành false
Thí dụ
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
7
đầu ra
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
8
tee[iterator, count] Trình lặp hữu hạn này chia trình vòng lặp đã truyền thành một số lượng các trình vòng lặp độc lập. Giá trị mặc định của đếm là 2
Thí dụ
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
    Scaler
    Academy
9
đầu ra
    import itertools
   
    for i in itertools.repeat["scaler", 5]:
        print[i]
0
zip_longest[*iterables, fillvalue] Trình lặp hữu hạn này in các giá trị bằng cách tổng hợp chúng từ mỗi lần lặp. Nếu bất kỳ lần lặp nào đã cạn kiệt hoàn toàn, các giá trị còn lại sẽ được lấp đầy bởi giá trị được cung cấp cho tham số fillvalue. Giá trị mặc định cho fillvalue là Không có
Thí dụ
    import itertools
   
    for i in itertools.repeat["scaler", 5]:
        print[i]
1
đầu ra
    import itertools
   
    for i in itertools.repeat["scaler", 5]:
        print[i]
2