Danh sách zip trong Python

Tôi đang cố gắng học cách "zip" danh sách. Để kết thúc này, tôi có một chương trình, tại một thời điểm cụ thể, tôi làm như sau:

x1, x2, x3 = stuff.calculations(withdataa)

Điều này cho phép tôi ba danh sách, x1, x2, và x3, mỗi người trong số, nói, kích thước 20.

Bây giờ, tôi làm:

zipall = zip(x1, x2, x3)

Tuy nhiên, khi tôi làm:

print "len of zipall %s" % len(zipall)

Tôi nhận được 20, đó không phải là những gì tôi mong đợi. Tôi mong đợi ba. Tôi nghĩ rằng tôi đang làm một cái gì đó sai về cơ bản.

Khi bạn zip()kết hợp ba danh sách chứa 20 phần tử mỗi phần, kết quả có hai phần tử. Mỗi yếu tố là một tuple ba.

Xem cho chính mình:

In [1]: a = b = c = range(20)

In [2]: zip(a, b, c)
Out[2]: 
[(0, 0, 0),
 (1, 1, 1),
 ...
 (17, 17, 17),
 (18, 18, 18),
 (19, 19, 19)]

Để tìm hiểu có bao nhiêu phần tử mỗi bộ chứa, bạn có thể kiểm tra độ dài của phần tử đầu tiên:

In [3]: result = zip(a, b, c)

In [4]: len(result[0])
Out[4]: 3

Tất nhiên, điều này sẽ không hoạt động nếu danh sách trống để bắt đầu.

zip mất một loạt các danh sách thích

a: a1 a2 a3 a4 a5 a6 a7...
b: b1 b2 b3 b4 b5 b6 b7...
c: c1 c2 c3 c4 c5 c6 c7...

và "nén" chúng vào một danh sách có các mục nhập là 3-tuples (ai, bi, ci). Hãy tưởng tượng vẽ một dây kéo theo chiều ngang từ trái sang phải.

Trong Python 2.7, điều này có thể đã hoạt động tốt:

>>> a = b = c = range(20)
>>> zip(a, b, c)

Nhưng trong Python 3.4 thì phải (nếu không, kết quả sẽ giống như vậy <zip object at 0x00000256124E7DC8>):

>>> a = b = c = range(20)
>>> list(zip(a, b, c))

zip tạo một danh sách mới, chứa đầy các bộ dữ liệu chứa các phần tử từ các đối số có thể lặp lại:

>>> zip ([1,2],[3,4])
[(1,3), (2,4)]

Tôi hy vọng những gì bạn cố gắng là tạo ra một tuple trong đó mỗi phần tử là một danh sách.

Nguồn: Bài viết trên Blog của tôi (định dạng tốt hơn)

Thí dụ

numbers = [1,2,3]
letters = 'abcd'

zip(numbers, letters)
# [(1, 'a'), (2, 'b'), (3, 'c')]

Đầu vào

Không hoặc nhiều lần lặp [1] (ví dụ: danh sách, chuỗi, tuple, từ điển)

Đầu ra (danh sách)

Tuple thứ 1 = (phần tử_1 của số, phần tử_1 của chữ cái)

Tuple thứ 2 = (số e_2, e_2 chữ cái)

Giáo dục

n-th tuple = (số e_n, chữ cái e_n)

1. Danh sách n tuples: n là độ dài của đối số ngắn nhất (đầu vào)
   • len (số) == 3 <len (chữ cái) == 4 → short = 3 → trả lại 3 bộ dữ liệu
2. Độ dài mỗi tuple = # of args (tuple lấy một phần tử từ mỗi arg)
   • args = (số, chữ cái); len (args) == 2 → tuple với 2 phần tử
3. ith tuple = (Element_i arg1, Element_i arg2 Hoài, Element_i arg n)

Vỏ cạnh

1) Chuỗi rỗng: len (str) = 0 = không có bộ dữ liệu

2) Chuỗi đơn: len (str) == 2 tuples với len (args) == 1 phần tử

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

Zip trong hành động!

