Itertools có được tích hợp vào python không?

Python cung cấp một mô-đun tuyệt vời để tạo các trình vòng lặp của riêng bạn. Mô-đun tôi đang đề cập đến là itertools. Các công cụ do itertools cung cấp rất nhanh và hiệu quả về bộ nhớ. Bạn sẽ có thể sử dụng các khối xây dựng này để tạo các trình lặp chuyên biệt của riêng mình có thể được sử dụng để lặp hiệu quả

Trong bài viết này, bạn sẽ xem xét các ví dụ về từng khối xây dựng để khi kết thúc, bạn sẽ hiểu cách sử dụng chúng cho cơ sở mã của riêng mình

Hãy bắt đầu bằng cách xem xét một số trình vòng lặp vô hạn

Trình lặp vô hạn

Gói itertools đi kèm với ba trình lặp có thể lặp vô hạn. Điều này có nghĩa là khi bạn sử dụng chúng, bạn cần
hiểu rằng cuối cùng bạn sẽ cần phải thoát ra khỏi các vòng lặp này, nếu không bạn sẽ có một vòng lặp vô hạn.

Chúng có thể hữu ích để tạo số hoặc đạp xe qua các lần lặp có độ dài không xác định, chẳng hạn. Hãy bắt đầu tìm hiểu về các iterable thú vị này

đếm [bắt đầu = 0, bước = 1]

Trình lặp đếm sẽ trả về các giá trị cách đều nhau bắt đầu bằng số bạn nhập làm tham số bắt đầu của nó. Đếm cũng chấp nhận một tham số bước

Hãy cùng xem một ví dụ đơn giản

>>> from itertools import count
>>> for i in count[10]:
..     if i > 20: 
..         break
..     else:
..         print[i]
.. 
10
11
12
13
14
15
16
17
18
19
20

Tại đây bạn nhập số đếm từ itertools và bạn tạo một vòng lặp for. Bạn thêm một kiểm tra có điều kiện sẽ thoát ra khỏi vòng lặp nếu trình lặp vượt quá 20, nếu không, nó sẽ in ra vị trí của bạn trong trình lặp. Bạn sẽ lưu ý rằng đầu ra bắt đầu từ 10 vì đó là những gì bạn đã chuyển để tính là giá trị bắt đầu của chúng tôi

Một cách khác để giới hạn đầu ra của trình vòng lặp vô hạn này là sử dụng một mô-đun con khác từ itertools có tên là islice

Đây là cách

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Trong ví dụ này, bạn nhập islice và lặp lại số đếm bắt đầu từ 10 và kết thúc sau 5 mục. Như bạn có thể đoán, đối số thứ hai của islice là khi nào ngừng lặp lại. Nhưng nó không có nghĩa là "dừng lại khi tôi đến số 5". Thay vào đó, nó có nghĩa là “dừng lại khi bạn đạt đến năm lần lặp lại”

chu kỳ [có thể lặp lại]

Trình lặp chu trình từ itertools cho phép bạn tạo một trình vòng lặp sẽ quay vòng vô hạn qua một loạt các giá trị. Hãy chuyển cho nó một chuỗi 3 chữ cái và xem điều gì sẽ xảy ra

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Tại đây bạn tạo một vòng lặp for để lặp qua chu kỳ vô tận của ba chữ cái. XYZ. Tất nhiên, bạn không muốn thực sự quay vòng mãi mãi, vì vậy bạn thêm một bộ đếm đơn giản để thoát ra khỏi vòng lặp với

Bạn cũng có thể sử dụng tích hợp sẵn tiếp theo của Python để lặp qua các trình vòng lặp mà bạn tạo bằng itertools

>>> polys = ['triangle', 'square', 'pentagon', 'rectangle']
>>> iterator = cycle[polys]
>>> next[iterator]
'triangle'
>>> next[iterator]
'square'
>>> next[iterator]
'pentagon'
>>> next[iterator]
'rectangle'
>>> next[iterator]
'triangle'
>>> next[iterator]
'square'

