Hướng dẫn python opposite of zip - python đối diện với zip

lst1, lst2 = zip(*zipped_list)

nên cung cấp cho bạn danh sách giải nén.

*zipped_list Giải nén đối tượng zipped_list. Sau đó, nó chuyển tất cả các bộ dữ liệu từ đối tượng zipped_list sang zip, chỉ đóng gói chúng trở lại như khi bạn truyền chúng vào.

vì thế nếu:

a = [1,2,3]
b = [4,5,6]

Sau đó

a = [1,2,3]
b = [4,5,6]

0 cung cấp cho bạn:

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

và *zipped_list cho bạn trở lại

(1,4), (2,5), (3,6)

Zipping mà với

a = [1,2,3]
b = [4,5,6]

2 cung cấp cho bạn hai bộ sưu tập:

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

> Cho một loạt các mảng, nếu tôi muốn tạo bộ dữ liệu, đó là iszip (mảng). Điều gì sẽ xảy ra nếu tôi muốn làm điều ngược lại: phá vỡ một bộ dữ liệu và ứng dụng các giá trị thành các mảng đã cho: MAP (append, mảng, tupl) ngoại trừ không có unbound compend () (list.append () không tồn tại, phải không?).

list.append tồn tại (thử hương vị trường hợp thấp hơn). > Không có thêm (), tôi buộc phải viết một vòng lặp rõ ràng (chậm): cho (a, v) trong zip (mảng, tupl): a.Append (v)

Ngoại trừ điều đó về mặt kỹ thuật không đối lập với zip. Ngược lại sẽ là một bộ dữ liệu đơn chiều:

x = [1,2,3,4,5]
y = [10,20,30,40,50]
points = zip(x,y)
points

def unzip (zipped): "" "Cho một chuỗi các chuỗi kích thước kích thước, tạo ra một bộ dữ liệu đại diện cho mỗi chỉ mục trong đối tượng bị kéo.

[(1, 10), (2, 20), (3, 30), (4, 40), (5, 50)]

>> Zipped = Zip ((1, 2, 3), (4, 5, 6)) >>

>> Giải nén (Zipped)

. Chỉ số = phạm vi (LEN (Zipped [0])) return tuple (Tuple (cặp [index] cho cặp trong zipped) cho chỉ mục trong các chỉ số)

[(1, 2, 3, 4, 5), (10, 20, 30, 40, 50)]

Đây có lẽ không phải là mã mã hiệu quả nhất cho việc này nhưng đây dường như là hành vi chính xác cho đối diện với ZIP và nó sẽ mở rộng quy mô tốt.

>> DESTS = [[], []] >> unzip_extend (Dests, Zipped) >> Dests

import random
rand = lambda: random.gauss(mu=1, sigma=1)
points = [(rand(), rand()) for i in xrange(1000)]

# Make the graph square
fig = plt.figure()
fig.set_size_inches(7,7)

# The scatter function takes an x-list and a y-list, NOT a list of points
(x, y) = zip(*points)

scatter(x,y)
show()

>> Giải nén = zip (*có khóa) được giải nén
zip(arrays). What if I want to do the opposite: break a tuple up and
append the values to given arrays:
map(append, arrays, tupl)
except there is no unbound append() (List.append() does not exist,
right?).

[(1, 2, 3), (4, 5, 6)]
for (a, v) in zip(arrays, tupl):
a.append(v)

Gọn gàng và hoàn toàn khó hiểu, phải không? :-)

-

17 tháng 12 '07 #11
igor

Matt Nordhoff đã viết: [Snip]

> Như Paddy đã viết, Zip là giải nén riêng của nó: >>> Zipped = Zip ((1, 2, 3), (4, 5, 6))

>> Giải nén = zip (*có khóa) được giải nén
zip(arrays). What if I want to do the opposite: break a tuple up and
append the values to given arrays:
map(append, arrays, tupl)
except there is no unbound append() (List.append() does not exist,
right?).

