Python, Gamit ang zip() function: Pagkuha ng mga elemento ng maraming listahan nang sabay-sabay

Negosyo

Pinagsasama-sama ng built-in na function na zip() ng Python ang mga elemento ng maramihang iterable na mga bagay (mga listahan, tuple, atbp.) at ginagamit upang kunin ang mga elemento ng maraming listahan sa isang for loop.

Inilalarawan ng seksyong ito ang sumusunod na paggamit ng zip() function.

  • Kunin ang mga elemento ng maraming listahan sa isang for loop.
  • Pagharap sa iba’t ibang bilang ng mga elemento
    • zip():Babalewalain ng function ang mga elemento na sobra.
    • itertools.zip_longest():Pupunan ng function na ito ang mga nawawalang elemento.
  • Kumuha ng listahan ng mga tuple ng mga elemento ng maraming iterable.

Kunin ang mga elemento ng maraming listahan sa isang for loop.

Kung gusto mong kunin at gamitin ang mga elemento ng maraming iterable na bagay (mga listahan, tuple, atbp.) nang sabay sa isang for loop, tukuyin ang mga ito bilang mga argumento sa zip() function.

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

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

Hindi lang dalawa, kundi tatlo o higit pa.

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

Pagharap sa iba’t ibang bilang ng mga elemento

Binabalewala ng zip() function ang isang malaking bilang ng mga elemento.

Sa zip() function, kung ang bilang ng mga elemento sa bawat listahan ay iba, hanggang sa mas maliit (mas maikli) na bilang ng mga elemento ay ibabalik, at ang mas malaking bilang ay hindi papansinin.

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

Ang itertools.zip_longest() function ay pupunan ang mga nawawalang elemento.

Gamit ang zip_longest() sa karaniwang module ng library itertools, posibleng punan ang mga nawawalang elemento ng mga arbitrary na halaga kapag iba ang bilang ng mga elemento sa bawat listahan.

Bilang default, ito ay puno ng Wala.

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

Kung tinukoy ang argumento ng fillvalue, mapupunan ito ng halagang iyon.

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

Kahit na maraming mga listahan na may mga nawawalang elemento, ang halaga na pupunan ay pare-pareho. Hindi posible na tukuyin ang iba’t ibang mga halaga.

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

Posibleng tumukoy ng ibang value sa pamamagitan ng paggamit ng zip_longest() sa loob ng zip_longest(), ngunit hindi ito praktikal dahil kailangan mong malaman nang maaga kung aling mga elemento ng listahan ang nawawala.

Kung gusto mong punan ang maraming listahan ng hindi kilalang bilang ng mga elemento, bawat isa ay may ibang halaga, maaaring isaalang-alang ang sumusunod na pamamaraan.

  1. Tukuyin ang mga halagang pupunan para sa lahat ng listahan.
  2. Kunin ang maximum na bilang ng mga elemento
  3. Punan ang lahat ng listahan sa maximum na bilang ng mga elemento
  4. Gamit ang zip() function
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

Sa proseso ng pagpuno hanggang sa pinakamalaking bilang ng mga elemento, ginagawa namin ang sumusunod.

  • Pagsisimula ng isang listahan na may arbitrary na halaga at bilang ng mga elemento
  • + operator upang pagsama-samahin ang mga listahan

Kung gagawin natin itong function, ganito ang hitsura. Ang orihinal na listahan at ang mga value na pumupuno sa listahan ay tinukoy bilang mga iterables (listahan o tuple) na argumento, ayon sa pagkakabanggit.

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

Gumagamit ito ng notasyon sa pag-unawa sa listahan at pagpapalawak ng listahan sa pamamagitan ng *.

Kumuha ng listahan ng mga tuple ng mga elemento ng maraming iterable.

Ang zip() function ay nagbabalik ng isang iterator (zip object) na isang tuple ng mga elemento ng maraming iterable na mga bagay.
Maaari rin itong gamitin sa labas ng for loop, at ang target ay hindi limitado sa mga listahan.

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

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

Kung gusto mong makakuha ng isang listahan ng mga elemento ng maraming iterable na bagay bilang isang tuple, gamitin ang list() para gumawa ng listahan.

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