Lặp lại hai lần trong danh sách hiểu

Trong Python bạn có thể có nhiều trình vòng lặp trong một danh sách hiểu, như

[(x,y) for x in a for y in b]

cho một số trình tự phù hợp a và b. Tôi biết về ngữ nghĩa vòng lặp lồng nhau của việc hiểu danh sách của Python.

Câu hỏi của tôi là: một trình lặp có thể hiểu được cái kia không? Nói cách khác: Tôi có thể có một cái gì đó như thế này:

[x for x in a for a in b]

trong đó giá trị hiện tại của vòng lặp bên ngoài là vòng lặp của bên trong?

Ví dụ, nếu tôi có một danh sách lồng nhau:

a=[[1,2],[3,4]]

biểu thức hiểu danh sách sẽ là gì để đạt được kết quả này:

[1,2,3,4]

?? (Xin vui lòng chỉ liệt kê câu trả lời hiểu, vì đây là những gì tôi muốn tìm hiểu).

Để trả lời câu hỏi của bạn với đề xuất của riêng bạn:

>>> [x for b in a for x in b] # Works fine

Trong khi bạn yêu cầu câu trả lời hiểu danh sách, tôi cũng chỉ ra itertools.chain ():

>>> from itertools import chain
>>> list(chain.from_iterable(a))
>>> list(chain(*a)) # If you're using python < 2.6

Tôi hy vọng điều này sẽ giúp người khác vì a,b,x,ytôi không có nhiều ý nghĩa với tôi! Giả sử bạn có một văn bản đầy câu và bạn muốn một mảng các từ.

# Without list comprehension
list_of_words = []
for sentence in text:
    for word in sentence:
       list_of_words.append(word)
return list_of_words

Tôi thích nghĩ về việc hiểu danh sách như kéo dài mã theo chiều ngang.

Hãy thử chia nó thành:

# List Comprehension 
[word for sentence in text for word in sentence]

Thí dụ:

>>> text = (("Hi", "Steve!"), ("What's", "up?"))
>>> [word for sentence in text for word in sentence]
['Hi', 'Steve!', "What's", 'up?']

Điều này cũng hoạt động cho máy phát điện

>>> text = (("Hi", "Steve!"), ("What's", "up?"))
>>> gen = (word for sentence in text for word in sentence)
>>> for word in gen: print(word)
Hi
Steve!
What's
up?

Gee, tôi đoán tôi đã tìm thấy anwser: Tôi đã không quan tâm đầy đủ về vòng lặp nào là bên trong và bên ngoài. Việc hiểu danh sách nên như sau:

[x for b in a for x in b]

để có được kết quả mong muốn và có, một giá trị hiện tại có thể là vòng lặp cho vòng lặp tiếp theo.

Thứ tự lặp có vẻ phản trực giác.

Lấy ví dụ: [str(x) for i in range(3) for x in foo(i)]

Hãy phân hủy nó:

def foo(i):
    return i, i + 0.5

[str(x)
    for i in range(3)
        for x in foo(i)
]

# is same as
for i in range(3):
    for x in foo(i):
        yield str(x)

ThomasH đã thêm một câu trả lời hay, nhưng tôi muốn chỉ ra điều gì xảy ra:

>>> a = [[1, 2], [3, 4]]
>>> [x for x in b for b in a]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined

>>> [x for b in a for x in b]
[1, 2, 3, 4]
>>> [x for x in b for b in a]
[3, 3, 4, 4]

Tôi đoán Python phân tích cú pháp hiểu danh sách từ trái sang phải. Điều này có nghĩa, forvòng lặp đầu tiên xảy ra sẽ được thực hiện đầu tiên.

"Vấn đề" thứ hai của vấn đề này là b"bị rò rỉ" ra khỏi danh sách hiểu. Sau khi hiểu danh sách thành công đầu tiên b == [3, 4].

Nếu bạn muốn giữ mảng đa chiều, người ta nên lồng các dấu ngoặc mảng. xem ví dụ dưới đây, nơi một được thêm vào mọi yếu tố.

>>> a = [[1, 2], [3, 4]]

>>> [[col +1 for col in row] for row in a]
[[2, 3], [4, 5]]

>>> [col +1 for row in a for col in row]
[2, 3, 4, 5]

Kỹ thuật bộ nhớ này giúp tôi rất nhiều:

[ <RETURNED_VALUE> <OUTER_LOOP1> <INNER_LOOP2> <INNER_LOOP3> ... <OPTIONAL_IF> ]

Và bây giờ bạn có thể nghĩ về R eturn + O uter-loop là R ight O rder duy nhất

Biết ở trên, thứ tự trong danh sách toàn diện thậm chí cho 3 vòng có vẻ dễ dàng:

c=[111, 222, 333]
b=[11, 22, 33]
a=[1, 2, 3]

print(
  [
    (i, j, k)                            # <RETURNED_VALUE> 
    for i in a for j in b for k in c     # in order: loop1, loop2, loop3
    if i < 2 and j < 20 and k < 200      # <OPTIONAL_IF>
  ]
)
[(1, 11, 111)]

bởi vì ở trên chỉ là một:

for i in a:                         # outer loop1 GOES SECOND
  for j in b:                       # inner loop2 GOES THIRD
    for k in c:                     # inner loop3 GOES FOURTH
      if i < 2 and j < 20 and k < 200:
        print((i, j, k))            # returned value GOES FIRST

để lặp lại một danh sách / cấu trúc lồng nhau, technic là như nhau: đối avới câu hỏi:

a = [[1,2],[3,4]]
[i2    for i1 in a      for i2 in i1]
which return [1, 2, 3, 4]

cho một cấp độ lồng nhau

a = [[[1, 2], [3, 4]], [[5, 6], [7, 8, 9]], [[10]]]
[i3    for i1 in a      for i2 in i1     for i3 in i2]
which return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

và như thế

Tôi cảm thấy điều này dễ hiểu hơn

[row[i] for row in a for i in range(len(a))]

result: [1, 2, 3, 4]

Ngoài ra, bạn có thể sử dụng cùng một biến cho thành viên của danh sách đầu vào hiện đang truy cập và cho thành phần bên trong thành viên này. Tuy nhiên, điều này thậm chí có thể làm cho nó nhiều hơn (danh sách) không thể hiểu được.

input = [[1, 2], [3, 4]]
[x for x in input for x in x]

Đầu tiên for x in inputđược đánh giá, dẫn đến một danh sách thành viên của đầu vào, sau đó, Python đi qua phần thứ hai for x in xtrong đó giá trị x được ghi đè bởi phần tử hiện tại mà nó đang truy cập, sau đó đầu tiên xxác định những gì chúng ta muốn trả về.

Hàm flatten_nlevel này gọi đệ quy list1 lồng nhau để chuyển sang một cấp. Thử thứ này đi

def flatten_nlevel(list1, flat_list):
    for sublist in list1:
        if isinstance(sublist, type(list)):        
            flatten_nlevel(sublist, flat_list)
        else:
            flat_list.append(sublist)

list1 = [1,[1,[2,3,[4,6]],4],5]

items = []
flatten_nlevel(list1,items)
print(items)

đầu ra:

[1, 1, 2, 3, 4, 6, 4, 5]