[(1, 2, 3), (4, 5, 6)]
for (a, v) in zip(arrays, tupl):
a.append(v)

Gọn gàng và hoàn toàn khó hiểu, phải không? :-)

-

17 tháng 12 '07 #11
igor

Matt Nordhoff đã viết: [Snip]
sample input & output?

> Như Paddy đã viết, Zip là giải nén riêng của nó: >>> Zipped = Zip ((1, 2, 3), (4, 5, 6))
http://paddy3118.blogspot.com/2007/0...in-python.html
Will help.

>>> Giải nén = zip (*có khóa) được giải nén

Có một giải pháp tốt hơn?

Tôi đã không nghĩ về zip () đối xứng như thế. Rất tuyệt...

>> Giải nén = zip (*có khóa) được giải nén
zip(arrays). What if I want to do the opposite: break a tuple up and
append the values to given arrays:
map(append, arrays, tupl)
except there is no unbound append() (List.append() does not exist,
right?).

[(1, 2, 3), (4, 5, 6)]
for (a, v) in zip(arrays, tupl):
a.append(v)

Gọn gàng và hoàn toàn khó hiểu, phải không? :-)

-

17 tháng 12 '07 #11
igor

Matt Nordhoff đã viết: [Snip]

> Như Paddy đã viết, Zip là giải nén riêng của nó: >>> Zipped = Zip ((1, 2, 3), (4, 5, 6))

>>> Giải nén = zip (*có khóa) được giải nén

Có một giải pháp tốt hơn?
map(list.append, a, (1,2))

Tôi đã không nghĩ về zip () đối xứng như thế. Rất tuyệt...

Giàu có

17 tháng 12 '07 #12

Chủ đề thảo luận này đã đóng

Tôi đã không nghĩ về zip () đối xứng như thế. Rất tuyệt...

Giàu có

17 tháng 12 '07 #12

Chủ đề thảo luận này đã đóng

Tôi đã không nghĩ về zip () đối xứng như thế. Rất tuyệt...

Giàu có

17 tháng 12 '07 #12
Gary Herron

Chủ đề thảo luận này đã đóng

Câu trả lời đã bị vô hiệu hóa cho cuộc thảo luận này.

Cho một loạt các mảng, nếu tôi muốn tạo bộ dữ liệu, có zip (mảng). Điều gì sẽ xảy ra nếu tôi muốn làm điều ngược lại: Break a Tuple Up và nối các giá trị vào các mảng đã cho: MAP (append, mảng, tupl) ngoại trừ không có accover expend () (list.append () không tồn tại, phải không?) .
zip(arrays). What if I want to do the opposite: break a tuple up and
append the values to given arrays:
map(append, arrays, tupl)
except there is no unbound append() (List.append() does not exist,
right?).

Không có phần phụ (), tôi buộc phải viết một vòng lặp rõ ràng (chậm): cho (a, v) trong zip (mảng, tupl): a.

Tôi giả sử sử dụng một biến chỉ mục thay vào đó sẽ không nhanh hơn nhiều.

Có một giải pháp tốt hơn?
Apparently it does. Here's how *not* to use it to do what you want:

Cảm ơn, Igor
tupl = tuple("ab")
map(lambda alist, x: alist.append(x), arrays, tupl)

Tôi đã không nghĩ về zip () đối xứng như thế. Rất tuyệt...

Giàu có

[[1, 2, 3, 4, 'A'], [101, 102, 103, 104, 'B']]]]

Nó hoạt động, nhưng khó hiểu và khó hiểu, và Lambda có thể làm cho nó chậm. Đừng làm theo cách đó.
probably makes it slow. Don't do it that way.

Không có phần phụ (), tôi buộc phải viết một vòng lặp rõ ràng (chậm): cho (a, v) trong zip (mảng, tupl): a.
for (a, v) in zip(arrays, tupl):
a.append(v)

Bạn có chắc nó chậm không? So với những gì? Đối với hồ sơ, đây là vòng lặp rõ ràng:
For the record, here's the explicit loop:

