LƯU Ý. Mã sẽ bị chia nhỏ và không được thụt lề chính xác liên quan đến từng phần của nó, vì vậy tôi khuyên bạn nên xem mã trong chính câu hỏi/tài liệu itertools [cùng mã]
Đã hơn 7 năm kể từ khi câu hỏi này được hỏi. Ồ. Bản thân tôi cũng quan tâm đến vấn đề này và những lời giải thích ở trên mặc dù rất hữu ích nhưng không thực sự phù hợp với tôi, vì vậy đây là phần tóm tắt mà tôi đã thực hiện cho chính mình.
Vì cuối cùng tôi đã hiểu được nó [hoặc ít nhất là tôi nghĩ là mình hiểu], tôi nghĩ sẽ có ích nếu đăng "phiên bản" giải thích này, phòng trường hợp có nhiều người giống tôi hơn. vì vậy hãy bắt đầu.
def combinations[iterable, r]:
pool = tuple[iterable]
n = len[pool]
Trong phần đầu tiên này, chỉ cần tạo một tuple của iterable và lấy độ dài của iterable. Những thứ này sẽ hữu ích sau này
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
Điều này cũng khá đơn giản - Nếu độ dài của tổ hợp cần thiết lớn hơn nhóm phần tử của chúng tôi, thì chúng tôi không thể tạo tổ hợp hợp lệ [bạn không thể tạo tổ hợp 5 phần tử từ 4 phần tử], do đó, chúng tôi chỉ cần dừng thực thi bằng cách trả về . Chúng tôi cũng tạo kết hợp đầu tiên [các phần tử r đầu tiên từ lần lặp của chúng tôi]
Phần tiếp theo này phức tạp hơn một chút, vì vậy hãy đọc kỹ
while True:
for i in reversed[range[r]]:
if indices[i] != n - [r - i]:
break
"""
The job of the while loop is to increment the indices one after
the other, and print out all the possible element combinations based
off all the possible valid indice combinations.
This for loop's job is to make sure we never over-increment any values.
In order for us to not run into any errors, the incremention of
the last element of the indice list must stop when it reaches one-less
than the length of our element list, otherwise we'll run into an index error
[trying to access an indice out of the list range].
How do we do that?
The range function will give us values cascading down from r-1 to 0
[r-1, r-2, r-3, .. , 0]
So first and foremost, the [r-1]st indice must not be greater than [n-1]
[remember, n is the length of our element pool], as that is the largest indice.
We can then write
Indices[r - 1] < n - 1
Moreover, because we'll stop incrementing the r-1st indice when we reach it's
maximum value, we must also stop incrementing the [r-2]nd indice when we reach
it's maximum value. What's the [r-2]nd indice maximum value?
Since we'll also be incrementing the [r-1]st indice based on the
[r-2]nd indice, and because the maximum value of the [r-1]st
indice is [n-1], plus we want no duplicates, the maximum value the
[r-2]nd indice can reach would be [n-2].
This trend will continue. more generally:
Indices[r - k] < n - k
Now, since r - k is an arbitrary index generated by the reversed range function,
namely [i], we can substitute:
r - k = i -----> k = r - i
Indices[r - k] < n - k -----> Indices[i] < n - [r - i]
That's our limit - for any indice i we generate, we must break the
increment if this inequality { Indices[i] < n - [r - i] } is no longer
true.
[In the documentation it's written as [Indice[i] != i + n - r], and it
means the exact same thing. I simply find this version easier to visualize
and understand].
"""
else:
return
"""
When our for loop runs out - which means we've gone through and
maximized each element in our indice list - we've gone through every
single combination, and we can exit the function.
It's important to distinct that the else statement is not linked to
the if statement in this case, but rather to the for loop. It's a
for-else statement, meaning "If you've finished iterating through the
entire loop, execute the else statement".
"""
Nếu chúng tôi đã cố gắng thoát ra khỏi vòng lặp for, điều này có nghĩa là chúng tôi có thể tăng chỉ số của mình một cách an toàn để có được kết hợp tiếp theo [dòng đầu tiên bên dưới]. Vòng lặp for bên dưới đảm bảo rằng mỗi khi chúng tôi bắt đầu trên một chỉ mục mới, chúng tôi sẽ đặt lại các chỉ mục khác về giá trị nhỏ nhất có thể của chúng, để không bỏ lỡ bất kỳ kết hợp nào
ví dụ: nếu chúng tôi không làm điều đó, thì khi chúng tôi đạt đến điểm mà chúng tôi phải tiếp tục, giả sử chúng tôi có [0, 1, 2, 3, 4] và các chỉ số kết hợp là [0, 1, 4] . Thay vào đó, sau khi chúng tôi tăng [1 -> 2], chúng tôi cập nhật các chỉ số sau dựa trên đó. [4 -> 3] và khi chúng ta chạy lại vòng lặp while, chúng ta sẽ tăng 3 trở lại 4 [tham khảo phần trước]
Lưu ý rằng chúng tôi không bao giờ tăng các chỉ số trước đó, để không tạo các bản sao
Và cuối cùng, đối với mỗi lần lặp, câu lệnh suất tạo ra tổ hợp phần tử tương ứng với tổ hợp chỉ số hiện tại
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Và đúng như tài liệu nêu rõ, bởi vì chúng tôi đang xử lý các vị trí, một sự kết hợp duy nhất là duy nhất dựa trên vị trí của các phần tử trong lần lặp, không phải giá trị của chúng