Trong đoạn mã trên, bạn tạo một danh sách đa giác đơn giản và chuyển chúng vào chu kỳ. Bạn lưu iterator mới của chúng ta vào một biến và sau đó bạn chuyển biến đó sang hàm tiếp theo. Mỗi khi bạn gọi next, nó sẽ trả về giá trị tiếp theo trong iterator. Vì iterator này là vô hạn nên bạn có thể gọi next cả ngày mà không bao giờ hết item

lặp lại [đối tượng]

Các trình vòng lặp lặp lại sẽ trả về một đối tượng lặp đi lặp lại mãi mãi trừ khi bạn đặt đối số lần của nó. Nó khá giống với chu kỳ ngoại trừ việc nó không lặp đi lặp lại một tập hợp các giá trị

Hãy cùng xem một ví dụ đơn giản

>>> from itertools import repeat
>>> repeat[5, 5]
repeat[5, 5]
>>> iterator = repeat[5, 5]
>>> next[iterator]
5
>>> next[iterator]
5
>>> next[iterator]
5
>>> next[iterator]
5
>>> next[iterator]
5
>>> next[iterator]
Traceback [most recent call last]:
  Python Shell, prompt 21, line 1
builtins.StopIteration:

Ở đây bạn nhập lặp lại và yêu cầu nó lặp lại số 5 năm lần. Sau đó, bạn gọi next trên iterator mới của chúng tôi sáu lần để xem nó có hoạt động chính xác không. Khi bạn chạy mã này, bạn sẽ thấy rằng StopIteration tăng lên vì bạn đã hết giá trị trong trình vòng lặp của chúng tôi

Vòng lặp kết thúc

Hầu hết các trình vòng lặp mà bạn tạo bằng itertools không phải là vô hạn. Trong phần này, bạn sẽ nghiên cứu các vòng lặp hữu hạn của itertools. Để có được đầu ra có thể đọc được, bạn sẽ sử dụng loại danh sách tích hợp sẵn của Python

Nếu bạn không dùng list thì in ra sẽ chỉ nhận được một đối tượng itertools

tích lũy [có thể lặp lại]

Trình vòng lặp tích lũy sẽ trả về tổng tích lũy hoặc kết quả tích lũy của hàm hai đối số mà bạn có thể chuyển sang tích lũy. Giá trị mặc định của tích lũy là phép cộng, vì vậy hãy thử nhanh

>>> from itertools import accumulate
>>> list[accumulate[range[10]]]
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]

Ở đây chúng tôi nhập tích lũy và chuyển cho nó một dãy gồm 10 số, 0-9. Nó thêm lần lượt từng cái, vì vậy cái đầu tiên là 0, cái thứ hai là 0+1, cái thứ 3 là 1+2, v.v.

Bây giờ, hãy nhập mô-đun toán tử và thêm nó vào hỗn hợp

>>> import operator
>>> list[accumulate[range[1, 5], operator.mul]]
[1, 2, 6, 24]

Hàm này chấp nhận hai đối số để được nhân. Vì vậy, đối với mỗi lần lặp lại, nó sẽ nhân lên thay vì thêm [1x1=1, 1x2=2, 2x3=6, v.v.]

Tài liệu về tích lũy cho thấy một số ví dụ thú vị khác như khấu hao khoản vay hoặc mối quan hệ tuần hoàn hỗn loạn. Bạn chắc chắn nên xem xét những ví dụ đó vì chúng rất đáng để bạn dành thời gian

chuỗi [* iterables]

Trình lặp chuỗi sẽ thực hiện một loạt các lần lặp và về cơ bản làm phẳng chúng thành một lần lặp dài. Tôi thực sự gần đây đã cần sự hỗ trợ của nó trong một dự án mà tôi đang giúp đỡ. Về cơ bản, bạn đã có một danh sách với một số mục đã có trong đó và hai danh sách khác mà bạn muốn thêm vào danh sách gốc, nhưng bạn chỉ muốn nối thêm các mục trong mỗi danh sách vào danh sách gốc thay vì tạo một danh sách các danh sách

Ban đầu tôi đã thử một cái gì đó như thế này

>>> my_list = ['foo', 'bar']
>>> numbers = list[range[5]]
>>> cmd = ['ls', '/some/dir']
>>> my_list.extend[cmd, numbers]
>>> my_list
['foo', 'bar', ['ls', '/some/dir'], [0, 1, 2, 3, 4]]