>> mảng = [[1, 2, 3, 4], [101, 102, 103, 104]] tupl = tuple ("ab") zip (mảng, tupl)
tupl = tuple("ab")
zip(arrays, tupl)

[([1, 2, 3, 4], 'A'), ([101, 102, 103, 104], 'B')]]

>> cho (a, v) trong zip (mảng, tupl):

.... A.Append (v) ....
....

>> mảng

[[1, 2, 3, 4, 'a'], [101, 102, 103, 104, 'b']] Tôi nghĩ rằng bạn đang làm cho nó quá phức tạp. Tại sao sử dụng zip ()?
I think you're making it too complicated. Why use zip()?

>> mảng = [[1, 2, 3, 4], [101, 102, 103, 104]] tupl = tuple ("ab") cho i, alist trong liệt kê (mảng):
tupl = tuple("ab")
for i, alist in enumerate(arrays):

.... alist.append (tupl [i]) ....
....

>> mảng

[[1, 2, 3, 4, 'A'], [101, 102, 103, 104, 'B']]]]

[[1, 2, 3, 4, 'a'], [101, 102, 103, 104, 'b']] Tôi nghĩ rằng bạn đang làm cho nó quá phức tạp. Tại sao sử dụng zip ()?
Steven

>> mảng = [[1, 2, 3, 4], [101, 102, 103, 104]] tupl = tuple ("ab") cho i, alist trong liệt kê (mảng):

.... alist.append (tupl [i]) ....

- Steven

>>>arrays = [[1, 2, 3, 4], [101, 102, 103, 104]] tupl = tuple("ab")
map(lambda alist, x: alist.append(x), arrays, tupl)

15 tháng 12 '07 #4

Vào Thứ Bảy, ngày 15 tháng 12 năm 2007 06:46:44 +0000, Steven D'Aprano đã viết:

[[1, 2, 3, 4, 'A'], [101, 102, 103, 104, 'B']]]]

Đây là cách * không * sử dụng nó để làm những gì bạn muốn: >>> mảng = [[1, 2, 3, 4], [101, 102, 103, 104]] TUPL = TUPLE ("AB") Bản đồ ( Lambda alist, x: alist.append (x), mảng, tupl)
probably makes it slow. Don't do it that way.

[Không, không]

>>> mảng

Nó hoạt động, nhưng khó hiểu và khó hiểu, và Lambda có thể làm cho nó chậm. Đừng làm theo cách đó.
the lambda out makes the map() based solution marginally faster than the
explicit loop, but I don't believe that the gain in speed is worth the
loss in readability.

Như Gary Herron chỉ ra, bạn không cần phải sử dụng Lambda:
0.4 second versus 0.5 second for the explicit loop. For smaller arrays,
the results are similar.)

Bản đồ (list.append, mảng, tupl)
Steven.

sẽ làm việc. Tôi vẫn duy trì rằng đây là cách sai đối với nó: lấy Lambda ra làm cho giải pháp dựa trên bản đồ () nhanh hơn so với vòng lặp rõ ràng, nhưng tôi không tin rằng mức tăng tốc độ đáng để mất khả năng đọc.

.

- Steven.
here is what I found:
from array import array
from time import time

15 tháng 12 '07 #5
for r in recs:
for i,v in enumerate(r):
cols[i].append(v)

Chào các bạn,
for r in recs:
for v,c in zip(r, cols):
c.append(v)

Cảm ơn vì sự giúp đỡ. Tôi đã thử chạy các tùy chọn khác nhau và đây là những gì tôi tìm thấy: từ mảng nhập mảng từ thời gian nhập
for r in recs:
map(list.append, cols, r)

def f1 (recs, cols): for r in recs: for i, v in enumerate (r): cols [i] .append (v)
return zip(*recs)

def f2 (recs, cols): cho r trong recs: cho v, c trong zip (r, cols): c.Append (v)

