Theo tài liệu Python, Itertools là một mô-đun Python cung cấp một bộ công cụ nhanh và tiết kiệm bộ nhớ để làm việc với các trình vòng lặp Python. Những công cụ này có thể được sử dụng riêng lẻ hoặc kết hợp và cho phép bạn tạo cũng như làm việc với các trình vòng lặp một cách chính xác và hiệu quả theo cách nhanh chóng và tiết kiệm bộ nhớ.
Mô-đun Itertools bao gồm các chức năng giúp làm việc với các trình vòng lặp dễ dàng hơn, đặc biệt là khi xử lý các tập dữ liệu lớn. Các hàm Itertools có thể chạy trên các trình vòng lặp hiện có, tạo ra các trình vòng lặp Python phức tạp hơn nữa.
Ngoài ra, Itertools có thể giúp các nhà phát triển giảm thiểu lỗi khi làm việc với các trình vòng lặp và viết mã sạch hơn, dễ đọc và dễ bảo trì hơn.
Dựa trên chức năng được cung cấp bởi các trình vòng lặp trong mô-đun Itertools, chúng có thể được chia thành các loại sau:
# 1. Vòng lặp vô hạn
Đây là các trình vòng lặp cho phép bạn làm việc với các chuỗi vô hạn và chạy vòng lặp vô thời hạn nếu không có điều kiện để thoát khỏi vòng lặp. Các trình vòng lặp như vậy rất hữu ích khi mô phỏng các vòng lặp vô hạn hoặc tạo ra một chuỗi không giới hạn. Itertools có ba trình vòng lặp vô hạn bao gồm count(), Cycle() và Repeat().
#2. Vòng lặp tổ hợp
Các trình vòng lặp tổ hợp bao gồm các hàm có thể được sử dụng để hoạt động trên tích Descartes và để thực hiện các kết hợp và hoán vị của các phần tử có trong một vòng lặp. Đây là những hàm thiết yếu khi bạn đang cố gắng tìm mọi cách có thể để sắp xếp hoặc kết hợp các phần tử trong một iterable. Itertools có bốn trình vòng lặp tổ hợp. Chúng là sản phẩm(), hoán vị(), kết hợp() và kết hợp_with_replacement().
#3. Trình vòng lặp kết thúc bằng chuỗi đầu vào ngắn nhất
Đây là các trình lặp kết thúc được sử dụng trên các chuỗi hữu hạn và tạo ra kết quả đầu ra dựa trên loại hàm được sử dụng. Ví dụ về các trình vòng lặp kết thúc như vậy là: Accept(), chain(), chain.from_iterable(), nén(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile ( ), tee() và zip_longest().
Chúng ta hãy xem các hàm Itertools khác nhau hoạt động như thế nào tùy thuộc vào loại của chúng:
Vòng lặp vô hạn
Ba vòng lặp vô hạn bao gồm:
# 1. để đếm()
count(start, step) tạo ra một chuỗi số vô hạn bắt đầu từ một giá trị bắt đầu. Hàm này có hai đối số tùy chọn: bắt đầu và bước. Đối số bắt đầu đặt nơi chuỗi số sẽ bắt đầu. Theo mặc định, nó bắt đầu bằng 0nếu không có giá trị ban đầu được đưa ra. step đặt sự khác biệt giữa mỗi số liên tiếp. Giá trị bước mặc định là 1.
import itertools
# count starting at 4, making steps of 2
for i in itertools.count(4, 2):
# condition to end the loop avoiding infinite looping
if i == 14:
break
else:
print(i) # output - 4, 6, 8, 10, 12Lối ra
4 6 8 10 12
#2. xe đạp()
Hàm Cycle(iterable) lấy một iterable làm đối số rồi lặp qua iterable đó, cho phép bạn truy cập các phần tử theo thứ tự iterable theo thứ tự chúng xuất hiện.
Ví dụ, nếu chúng ta vượt qua [“red”, “green”, “yellow”] tới Cycle(), trong chu kỳ đầu tiên chúng ta sẽ có quyền truy cập vào “red”; trong chu kỳ thứ hai, chúng ta sẽ có quyền truy cập vào “xanh”, sau đó là “vàng”. Trong chu kỳ thứ tư, vì tất cả các phần tử đã hết trong khả năng lặp lại, chúng ta sẽ bắt đầu với “màu đỏ” và tiếp tục vô thời hạn.
Bằng cách gọi chu kỳ(), bạn lưu trữ kết quả của nó trong một biến để tạo một trình vòng lặp duy trì trạng thái của nó. Nhờ đó, chu kỳ không bắt đầu lại mỗi lần, chỉ cấp quyền truy cập vào phần tử đầu tiên.
import itertools
colors = ["red", "green", "yellow"]
# pass in colors into cycle()
color_cycle = itertools.cycle(colors)
print(color_cycle)
# range used to stop the infinite loop once we've printed 7 times
# next() used to return the next item from the iterator
for i in range(7):
print(next(color_cycle))Lối ra:
red green yellow red green yellow red
#3. lặp lại()
lặp lại(elem,n) nhận hai đối số, mục cần lặp lại (elem) và số lần mục đó được lặp lại (n). Mục bạn muốn lặp lại có thể là một giá trị duy nhất hoặc một mục có thể lặp lại. Nếu bạn không chỉ định n, mục này sẽ được lặp lại vô thời hạn.
import itertools
for i in itertools.repeat(10, 3):
print(i)Lối ra:
10 10 10
Vòng lặp tổ hợp
Các trình vòng lặp tổ hợp bao gồm:
# 1. sản phẩm()
Product() là một hàm tính tích Descartes của khả năng lặp được truyền cho nó. Nếu chúng ta có hai bộ lặp, ví dụ x = {7,8} i = {1,2,3}, tích Descartes x và y sẽ chứa tất cả các tổ hợp có thể có của các phần tử zx và y, trong đó phần tử đầu tiên đến từ x và phần tử thứ hai đến từ y. Tích Descartes x và y trong trường hợp này là [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
sản phẩm() nhận một tham số tùy chọn gọi là lặp lại, được sử dụng để tính toán tích Descartes có thể lặp lại với chính nó. lặp lại chỉ định số lần lặp lại cho từng phần tử của các lần lặp đầu vào khi tính tích Descartes.
Ví dụ: gọi sản phẩm (‘ABCD’, lặp lại =2) đưa ra các kết hợp như (‘A’, ‘A’), (‘A’, ‘B’), (‘A’, ‘C’), v.v. NA. Nếu lặp lại đã được đặt thành 3hàm sẽ trả về các kết hợp như (‘A’, ‘A’, ‘A’), (‘A’, ‘A’, ‘B’), (‘A’, ‘A’, ‘C’), ( “A”, “A”, “D”), v.v.
from itertools import product
# product() with the optional repeat argument
print("product() with the optional repeat argument ")
print(list(product('ABC', repeat = 2)))
# product with no repeat
print("product() WITHOUT an optional repeat argument")
print(list(product([7,8], [1,2,3])))Lối ra
product() with the optional repeat argument
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
product() WITHOUT an optional repeat argument
[(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)]#2. hoán vị()
permutations(iterable, group_size) trả về tất cả các hoán vị có thể có của iterable được truyền cho nó. Một hoán vị biểu thị số cách sắp xếp các phần tử trong một tập hợp. permutations() nhận một đối số group_size tùy chọn. Nếu group_size không được chỉ định, các hoán vị được tạo sẽ có cùng kích thước với độ dài của iterable được truyền cho hàm
import itertools
numbers = [1, 2, 3]
sized_permutations = list(itertools.permutations(numbers,2))
unsized_permuatations = list(itertools.permutations(numbers))
print("Permutations with a size of 2")
print(sized_permutations)
print("Permutations with NO size argument")
print(unsized_permuatations)Lối ra
Permutations with a group size of 2 [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)] Permutations with NO size argument [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
#3. kết hợp()
Combines(iterable, size) trả về tất cả các kết hợp có thể có của một iterable có độ dài nhất định từ các phần tử của iterable được truyền cho hàm. Đối số kích thước chỉ định kích thước của mỗi kết hợp.
Kết quả được sắp xếp. Sự kết hợp hơi khác so với hoán vị. Đối với các hoán vị, thứ tự quan trọng, nhưng đối với các kết hợp, thứ tự không quan trọng. Ví dụ, trong [A, B, C] tồn tại 6 hoán vị: AB, AC, BA, BC, CA, CB, nhưng chỉ 3 tổ hợp AB, AC, BC.
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations(numbers,2))
size3_combination = list(itertools.combinations(numbers, 3))
print("Combinations with a size of 2")
print(size2_combination)
print("Combinations with a size of 3")
print(size3_combination)Lối ra:
Combinations with a size of 2 [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)] Combinations with a size of 3 [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
#4. kết hợp_with_replacement()
Combines_with_replacement(iterable, size) tạo ra tất cả các kết hợp có thể lặp lại của một độ dài nhất định từ các lần lặp được truyền cho hàm và cho phép các phần tử lặp lại trong các kết hợp đầu ra. Kích thước xác định kích thước của các kết hợp được tạo ra.
Hàm này khác với tổ hợp() ở chỗ nó tạo ra các kết hợp trong đó một mục có thể được lặp lại nhiều lần. Ví dụ: bạn có thể nhận được sự kết hợp như (1,1) mà bạn không thể có được bằng tổ hợp().
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations_with_replacement(numbers,2))
print("Combinations_with_replacement => size 2")
print(size2_combination)Lối ra
Combinations_with_replacement => size 2 [(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
Hoàn thành các vòng lặp
Điều này bao gồm các trình vòng lặp như:
# 1. sưu tầm()
tích lũy (iterable, function) nhận một đối số có thể lặp lại và một đối số tùy chọn thứ hai là một hàm. Sau đó, nó trả về kết quả tích lũy của việc áp dụng hàm trong mỗi lần lặp trên các lần lặp. Nếu không có hàm nào được thông qua, phép cộng sẽ được thực hiện và kết quả tích lũy sẽ được trả về.
import itertools
import operator
numbers = [1, 2, 3, 4, 5]
# Accumulate the sum of numbers
accumulated_val = itertools.accumulate(numbers)
accumulated_mul = itertools.accumulate(numbers, operator.mul)
print("Accumulate with no function")
print(list(accumulated_val))
print("Accumulate with multiplication")
print(list(accumulated_mul))Lối ra:
Accumulate with no function [1, 3, 6, 10, 15] Accumulate with multiplication [1, 2, 6, 24, 120]
#2. xích()
chain(iterable_1, iterable_2, …) lấy nhiều lần lặp và xâu chuỗi chúng lại với nhau, tạo ra một lần lặp duy nhất chứa các giá trị từ các lần lặp được truyền cho hàm chain()
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] # Chain letters and numbers together chained_iterable = list(itertools.chain(letters, numbers, colors)) print(chained_iterable)
Lối ra:
['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']
#3. string.z_iterable()
chain.from_iterable(iterable) hàm này tương tự như chain(). Tuy nhiên, nó khác với chuỗi ở chỗ nó chỉ lấy một vòng lặp chứa vòng lặp con và xâu chuỗi chúng lại với nhau.
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] iterable = ['hello',colors, letters, numbers] chain = list(itertools.chain.from_iterable(iterable)) print(chain)
Lối ra:
['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]
#4. Nén()
nén(data, selectors) nhận hai đối số, dữ liệu có thể lặp lại và bộ chọn có thể lặp lại và chứa các giá trị boolean đúng và sai. 1, 0 cũng có thể được sử dụng thay thế cho các giá trị boolean đúng và sai. nén() sau đó lọc dữ liệu được truyền vào bằng cách sử dụng các mục thích hợp được chuyển vào bộ chọn.
Các giá trị trong dữ liệu tương ứng với true hoặc 1 trong bộ chọn được chọn trong khi những cái khác tương ứng với sai hoặc 0 bị bỏ qua. Nếu bạn truyền ít giá trị boolean trong bộ chọn hơn số mục trong dữ liệu, tất cả các mục ngoại trừ giá trị boolean được truyền trong bộ chọn sẽ bị bỏ qua
import itertools # data has 10 items data = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'] # passing in 9 selector items selectors = [True, False, 1, False, 0, 1, True, False, 1] # Select elements from data based on selectors filtered_data = list(itertools.compress(data, selectors)) print(filtered_data)
Lối ra:
['A', 'C', 'F', 'G', 'I']
#5. thả rơi()
dropwhile(function, Sequence) nhận vào một hàm có điều kiện đúng hoặc sai và một chuỗi các giá trị. Sau đó nó loại bỏ tất cả các giá trị cho đến khi điều kiện trả về Sai. Khi điều kiện được đánh giá là sai, các mục còn lại sẽ được đưa vào kết quả, cho dù chúng trả về Đúng hay Sai.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.dropwhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Lối ra:
[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]
#6. lọc sai()
filterfalse(function, Sequence) nhận vào một hàm có điều kiện đánh giá là đúng hoặc sai và một chuỗi. Sau đó nó trả về các giá trị từ dãy không thỏa mãn điều kiện trong hàm.
import itertools numbers = [1, 2, 3, 4, 2, 3 5, 6, 5, 8, 1, 2, 3, 6, 2, 7, 4, 3] # Filter elements for which condition is False filtered_numbers = list(itertools.filterfalse(lambda x: x < 4, numbers)) print(filtered_numbers)
Lối ra:
[4, 5, 6, 5, 8, 6, 7, 4]
#7. nhóm theo()
groupby(iterable, key) lấy một iterable và một key, sau đó tạo một iterator trả về các key và nhóm liên tiếp. Để tính năng này hoạt động, phép lặp được truyền cho nó phải được sắp xếp theo cùng một hàm khóa. Chức năng chính của máy tính là giá trị khóa cho từng mục trong vòng lặp.
import itertools
input_list = [("Domestic", "Cow"), ("Domestic", "Dog"), ("Domestic", "Cat"),("Wild", "Lion"), ("Wild", "Zebra"), ("Wild", "Elephant")]
classification = itertools.groupby(input_list,lambda x: x[0])
for key,value in classification:
print(key,":",list(value))Lối ra:
Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]#8. islice()
islice(iterable, start, stop, step) cho phép bạn phân chia một iterable bằng cách sử dụng các giá trị start, stop và step được truyền vào. Đối số bước là tùy chọn. Việc đếm bắt đầu từ 0và vị trí trên số dừng không được tính đến.
import itertools
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
# Select elements within a range
selected_numbers = list(itertools.islice(numbers, 2, 10))
selected_numbers_step= list(itertools.islice(numbers, 2, 10,2))
print("islice without setting a step value")
print(selected_numbers)
print("islice with a step value of 2")
print(selected_numbers_step)Lối ra:
islice without setting a step value [3, 4, 5, 6, 7, 8, 9, 10] islice with a step value of 2 [3, 5, 7, 9]
#9. theo cặp()
pairwise(iterable) trả về các cặp chồng chéo liên tiếp được lấy từ iterable được truyền cho nó theo thứ tự chúng xuất hiện trong iterable. Nếu iterable được truyền cho nó có ít hơn hai giá trị, thì kết quả từ pairwise() sẽ trống.
from itertools import pairwise numbers = [1, 2, 3, 4, 5, 6, 7, 8] word = 'WORLD' single = ['A'] print(list(pairwise(numbers))) print(list(pairwise(word))) print(list(pairwise(single)))
Lối ra:
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]#10. bản đồ sao()
starmap(function, iterable) là một hàm được sử dụng thay cho map() khi các tham số đối số đã được nhóm thành các bộ dữ liệu. startmap() áp dụng hàm cho các phần tử của iterable được truyền cho nó. Một iterable nên có các phần tử được nhóm thành các bộ dữ liệu.
import itertools iter_starmap = [(123, 63, 13), (5, 6, 52), (824, 51, 9), (26, 24, 16), (14, 15, 11)] print (list(itertools.starmap(min, iter_starmap)))
Lối ra:
[13, 5, 9, 16, 11]
#11. một lúc()
takewhile(function, iterable) hoạt động theo cách ngược lại với dropwhile(). takewhile() lấy một hàm có điều kiện để đánh giá và lặp lại. Sau đó, nó chứa tất cả các lần lặp thỏa mãn điều kiện trong hàm cho đến khi trả về Sai. Khi trả về Sai, tất cả các mục sau trong vòng lặp sẽ bị bỏ qua.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.takewhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Lối ra:
[1, 2, 3, 4]
#12. tee()
tee(iterable, n) nhận một iterable và trả về nhiều iterator độc lập. Số vòng lặp được trả về được đặt bởi n, theo mặc định 2.
import itertools numbers = [1, 2, 3, 4, 5] # Create two independent iterators from numbers iter1, iter2 = itertools.tee(numbers, 2) print(list(iter1)) print(list(iter2))
Lối ra:
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
#13. zip_longest()
zip_longest(iterables, fillvalue) cần nhiều lần lặp và một giá trị điền. Sau đó, nó trả về một trình lặp tổng hợp các phần tử từ mỗi trình vòng lặp được truyền cho nó. Nếu các vòng lặp không có cùng độ dài, các giá trị bị thiếu sẽ được thay thế bằng một giá trị đệm được truyền cho hàm cho đến khi hết vòng lặp dài nhất.
import itertools
names = ['John', 'mathew', 'mary', 'Alice', 'Bob', 'Charlie', 'Fury']
ages = [25, 30, 12, 13, 42]
# Combine name and ages, filling in missing ages with a dash
combined = itertools.zip_longest(names, ages, fillvalue="-")
for name, age in combined:
print(name, age)Lối ra:
John 25 mathew 30 mary 12 Alice 13 Bob 42 Charlie - Fury -
Ứng dụng
Python itertools là bộ công cụ quan trọng dành cho nhà phát triển Python. Python itertools được sử dụng rộng rãi trong lập trình chức năng, xử lý và chuyển đổi dữ liệu, lọc và chọn dữ liệu, nhóm và tổng hợp, kết hợp lặp, tổ hợp và khi làm việc với các chuỗi vô hạn.
Là một nhà phát triển Python, bạn sẽ học được rất nhiều điều từ việc học itertools, vì vậy hãy sử dụng bài viết này để làm quen với Python Itertools.
