Python, Sử dụng hàm zip (): Lấy các phần tử của nhiều danh sách cùng một lúc

Kinh doanh

Hàm zip () tích hợp sẵn của Python kết hợp các phần tử của nhiều đối tượng có thể lặp lại (danh sách, bộ giá trị, v.v.) và được sử dụng để truy xuất các phần tử của nhiều danh sách trong vòng lặp for.

Phần này mô tả cách sử dụng hàm zip () sau đây.

  • Lấy các phần tử của nhiều danh sách trong vòng lặp for.
  • Xử lý số lượng phần tử khác nhau
    • zip():Hàm sẽ bỏ qua các phần tử quá nhiều.
    • itertools.zip_longest():Hàm này sẽ điền vào các phần tử còn thiếu.
  • Nhận danh sách các bộ giá trị của nhiều phần tử lặp lại.

Lấy các phần tử của nhiều danh sách trong vòng lặp for.

Nếu bạn muốn truy xuất và sử dụng các phần tử của nhiều đối tượng có thể lặp lại (danh sách, bộ giá trị, v.v.) cùng một lúc trong vòng lặp for, hãy chỉ định chúng làm đối số cho hàm zip ().

names = ['Alice', 'Bob', 'Charlie']
ages = [24, 50, 18]

for name, age in zip(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18

Không chỉ hai, mà là ba hoặc nhiều hơn nữa.

points = [100, 85, 90]

for name, age, point in zip(names, ages, points):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 90

Xử lý số lượng phần tử khác nhau

Hàm zip () bỏ qua một số lượng lớn các phần tử.

Trong hàm zip (), nếu số phần tử trong mỗi danh sách khác nhau, thì số phần tử ít hơn (ngắn hơn) sẽ được trả về và số lớn hơn sẽ bị bỏ qua.

names = ['Alice', 'Bob', 'Charlie', 'Dave']
ages = [24, 50, 18]

for name, age in zip(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18

Hàm itertools.zip_longest () sẽ điền vào các phần tử còn thiếu.

Sử dụng zip_longest () trong mô-đun itertools của thư viện tiêu chuẩn, có thể điền vào các phần tử còn thiếu với giá trị tùy ý khi số lượng phần tử trong mỗi danh sách là khác nhau.

Theo mặc định, nó được điền bằng Không.

from itertools import zip_longest

names = ['Alice', 'Bob', 'Charlie', 'Dave']
ages = [24, 50, 18]

for name, age in zip_longest(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18
# Dave None

Nếu đối số fillvalue được chỉ định, nó sẽ được điền bằng giá trị đó.

for name, age in zip_longest(names, ages, fillvalue=20):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18
# Dave 20

Ngay cả khi có nhiều danh sách bị thiếu phần tử, giá trị được điền là đồng nhất. Không thể chỉ định các giá trị khác nhau.

points = [100, 85]

for name, age, point in zip_longest(names, ages, points, fillvalue=20):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 20
# Dave 20 20

Có thể chỉ định một giá trị khác bằng cách sử dụng zip_longest () bên trong zip_longest (), nhưng không thực tế vì bạn cần biết trước phần tử nào của danh sách bị thiếu.

Nếu bạn muốn điền vào nhiều danh sách với một số phần tử chưa biết, mỗi phần tử có một giá trị khác nhau, có thể xem xét quy trình sau.

  1. Xác định các giá trị cần điền cho tất cả các danh sách.
  2. Nhận số phần tử tối đa
  3. Điền vào tất cả các danh sách với số lượng phần tử tối đa
  4. Sử dụng hàm zip ()
fill_name = 'XXX'
fill_age = 20
fill_point = 50

len_names = len(names)
len_ages = len(ages)
len_points = len(points)

max_len = max(len_names, len_ages, len_points)

names = names + [fill_name] * (max_len - len_names)
ages = ages + [fill_age] * (max_len - len_ages)
points = points + [fill_point] * (max_len - len_points)

print(names)
print(ages)
print(points)
# ['Alice', 'Bob', 'Charlie', 'Dave']
# [24, 50, 18, 20]
# [100, 85, 50, 50]

for name, age, point in zip(names, ages, points):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 50
# Dave 20 50

Trong quá trình điền đến số phần tử lớn nhất, chúng ta thực hiện như sau.

  • Khởi tạo danh sách với giá trị và số phần tử tùy ý
  • + toán tử để kết hợp các danh sách với nhau

Nếu chúng ta biến nó thành một hàm, nó sẽ như thế này. Danh sách ban đầu và các giá trị lấp đầy danh sách được chỉ định tương ứng dưới dạng đối số lặp (danh sách hoặc tuple).

def my_zip_longest(iterables, fillvalues):
    max_len = max(len(i) for i in iterables)
    return zip(*[list(i) + [v] * (max_len - len(i)) for i, v in zip(iterables, fillvalues)])

for name, age, point in my_zip_longest((names, ages, points), ('XXX', 20, 50)):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 50
# Dave 20 50

Nó sử dụng ký hiệu hiểu danh sách và mở rộng danh sách bằng *.

Nhận danh sách các bộ giá trị của nhiều phần tử lặp lại.

Hàm zip () trả về một trình vòng lặp (đối tượng zip) là một tập hợp các phần tử của nhiều đối tượng có thể lặp lại.
Nó cũng có thể được sử dụng bên ngoài vòng lặp for và mục tiêu không bị giới hạn trong danh sách.

names = ['Alice', 'Bob', 'Charlie']
ages = (24, 50, 18)

z = zip(names, ages)
print(z)
print(type(z))
# <zip object at 0x10b57b888>
# <class 'zip'>

Nếu bạn muốn nhận danh sách các phần tử của nhiều đối tượng có thể lặp lại dưới dạng một bộ, hãy sử dụng list () để tạo danh sách.

l = list(zip(names, ages))
print(l)
print(type(l))
print(type(l[0]))
# [('Alice', 24), ('Bob', 50), ('Charlie', 18)]
# <class 'list'>
# <class 'tuple'>