def F3 (recs, cols): cho r trong recs: map (list.append, cols, r)
t = time()
f1(records, columns)
print 'f1: ', time()-t

def f4 (recs): return zip (*recs)
t = time()
f2(records, columns)
print 'f2: ', time()-t

Records = [Tuple (phạm vi (10)) cho i trong xrange (1000000)]
t = time()
f3(records, columns)
print 'f3: ', time()-t

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f1 (bản ghi, cột) in 'f1:', thời gian ()-t
columns = f4(records)
print 'f4: ', time()-t

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f2 (bản ghi, cột) in 'f2:', thời gian ()-t
f2: 5.06787180901
f3: 4.04700708389
f4: 19.13633203506

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f3 (bản ghi, cột) in 'f3:', thời gian ()-t
and cool but it doesn't seem to scale.

t = thời gian () cột = f4 (bản ghi) in 'f4:', thời gian ()-t
initialization doesn't work:
columns = ([],)*10
apparently you end up with 10 copies of the same list.

F1: 5.10132408142 F2: 5.06787180901 F3: 4.04700708389 F4: 19.13633203506
memory). I can still use array.append but it's a little slower so the
difference between f1-f3 gets even smaller. f4 is not an option with
arrays.

Vì vậy, có một số lợi ích trong việc sử dụng MAP (list.append). F4 rất thông minh và mát mẻ nhưng dường như nó không quy mô.

Ngẫu nhiên, tôi phải mất một thời gian để tìm ra lý do tại sao việc khởi tạo sau không hoạt động: cột = ([],)*10 Rõ ràng bạn kết thúc với 10 bản sao của cùng một danh sách.

.

- Steven.
here is what I found:
from array import array
from time import time

15 tháng 12 '07 #5
for r in recs:
for i,v in enumerate(r):
cols[i].append(v)

Chào các bạn,
for r in recs:
for v,c in zip(r, cols):
c.append(v)

Cảm ơn vì sự giúp đỡ. Tôi đã thử chạy các tùy chọn khác nhau và đây là những gì tôi tìm thấy: từ mảng nhập mảng từ thời gian nhập
for r in recs:
map(list.append, cols, r)

def f1 (recs, cols): for r in recs: for i, v in enumerate (r): cols [i] .append (v)
return zip(*recs)

def f2 (recs, cols): cho r trong recs: cho v, c trong zip (r, cols): c.Append (v)

def F3 (recs, cols): cho r trong recs: map (list.append, cols, r)
t = time()
f1(records, columns)
print 'f1: ', time()-t

def f4 (recs): return zip (*recs)
t = time()
f2(records, columns)
print 'f2: ', time()-t

Records = [Tuple (phạm vi (10)) cho i trong xrange (1000000)]
t = time()
f3(records, columns)
print 'f3: ', time()-t

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f1 (bản ghi, cột) in 'f1:', thời gian ()-t
columns = f4(records)
print 'f4: ', time()-t

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f2 (bản ghi, cột) in 'f2:', thời gian ()-t
f2: 5.06787180901
f3: 4.04700708389
f4: 19.13633203506

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f3 (bản ghi, cột) in 'f3:', thời gian ()-t
and cool but it doesn't seem to scale.

t = thời gian () cột = f4 (bản ghi) in 'f4:', thời gian ()-t
initialization doesn't work:
columns = ([],)*10
apparently you end up with 10 copies of the same list.

F1: 5.10132408142 F2: 5.06787180901 F3: 4.04700708389 F4: 19.13633203506

F1: 5.10132408142 F2: 5.06787180901 F3: 4.04700708389 F4: 19.13633203506
memory). I can still use array.append but it's a little slower so the
difference between f1-f3 gets even smaller. f4 is not an option with
arrays.

15 tháng 12 '07 #7

Vào ngày 15 tháng 12, 4:45 sáng, Gary Herron

đã viết:

Chào các bạn,

Cảm ơn vì sự giúp đỡ. Tôi đã thử chạy các tùy chọn khác nhau, và đây là những gì tôi tìm thấy:
here is what I found:

Từ mảng nhập mảng từ thời gian nhập thời gian
from time import time

def f1 (recs, cols): for r in recs: for i, v in enumerate (r): cols [i] .append (v)
for r in recs:
for i,v in enumerate(r):
cols[i].append(v)

def f2 (recs, cols): cho r trong recs: cho v, c trong zip (r, cols): c.Append (v)
for r in recs:
for v,c in zip(r, cols):
c.append(v)

def F3 (recs, cols): cho r trong recs: map (list.append, cols, r)
for r in recs:
map(list.append, cols, r)

def f4 (recs): return zip (*recs)
return zip(*recs)

Records = [Tuple (phạm vi (10)) cho i trong xrange (1000000)]

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f1 (bản ghi, cột) in 'f1:', thời gian ()-t
t = time()
f1(records, columns)
print 'f1: ', time()-t

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f2 (bản ghi, cột) in 'f2:', thời gian ()-t
t = time()
f2(records, columns)
print 'f2: ', time()-t

cột = tuple ([] cho i trong xrange (10)) t = thời gian () f3 (bản ghi, cột) in 'f3:', thời gian ()-t
t = time()
f3(records, columns)
print 'f3: ', time()-t

t = thời gian () cột = f4 (bản ghi) in 'f4:', thời gian ()-t
columns = f4(records)
print 'f4: ', time()-t

F1: 5.10132408142 F2: 5.06787180901 F3: 4.04700708389 F4: 19.13633203506
f2: 5.06787180901
f3: 4.04700708389
f4: 19.13633203506

Vì vậy, có một số lợi ích trong việc sử dụng MAP (list.append). F4 rất thông minh và mát mẻ nhưng dường như nó không quy mô.
and cool but it doesn't seem to scale.

Ngẫu nhiên, tôi phải mất một thời gian để tìm ra lý do tại sao việc khởi tạo sau không hoạt động: cột = ([],)*10 Rõ ràng bạn kết thúc với 10 bản sao của cùng một danh sách.
initialization doesn't work:
columns = ([],)*10
apparently you end up with 10 copies of the same list.

Đúng. Một gotcha nổi tiếng ở Python và Câu hỏi thường gặp. Cuối cùng, trong trường hợp của tôi, các cột đầu ra là các mảng số nguyên (để lưu bộ nhớ). Tôi vẫn có thể sử dụng Array.Append nhưng nó chậm hơn một chút để sự khác biệt giữa F1-F3 thậm chí còn nhỏ hơn. F4 không phải là một tùy chọn với các mảng.

Finally, in my case the output columns are integer arrays (to save
memory). I can still use array.append but it's a little slower so the
difference between f1-f3 gets even smaller. f4 is not an option with
arrays.

Nếu bạn muốn một câu trả lời khác. Ngược lại với zip (danh sách) là zip (* list_of_tuples)
list_of_tuples)

Đó là: Danh sách == zip (zip (* danh sách))
lists == zip(zip(* lists))

Tôi không biết về tốc độ của nó mặc dù so với các đề xuất khác.

Matt

15 tháng 12 '07 #8

ig**************@gmail đã viết:

Bản đồ (nối, mảng, tupl) ngoại trừ không có acplound append () (list.append () không tồn tại, phải không?).
except there is no unbound append() (List.append() does not exist,
right?).

Er, không, nhưng list.append không:

>> Danh sách.Append

def f2 (recs, cols): cho r trong recs: cho v, c trong zip (r, cols): c.Append (v)

Vì vậy, bạn sẽ có thể làm

Bản đồ (list.append, mảng, tupl)

Với điều kiện bạn biết rằng tất cả các yếu tố của 'mảng' là danh sách thực tế.
actual lists.

- Greg
Greg

15 tháng 12 '07 #9

ig**************@gmail đã viết:

Bản đồ (nối, mảng, tupl) ngoại trừ không có acplound append () (list.append () không tồn tại, phải không?).
zip(arrays). What if I want to do the opposite: break a tuple up and
append the values to given arrays:
map(append, arrays, tupl)
except there is no unbound append() (List.append() does not exist,
right?).

Er, không, nhưng list.append không:

>> Danh sách.Append
for (a, v) in zip(arrays, tupl):
a.append(v)

Ngoại trừ điều đó về mặt kỹ thuật không đối lập với zip. Ngược lại sẽ là một bộ dữ liệu đơn chiều:
be a tuple of single-dimensional tuples:

Vì vậy, bạn sẽ có thể làm
"""
Given a sequence of size-sized sequences, produce a tuple of tuples
that represent each index within the zipped object.

Bản đồ (list.append, mảng, tupl)

Với điều kiện bạn biết rằng tất cả các yếu tố của 'mảng' là danh sách thực tế.
zipped

- Greg

15 tháng 12 '07 #9

Cho một loạt các mảng, nếu tôi muốn tạo bộ dữ liệu, có zip (mảng). Điều gì sẽ xảy ra nếu tôi muốn làm điều ngược lại: Break a Tuple Up và nối các giá trị vào các mảng đã cho: MAP (append, mảng, tupl) ngoại trừ không có accover expend () (list.append () không tồn tại, phải không?) .
"""
if len(zipped) < 1:
raise ValueError, 'At least one item is required for unzip.'
indices = range(len(zipped[0]))
return tuple(tuple(pair[index] for pair in zipped)
for index in indices)

list.append tồn tại (thử hương vị trường hợp thấp hơn).
would seem to be the correct behavior for the opposite of zip and it
should scale well.

Không có phần phụ (), tôi buộc phải viết một vòng lặp rõ ràng (chậm): cho (a, v) trong zip (mảng, tupl): a.
what I think you're asking for:

Ngoại trừ điều đó về mặt kỹ thuật không đối lập với zip. Ngược lại sẽ là một bộ dữ liệu đơn chiều:
"""
Appends the unzip versions of zipped into dests. This avoids an
unnecessary allocation.

Bản đồ (list.append, mảng, tupl)

Với điều kiện bạn biết rằng tất cả các yếu tố của 'mảng' là danh sách thực tế.
zipped

- Greg

15 tháng 12 '07 #9
unzip_extend(dests, zipped)
dests

Cho một loạt các mảng, nếu tôi muốn tạo bộ dữ liệu, có zip (mảng). Điều gì sẽ xảy ra nếu tôi muốn làm điều ngược lại: Break a Tuple Up và nối các giá trị vào các mảng đã cho: MAP (append, mảng, tupl) ngoại trừ không có accover expend () (list.append () không tồn tại, phải không?) .
"""
if len(zipped) < 1:
raise ValueError, 'At least one item is required for unzip.'
for index in range(len(zipped[0])):
dests[index].extend(pair[index] for pair in zipped)

list.append tồn tại (thử hương vị trường hợp thấp hơn).
pretty fast. Not that it's truly meaningful, here's timeit on my 2GHz
laptop:

Không có phần phụ (), tôi buộc phải viết một vòng lặp rõ ràng (chậm): cho (a, v) trong zip (mảng, tupl): a.
range(1024))' 'unzip.unzip_extend([[], []], zipped)'
1000 loops, best of 3: 510 usec per loop

Ngoại trừ điều đó về mặt kỹ thuật không đối lập với zip. Ngược lại sẽ là một bộ dữ liệu đơn chiều:

def unzip (zipped): "" "Cho một chuỗi các chuỗi kích thước kích thước, tạo ra một bộ dữ liệu đại diện cho mỗi chỉ mục trong đối tượng bị kéo.
range(1024))' 'unzip.unzip(zipped)'
1000 loops, best of 3: 504 usec per loop

Thí dụ:

>> Zipped = Zip ((1, 2, 3), (4, 5, 6))

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

>> Giải nén (Zipped)