1. Xây dựng một từ điển [2] trong số hai danh sách

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

• zip là một giải pháp thanh lịch, rõ ràng và súc tích

2. In cột trong bảng

"*" [3] được gọi là "giải nén": f(*[arg1,arg2,arg3]) == f(arg1, arg2, arg3)

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

Tín dụng bổ sung: Giải nén

zip(*args) được gọi là không giải mã được vì nó có tác dụng nghịch đảo zip

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

• unzipped: tuple_1 = e1 của mỗi bộ được nén. tuple_2 = e2 của mỗizipped

Chú thích

1. Một đối tượng có khả năng trả lại từng thành viên của nó (ví dụ: danh sách [1,2,3], chuỗi 'Tôi thích codin', tuple (1,2,3), từ điển {'a': 1, 'b' : 2})
2. {key1: value1, key2: value2 ...}
3. Dịch vụ giải nén

* Mã số:

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

*đã lấy numbers(1 arg) và hung đã giải nén ra '2 phần tử của nó thành 2 arg

Về cơ bản, chức năng zip hoạt động trên danh sách, bộ dữ liệu và từ điển trong Python. Nếu bạn đang sử dụng IPython thì chỉ cần gõ zip? Và kiểm tra xem zip () nói về cái gì

Nếu bạn không sử dụng IPython thì chỉ cần cài đặt nó: "pip install ipython"

Đối với danh sách

a = ['a', 'b', 'c']
b = ['p', 'q', 'r']
zip(a, b)

Đầu ra là [('a', 'p'), ('b', 'q'), ('c', 'r')

Đối với từ điển:

c = {'gaurav':'waghs', 'nilesh':'kashid', 'ramesh':'sawant', 'anu':'raje'}
d = {'amit':'wagh', 'swapnil':'dalavi', 'anish':'mane', 'raghu':'rokda'}
zip(c, d)

Đầu ra là:

[('gaurav', 'amit'),
 ('nilesh', 'swapnil'),
 ('ramesh', 'anish'),
 ('anu', 'raghu')]

Trong Python 3 zip trả về một iterator thay vào đó và cần được chuyển đến một hàm danh sách để có được các bộ nén:

x = [1, 2, 3]; y = ['a','b','c']
z = zip(x, y)
z = list(z)
print(z)
>>> [(1, 'a'), (2, 'b'), (3, 'c')]

Sau đó, để unziphọ quay lại chỉ cần lặp lại trình lặp được nén:

x_back, y_back = zip(*z)
print(x_back); print(y_back)
>>> (1, 2, 3)
>>> ('a', 'b', 'c')

Nếu hình thức ban đầu của danh sách là cần thiết thay vì bộ dữ liệu:

x_back, y_back = zip(*z)
print(list(x_back)); print(list(y_back))
>>> [1,2,3]
>>> ['a','b','c']

Vì sự trọn vẹn.

Khi độ dài của danh sách nén không bằng nhau. Độ dài của danh sách kết quả sẽ trở thành ngắn nhất mà không có lỗi xảy ra

>>> a = [1]
>>> b = ["2", 3]
>>> zip(a,b)
[(1, '2')]

Tôi không nghĩ zipsẽ trả về một danh sách. ziptrả về một máy phát điện. Bạn phải làm list(zip(a, b))để có được một danh sách các bộ dữ liệu.

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)

Thật đáng để thêm vào đây vì đây là một câu hỏi xếp hạng cao trên zip. ziplà một Python tuyệt vời, thành ngữ - nhưng nó không có quy mô rất tốt cho các danh sách lớn.

Thay vì:

books = ['AAAAAAA', 'BAAAAAAA', ... , 'ZZZZZZZ']
words = [345, 567, ... , 672]

for book, word in zip(books, words):
   print('{}: {}'.format(book, word))

Sử dụng izip. Để xử lý hiện đại, nó lưu trữ nó trong bộ nhớ L1 Cache và hiệu năng cao hơn nhiều cho các danh sách lớn hơn. Sử dụng nó đơn giản như thêm một i:

for book, word in izip(books, words):
   print('{}: {}'.format(book, word))