Thứ tự zip Python

Mã giống như trước với một danh sách dòng bổ sung (zip_object) ở cuối cung cấp cho chúng tôi một danh sách trống vì zip_object với tư cách là trình vòng lặp đã cạn kiệt bên trong vòng lặp for (được in tất cả các phần tử của trình vòng lặp này). Hãy để chúng tôi kiểm tra hành vi với phương thức next()

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
zip_object = zip(n, l)
print(next(zip_object))
print(next(zip_object))
list(zip_object)# result:
(1, 'a')
(2, 'b')
[(3, 'c'), (4, 'd')]

Chúng ta thấy rằng hai phần tử đầu tiên của zip_object đã được gọi bởi phương thức next() và được in ra, do đó, zip_object cuối cùng được liệt kê có hai phần tử cuối cùng. Hãy để chúng tôi kiểm tra một số lệnh gọi next()

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
zip_object = zip(n, l)
print(next(zip_object))
print(next(zip_object))
print(next(zip_object))
print(next(zip_object))
next(zip_object)# result:
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
--------------------------------------------------------------------StopIteration                     Traceback (most recent call last)<ipython-input-2-b10ae380d83b> in <module>()
      6 print(next(zip_object))
      7 print(next(zip_object))
----> 8 next(zip_object)
StopIteration:

Chúng tôi đã gặp lỗi StopIteration tiêu chuẩn cho các trình vòng lặp, sau quá nhiều lệnh gọi next()

2. trường hợp chiều dài

I nput iterables được chuyển tới zip() có thể có độ dài khác nhau. Trường hợp đặc biệt là.

• zip() không có đối số, trả về một trình vòng lặp trống

list(zip())# result:
[]

• Với một đối số có thể lặp lại duy nhất, hàm zip() trả về một trình lặp gồm 1 bộ

list(zip([1, 2, 3, 4))# result:
[(1,), (2,), (3,), (4,)]

Các lần lặp có độ dài khác nhau có thể do thiết kế gây ra và đôi khi do lỗi trong mã chuẩn bị các lần lặp này. Chúng ta có thể giải quyết vấn đề này theo ba cách khác nhau

• Theo mặc định, zip() dừng khi hết lần lặp đầu vào ngắn nhất. Do đó, chúng tôi mất các mục còn lại trong các lần lặp dài hơn. Kết quả được cắt theo độ dài của lần lặp ngắn nhất

n = [1, 2, 3, 4, 5, 6]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

• zip() thường được sử dụng trong trường hợp các lần lặp được giả định là có độ dài bằng nhau. Trong những trường hợp như vậy, tôi khuyên bạn nên sử dụng tùy chọnstrict=True của hàm zip() (kể từ Python 3. 10). Không giống như hành vi mặc định, nó kiểm tra xem độ dài của các lần lặp có giống nhau không, tăng ValueError nếu chúng không giống nhau. Nếu không có đối sốstrict=True, bất kỳ lỗi nào dẫn đến các lần lặp có độ dài khác nhau sẽ không được chú ý và sau đó có thể trở thành một lỗi khó tìm trong một phần khác của mã. Hãy để chúng tôi kiểm tra một ví dụ

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

• Các lần lặp ngắn hơn có thể được đệm bằng một giá trị không đổi để làm cho tất cả các lần lặp có cùng độ dài. Điều này được thực hiện bởi zip_longest() từ thư viện itertools. Tham số đầu vào fillvalue của nó là giá trị mở rộng iterable ngắn hơn. Hãy để chúng tôi có một kiểm tra

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

3. Sắp xếp đối tượng zip

Sắp xếp đối tượng zip theo đầu vào đầu tiên có thể lặp lại. Hãy để chúng tôi xem một ví dụ

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

4. thủ thuật giải nén

Hàm zip() kết hợp với toán tử * có thể được sử dụng để giải nén danh sách (hay nói chung là có thể lặp lại). Hãy để chúng tôi xem một ví dụ

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

5. Thưởng. thủ thuật chunking

Thứ tự đánh giá từ trái sang phải của các lần lặp đầu vào được đảm bảo trong hàm zip(). Điều này tạo khả năng phân cụm chuỗi dữ liệu thành các nhóm có độ dài bằng nhau. Hãy để chúng tôi bắt đầu với một danh sách

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

Đầu tiên, [n]*2 tạo một danh sách có hai danh sách (danh sách n lặp lại). Điều này tương đương với [n, n]. Tiếp theo, toán tử * giải nén hai danh sách đó (cùng một danh sách) n và đặt chúng làm đối số cho hàm zip(). Do đó, kết quả giống như đối với list(zip(n,n))

Bây giờ điều khó khăn. Thay vì danh sách n, chúng ta đặt một iterator iter(n). Điều này lặp lại cùng một trình vòng lặp n lần để mỗi bộ dữ liệu đầu ra có kết quả của n lệnh gọi đến trình vòng lặp. Nhưng với mỗi cuộc gọi của iterator như vậy, chúng ta liên tiếp mất phần tử ban đầu của nó và cuối cùng nhận được

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

Sức mạnh của phương pháp này là khi danh sách ban đầu của chúng tôi rất dài và chúng tôi muốn chia nhỏ dữ liệu của mình với bất kỳ kích thước khối nào. Chúng ta hãy xem một ví dụ dưới đây

n = [1, 2, 3, 4]
l = ['a', 'b', 'c', 'd']
list(zip(n, l))# result:
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

T tất cả đều nằm trong câu chuyện ngắn của tôi về hàm zip(). Tôi hy vọng rằng bạn sẽ áp dụng một số thủ thuật được trình bày trong mã hóa của mình. Hãy thử chơi với hàm zip() với số lần lặp khác nhau và các loại khác nhau của chúng.

Nếu bạn quan tâm đến các chủ đề Khoa học dữ liệu và bạn cho rằng bài viết của tôi có giá trị, bạn có thể theo dõi tôi trên LinkedIn hoặc Medium. Tôi rất vui được thảo luận về bất kỳ chủ đề Khoa học dữ liệu, Số liệu thống kê, Toán học hoặc ML nào với bạn. Bạn cũng có thể trở thành thành viên Phương tiện, có quyền truy cập không giới hạn vào tất cả nội dung và hỗ trợ tất cả các nhà văn bằng liên kết giới thiệu của tôi. Cảm ơn, Greg

Bạn có thể sắp xếp một đối tượng zip trong Python không?

Bạn có thể nén 4 danh sách Python không?

Bạn có thể nén chuỗi Python không?

Zip có trả lại một tuple không?