Chà, nó không hoạt động theo cách tôi muốn. Mô-đun itertools cung cấp một cách thanh lịch hơn nhiều để làm phẳng các danh sách này thành một bằng cách sử dụng chuỗi

Những độc giả sắc sảo hơn của tôi có thể nhận thấy rằng thực sự có một cách khác mà bạn có thể hoàn thành điều tương tự mà không cần sử dụng itertools. Bạn có thể làm điều này để có được hiệu ứng tương tự

>>> my_list = ['foo', 'bar']
>>> my_list += cmd + numbers
>>> my_list
['foo', 'bar', 'ls', '/some/dir', 0, 1, 2, 3, 4]

Cả hai phương pháp này chắc chắn đều hợp lệ và trước khi tôi biết về chain, có lẽ tôi đã đi theo con đường này, nhưng tôi nghĩ chain là một giải pháp tao nhã và dễ hiểu hơn trong trường hợp cụ thể này

chuỗi. from_iterable[có thể lặp lại]

Bạn cũng có thể sử dụng phương thức chuỗi có tên from_iterable. Phương pháp này hoạt động hơi khác so với sử dụng chuỗi trực tiếp. Thay vì chuyển qua một loạt các lần lặp, bạn phải chuyển vào một danh sách lồng nhau

Hãy cùng xem

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Ở đây bạn nhập chuỗi như bạn đã làm trước đây. Bạn thử chuyển vào hai danh sách của chúng tôi nhưng cuối cùng bạn nhận được TypeError. Để khắc phục điều này, bạn thay đổi cuộc gọi của mình một chút sao cho bạn đặt cmd và số vào trong danh sách rồi chuyển danh sách lồng nhau đó sang from_iterable. Đó là một sự khác biệt tinh tế nhưng vẫn dễ sử dụng

nén [dữ liệu, bộ chọn]

Mô-đun con nén rất hữu ích để lọc lần lặp đầu tiên với lần lặp thứ hai. Điều này hoạt động bằng cách làm cho lần lặp thứ hai trở thành danh sách Booleans [hoặc số 1 và số 0 tương đương với cùng một thứ]

Đây là cách nó hoạt động

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Trong ví dụ này, bạn có một nhóm gồm bảy chữ cái và một danh sách năm Bool. Sau đó, bạn chuyển chúng vào chức năng nén. chức năng nén sẽ đi qua từng lần lặp tương ứng và kiểm tra lần đầu tiên so với lần thứ hai. Nếu cái thứ hai có giá trị True phù hợp thì nó sẽ được giữ lại. Nếu là Sai, thì mục đó sẽ bị loại

Vì vậy, nếu bạn nghiên cứu ví dụ trên, bạn sẽ nhận thấy rằng bạn có True ở vị trí thứ nhất, thứ ba và thứ tư tương ứng với A, C và D

dropwhile [vị ngữ, có thể lặp lại]

Có một iterator nhỏ gọn chứa trong itertools được gọi là dropwhile. Trình lặp nhỏ thú vị này sẽ loại bỏ các phần tử miễn là tiêu chí bộ lọc là True. Do đó, bạn sẽ không thấy bất kỳ đầu ra nào từ trình vòng lặp này cho đến khi vị từ trở thành Sai. Điều này có thể làm cho thời gian khởi động kéo dài, vì vậy đây là điều cần lưu ý

Hãy xem một ví dụ từ tài liệu của Python

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Tại đây, bạn nhập dữ liệu tạm thời và sau đó chuyển cho nó một câu lệnh lambda đơn giản. Hàm này sẽ trả về True nếu x nhỏ hơn 5. Nếu không nó sẽ trả về Sai. Hàm dropwhile sẽ lặp qua danh sách và chuyển từng phần tử vào lambda. Nếu lambda trả về True, thì giá trị đó sẽ bị loại bỏ. Khi bạn đạt đến số 6, lambda trả về Sai và bạn giữ lại số 6 và tất cả các giá trị theo sau nó