. Chỉ số = phạm vi (LEN (Zipped [0])) return tuple (Tuple (cặp [index] cho cặp trong zipped) cho chỉ mục trong các chỉ số)
zip(arrays). What if I want to do the opposite: break a tuple up and
append the values to given arrays:
map(append, arrays, tupl)
except there is no unbound append() (List.append() does not exist,
right?).

list.append tồn tại (thử hương vị trường hợp thấp hơn). > Không có thêm (), tôi buộc phải viết một vòng lặp rõ ràng (chậm): cho (a, v) trong zip (mảng, tupl): a.Append (v)

>Without append(), I am forced to write a (slow) explicit loop:
for (a, v) in zip(arrays, tupl):
a.append(v)

Ngoại trừ điều đó về mặt kỹ thuật không đối lập với zip. Ngược lại sẽ là một bộ dữ liệu đơn chiều:
be a tuple of single-dimensional tuples:

def unzip (zipped): "" "Cho một chuỗi các chuỗi kích thước kích thước, tạo ra một bộ dữ liệu đại diện cho mỗi chỉ mục trong đối tượng bị kéo.
"""
Given a sequence of size-sized sequences, produce a tuple of tuples
that represent each index within the zipped object.

Thí dụ:

>> Zipped = Zip ((1, 2, 3), (4, 5, 6)) >>
>>zipped

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

>> Giải nén (Zipped)

. Chỉ số = phạm vi (LEN (Zipped [0])) return tuple (Tuple (cặp [index] cho cặp trong zipped) cho chỉ mục trong các chỉ số)
"""
if len(zipped) < 1:
raise ValueError, 'At least one item is required for unzip.'
indices = range(len(zipped[0]))
return tuple(tuple(pair[index] for pair in zipped)
for index in indices)

Đây có lẽ không phải là mã mã hiệu quả nhất cho việc này nhưng đây dường như là hành vi chính xác cho đối diện với ZIP và nó sẽ mở rộng quy mô tốt.
would seem to be the correct behavior for the opposite of zip and it
should scale well.

Việc sửa đổi ở trên với Danh sách.extend sẽ tạo ra một biến thể gần hơn với những gì tôi nghĩ bạn đang yêu cầu:
what I think you're asking for:

def unzip_extend (Dests, Zipped): "" "Bổ số các phiên bản giải nén của Zipped vào DOTS. Điều này tránh được sự phân bổ không cần thiết.
"""
Appends the unzip versions of zipped into dests. This avoids an
unnecessary allocation.

Thí dụ:

>> Zipped = Zip ((1, 2, 3), (4, 5, 6)) >>
>>zipped

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

>> Giải nén (Zipped)
>>unzip_extend(dests, zipped)
>>dests

. Chỉ số = phạm vi (LEN (Zipped [0])) return tuple (Tuple (cặp [index] cho cặp trong zipped) cho chỉ mục trong các chỉ số)
"""
if len(zipped) < 1:
raise ValueError, 'At least one item is required for unzip.'
for index in range(len(zipped[0])):
dests[index].extend(pair[index] for pair in zipped)

Đây có lẽ không phải là mã mã hiệu quả nhất cho việc này nhưng đây dường như là hành vi chính xác cho đối diện với ZIP và nó sẽ mở rộng quy mô tốt.
pretty fast. Not that it's truly meaningful, here's timeit on my 2GHz
laptop:

Việc sửa đổi ở trên với Danh sách.extend sẽ tạo ra một biến thể gần hơn với những gì tôi nghĩ bạn đang yêu cầu:
range(1024))' 'unzip.unzip_extend([[], []], zipped)'
1000 loops, best of 3: 510 usec per loop

def unzip_extend (Dests, Zipped): "" "Bổ số các phiên bản giải nén của Zipped vào DOTS. Điều này tránh được sự phân bổ không cần thiết.

>> DESTS = [[], []] >> unzip_extend (Dests, Zipped) >> Dests
range(1024))' 'unzip.unzip(zipped)'
1000 loops, best of 3: 504 usec per loop