Tôi thấy hữu ích khi sử dụng một hàm thông thường trên lambda khi tôi đang học điều gì đó mới. Vì vậy, hãy lật ngược cái này và tạo một hàm trả về True nếu số lớn hơn 5

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Tại đây bạn tạo một hàm đơn giản trong trình thông dịch của Python. Chức năng này là vị ngữ hoặc bộ lọc của bạn. Nếu các giá trị bạn chuyển đến là True, thì chúng sẽ bị loại bỏ. Khi bạn đạt đến một giá trị nhỏ hơn 5, thì TẤT CẢ các giá trị sau và bao gồm cả giá trị đó sẽ được giữ lại, bạn có thể thấy điều này trong ví dụ trên

filterfalse[vị ngữ, có thể lặp lại]

Chức năng filterfalse từ itertools rất giống với dropwhile. Tuy nhiên, thay vì loại bỏ các giá trị khớp với True, filterfalse sẽ chỉ trả về những giá trị được đánh giá là Sai

Hãy sử dụng chức năng của chúng tôi từ phần trước để minh họa

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Tại đây bạn truyền hàm filterfalse và danh sách các số nguyên. Nếu số nguyên nhỏ hơn 5, nó được giữ nguyên. Còn không thì vứt đi. Bạn sẽ nhận thấy rằng kết quả của chúng tôi chỉ là 1, 2 và 3. Không giống như droptime, filterfalse sẽ kiểm tra từng và mọi giá trị đối với vị từ của chúng ta

nhóm [có thể lặp lại, khóa = Không]

Trình lặp nhóm sẽ trả về các khóa và nhóm liên tiếp từ trình lặp của bạn. Cái này hơi khó hiểu nếu không xem ví dụ. Vì vậy, chúng ta hãy xem xét một

Đặt đoạn mã sau vào trình thông dịch của bạn hoặc lưu nó vào một tệp

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Ở đây bạn nhập groupby và sau đó tạo danh sách các bộ dữ liệu. Sau đó, bạn sắp xếp dữ liệu sao cho hợp lý hơn khi xuất dữ liệu và nó cũng cho phép nhóm theo nhóm thực sự nhóm các mục một cách chính xác. Tiếp theo, bạn thực sự lặp qua trình vòng lặp được trả về bởi groupby sẽ cung cấp cho bạn khóa và nhóm. Cuối cùng, bạn lặp qua nhóm và in ra những gì trong đó

Nếu bạn chạy mã này, bạn sẽ thấy một cái gì đó như thế này

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Để giải trí, hãy thử thay đổi mã để bạn vượt qua phương tiện thay vì sorted_vehicles. Bạn sẽ nhanh chóng tìm hiểu lý do tại sao bạn nên sắp xếp dữ liệu trước khi chạy dữ liệu qua nhóm nếu bạn làm như vậy.

islice [có thể lặp lại, bắt đầu, dừng]

Bạn đã thực sự tìm hiểu về islice trong phần đếm. Nhưng ở đây bạn sẽ xem xét nó sâu hơn một chút. islice là một iterator trả về các phần tử đã chọn từ iterable. Đó là một tuyên bố không rõ ràng

Về cơ bản, những gì islice làm là lấy một lát theo chỉ mục của iterable của bạn [thứ bạn lặp lại] và trả về các mục đã chọn dưới dạng iterator. Thực tế có hai triển khai của islice. Có itertools. islice[iterable, stop] và sau đó có phiên bản islice phù hợp hơn với việc cắt lát Python thông thường. islice[có thể lặp lại, bắt đầu, dừng [, bước]]

Hãy xem phiên bản đầu tiên để xem nó hoạt động như thế nào

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Trong đoạn mã trên, bạn chuyển một chuỗi gồm sáu ký tự cho islice cùng với số 4 là đối số dừng. Điều này có nghĩa là iterator mà islice trả về sẽ có 4 mục đầu tiên từ chuỗi trong đó. Bạn có thể xác minh điều này bằng cách gọi next trên iterator của chúng tôi bốn lần, đó là những gì bạn làm ở trên. Python đủ thông minh để biết rằng nếu chỉ có hai đối số được truyền cho islice, thì đối số thứ hai là đối số dừng

Hãy thử đưa ra ba đối số để chứng minh rằng bạn có thể chuyển đối số bắt đầu và dừng cho nó. Công cụ đếm từ itertools có thể giúp chúng tôi minh họa khái niệm này

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Ở đây bạn chỉ cần gọi số đếm và yêu cầu islice bắt đầu từ số 3 và dừng khi đạt 15. Nó giống như thực hiện một lát cắt ngoại trừ việc bạn đang thực hiện nó với một trình vòng lặp và trả về một trình vòng lặp mới

starmap [chức năng, có thể lặp lại]

Công cụ starmap sẽ tạo một iterator có thể tính toán bằng hàm và iterable được cung cấp. Như tài liệu đã đề cập, "sự khác biệt giữa map[] và starmap[] tương đương với sự khác biệt giữa hàm[a,b] và hàm[*c]. "

Hãy xem một ví dụ đơn giản

>>> from itertools import islice
>>> for i in islice[count[10], 5]:
..     print[i]
.. 
10
11
12
13
14

Ở đây bạn tạo một hàm thêm đơn giản chấp nhận hai đối số. Tiếp theo, bạn tạo một vòng lặp for và gọi starmap với hàm là đối số đầu tiên của nó và một danh sách các bộ cho lần lặp. Sau đó, hàm starmap sẽ chuyển từng phần tử bộ vào hàm và trả về một trình lặp kết quả mà bạn in ra

mất thời gian [vị ngữ, lặp lại]

Hàm takewhile về cơ bản ngược lại với trình lặp dropwhile mà bạn đã xem xét trước đó. takewhile sẽ tạo một iterator chỉ trả về các phần tử từ iterable miễn là vị từ hoặc bộ lọc của chúng ta là True

Hãy thử một ví dụ đơn giản để xem nó hoạt động như thế nào

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Tại đây, bạn chạy takewhile bằng hàm lambda và danh sách. Đầu ra chỉ là hai số nguyên đầu tiên từ iterable của chúng tôi. Lý do là 1 và 4 đều nhỏ hơn 5, nhưng 6 lớn hơn. Vì vậy, khi takewhile nhìn thấy 6, điều kiện trở thành Sai và nó sẽ bỏ qua phần còn lại của các mục trong iterable

tee[có thể lặp lại, n=2]

Hàm tee sẽ tạo n trình vòng lặp từ một lần lặp duy nhất. Điều này có nghĩa là bạn có thể tạo nhiều iterator từ một iterable. Hãy xem xét một số mã giải thích về cách thức hoạt động của nó

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Tại đây bạn tạo một chuỗi gồm 5 chữ cái và chuyển nó tới tee. Vì tee mặc định là 2, nên bạn sử dụng nhiều phép gán để có được hai vòng lặp được trả về từ tee. Cuối cùng, bạn lặp qua từng trình vòng lặp và in ra nội dung của chúng. Như bạn có thể thấy, nội dung của chúng giống nhau

zip_longest[*iterables, fillvalue=None]

Trình lặp zip_longest có thể được sử dụng để nén hai lần lặp lại với nhau. Nếu các lần lặp không có cùng độ dài, thì bạn cũng có thể chuyển vào một giá trị điền. Hãy xem một ví dụ ngớ ngẩn dựa trên tài liệu về chức năng này

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Trong mã này, bạn nhập zip_longest và sau đó chuyển hai chuỗi để nén lại với nhau. Bạn có thể thấy rằng chuỗi đầu tiên dài 4 ký tự trong khi chuỗi thứ hai chỉ dài 2 ký tự. Bạn cũng đặt giá trị lấp đầy là “BLANK”. Khi bạn lặp lại điều này và in nó ra, bạn sẽ thấy rằng bạn nhận được các bộ dữ liệu được trả về

Hai bộ dữ liệu đầu tiên là sự kết hợp của các chữ cái đầu tiên và thứ hai từ mỗi chuỗi tương ứng. Hai cái cuối cùng đã chèn giá trị điền của bạn

Cần lưu ý rằng nếu [các] lần lặp được chuyển đến zip_longest có khả năng là vô hạn, thì bạn nên bọc hàm bằng thứ gì đó như islice để giới hạn số lượng lệnh gọi

Máy phát điện tổ hợp

Thư viện itertools chứa bốn trình vòng lặp có thể được sử dụng để tạo các kết hợp và hoán vị dữ liệu. Bạn sẽ đề cập đến các vòng lặp thú vị này trong phần này