[[1, 2, 3], [4, 5, 6]] "" "Nếu len (zipped) <1: nâng giá trị, 'ít nhất một mục là bắt buộc để giải nén.' Đối với chỉ mục trong phạm vi (LEN (Zipped [0])): Dests [Index] .extend (cặp [INDEX] cho cặp trong Zipped)

Điều này sẽ hoạt động khá tốt, vì mở rộng với sự hiểu biết là khá nhanh. Không phải là nó thực sự có ý nghĩa, đây là thời gian trên máy tính xách tay 2GHz của tôi:

bash -3.1 $ python -m thời gian nhập thời gian -s 'nhập khẩu; Zipped = zip (phạm vi (1024), phạm vi (1024)) '' unzip.unzip_extend ([], []], zipped) '1000 vòng, tốt nhất 3: 510 USEC mỗi vòng lặp
zipped

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

>> Giải nén (Zipped)
unzipped

. Chỉ số = phạm vi (LEN (Zipped [0])) return tuple (Tuple (cặp [index] cho cặp trong zipped) cho chỉ mục trong các chỉ số)

Đây có lẽ không phải là mã mã hiệu quả nhất cho việc này nhưng đây dường như là hành vi chính xác cho đối diện với ZIP và nó sẽ mở rộng quy mô tốt.

Việc sửa đổi ở trên với Danh sách.extend sẽ tạo ra một biến thể gần hơn với những gì tôi nghĩ bạn đang yêu cầu:
--

def unzip_extend (Dests, Zipped): "" "Bổ số các phiên bản giải nén của Zipped vào DOTS. Điều này tránh được sự phân bổ không cần thiết.

>> DESTS = [[], []] >> unzip_extend (Dests, Zipped) >> Dests
[snip]

[[1, 2, 3], [4, 5, 6]] "" "Nếu len (zipped) <1: nâng giá trị, 'ít nhất một mục là bắt buộc để giải nén.' Đối với chỉ mục trong phạm vi (LEN (Zipped [0])): Dests [Index] .extend (cặp [INDEX] cho cặp trong Zipped)
As Paddy wrote, zip is its own unzip:

>>>zipped = zip((1, 2, 3), (4, 5, 6))
zipped

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

>> Giải nén (Zipped)
unzipped

. Chỉ số = phạm vi (LEN (Zipped [0])) return tuple (Tuple (cặp [index] cho cặp trong zipped) cho chỉ mục trong các chỉ số)

Đây có lẽ không phải là mã mã hiệu quả nhất cho việc này nhưng đây dường như là hành vi chính xác cho đối diện với ZIP và nó sẽ mở rộng quy mô tốt.

Việc sửa đổi ở trên với Danh sách.extend sẽ tạo ra một biến thể gần hơn với những gì tôi nghĩ bạn đang yêu cầu:

def unzip_extend (Dests, Zipped): "" "Bổ số các phiên bản giải nén của Zipped vào DOTS. Điều này tránh được sự phân bổ không cần thiết.

>> DESTS = [[], []] >> unzip_extend (Dests, Zipped) >> Dests

[[1, 2, 3], [4, 5, 6]] "" "Nếu len (zipped) <1: nâng giá trị, 'ít nhất một mục là bắt buộc để giải nén.' Đối với chỉ mục trong phạm vi (LEN (Zipped [0])): Dests [Index] .extend (cặp [INDEX] cho cặp trong Zipped)

Điều này sẽ hoạt động khá tốt, vì mở rộng với sự hiểu biết là khá nhanh. Không phải là nó thực sự có ý nghĩa, đây là thời gian trên máy tính xách tay 2GHz của tôi:

bash -3.1 $ python -m thời gian nhập thời gian -s 'nhập khẩu; Zipped = zip (phạm vi (1024), phạm vi (1024)) '' unzip.unzip_extend ([], []], zipped) '1000 vòng, tốt nhất 3: 510 USEC mỗi vòng lặp