kết hợp [lặp lại, r]

Nếu bạn có nhu cầu tạo các kết hợp, Python sẽ hỗ trợ bạn với itertools. kết hợp. Những kết hợp nào cho phép bạn làm là tạo một trình lặp từ một trình lặp có độ dài dài

Hãy cùng xem

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Khi bạn chạy chương trình này, bạn có thể nhận thấy rằng các kết hợp trả về các bộ. Để làm cho đầu ra này dễ đọc hơn một chút, hãy lặp lại trình vòng lặp của chúng ta và nối các bộ dữ liệu thành một chuỗi duy nhất

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Bây giờ dễ dàng hơn một chút để xem tất cả các kết hợp khác nhau. Lưu ý rằng hàm kết hợp thực hiện kết hợp của nó theo thứ tự sắp xếp từ điển, vì vậy nếu lần lặp của bạn được sắp xếp, thì các bộ dữ liệu kết hợp của bạn cũng sẽ được sắp xếp. Cũng đáng lưu ý là các kết hợp sẽ không tạo ra các giá trị lặp lại trong các kết hợp nếu tất cả các phần tử đầu vào là duy nhất

tổ hợp_with_replacement[có thể lặp lại, r]

Trình lặp tổ hợp_with_replacement rất giống với tổ hợp. Sự khác biệt duy nhất là nó sẽ thực sự tạo ra các kết hợp trong đó các phần tử lặp lại. Hãy thử một ví dụ từ phần trước để minh họa

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Như bạn có thể thấy, bây giờ bạn có bốn mục mới trong đầu ra của chúng tôi. WW, XX, YY và ZZ

sản phẩm[*iterables, repeat=1]

Gói itertools có một chức năng nhỏ gọn để tạo các sản phẩm Cartesian từ một loạt các lần lặp đầu vào. Vâng, chức năng đó là sản phẩm

Hãy xem nó hoạt động như thế nào

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Tại đây, bạn nhập sản phẩm và sau đó thiết lập danh sách các bộ dữ liệu mà bạn gán cho các mảng biến. Tiếp theo, bạn gọi sản phẩm với các mảng đó. Bạn sẽ nhận thấy rằng bạn gọi nó bằng cách sử dụng *arrays. Điều này sẽ khiến danh sách bị "bùng nổ" hoặc áp dụng cho chức năng sản phẩm theo thứ tự. Điều đó có nghĩa là bạn đang chuyển 3 đối số thay vì một đối số. Nếu bạn muốn, hãy thử gọi nó với dấu hoa thị được đặt trước mảng và xem điều gì sẽ xảy ra

hoán vị

Mô-đun con hoán vị của itertools sẽ trả về các hoán vị độ dài r liên tiếp của các phần tử từ lần lặp mà bạn cung cấp cho nó. Giống như chức năng kết hợp, hoán vị được phát ra theo thứ tự sắp xếp từ điển

Hãy cùng xem

>>> from itertools import cycle
>>> count = 0
>>> for item in cycle['XYZ']:
..     if count > 7:
..         break
..     print[item]
..     count += 1
.. 
X
Y
Z
X
Y
Z
X

Bạn sẽ nhận thấy rằng đầu ra dài hơn một chút so với đầu ra từ các kết hợp. Khi bạn sử dụng hoán vị, nó sẽ đi qua tất cả các hoán vị của chuỗi, nhưng nó sẽ không lặp lại các giá trị nếu các phần tử đầu vào là duy nhất

kết thúc

itertools là một bộ công cụ rất linh hoạt để tạo các trình vòng lặp. Bạn có thể sử dụng chúng để tự tạo các trình vòng lặp của riêng mình hoặc kết hợp với nhau. Tài liệu Python có rất nhiều ví dụ tuyệt vời mà bạn có thể nghiên cứu để cung cấp cho bạn ý tưởng về những gì có thể được thực hiện với thư viện có giá trị này

Itertools có được xây dựng bằng Python không?

Itertools có trong thư viện chuẩn Python không?

Python Itertools có được viết bằng C không?

Itertools có nhanh hơn các vòng lặp không?