Python, Bikaranîna fonksiyona zip(): Bi yekcarî girtina hêmanên gelek navnîşan

Dikan

Fonksiyona çêkirî ya Python-ê zip() hêmanên gelek tiştên dubare (lîste, pirtik, hwd.) li hev dike û ji bo vegerandina hêmanên pir lîsteyên di çerxa for de tê bikar anîn.

Ev beş karanîna jêrîn a fonksiyona zip() diyar dike.

  • Hêmanên navnîşên pirjimar di hêlek for de bistînin.
  • Bi hejmarên cûda yên hêmanan re mijûl dibin
    • zip():Fonksiyon dê hêmanên ku pir zêde ne paşguh bike.
    • itertools.zip_longest():Ev fonksiyon dê hêmanên winda tije bike.
  • Lîsteyek ji çend hêmanên pirhejmaran bistînin.

Hêmanên navnîşên pirjimar di hêlek for de bistînin.

Ger hûn dixwazin hêmanên gelek tiştên dubarekirî (lîste, pirtik, hwd.) di heman demê de di çerxa for de bigrin û bikar bînin, wan wekî argumanên fonksiyona zip() destnîşan bikin.

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

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

Ne tenê du, lê sê an jî zêdetir jî.

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

Bi hejmarên cûda yên hêmanan re mijûl dibin

Fonksiyona zip() hejmareke mezin ji hêmanan paşguh dike.

Di fonksiyona zip() de, heke hejmara hêmanên di her lîsteyê de cûda be, dê heya hejmara hindik (kurt) ya hêmanan were vegerandin, û hêjmara mezin dê were paşguh kirin.

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

Fonksiyona itertools.zip_longest() dê hêmanên wenda dagire.

Bi karanîna zip_longest() di modula standard itertools ya pirtûkxaneyê de, dema ku hejmara hêmanên di her navnîşê de cûda be, gengaz e ku meriv hêmanên winda bi nirxên keyfî tije bike.

Bi xwerû, ew bi None dagirtî ye.

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

Ger argumana dagirtina nirxê were destnîşan kirin, ew ê bi wê nirxê were dagirtin.

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

Ger çend navnîşên bi hêmanên wenda hebin jî, nirxa ku were dagirtin yekreng e. Ne gengaz e ku meriv nirxên cûda diyar bike.

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

Bi karanîna zip_longest() di hundurê zip_longest() de gengaz e ku meriv nirxek cûda diyar bike, lê ew ne pratîkî ye ji ber ku hûn hewce ne ku ji berê ve zanibin ka kîjan hêmanên navnîşê winda ne.

Heke hûn dixwazin gelek navnîşan bi hejmarek hêmanên nenas, her yek bi nirxek cûda tije bikin, prosedûra jêrîn dikare were hesibandin.

  1. Nirxên ku ji bo hemî navnîşan tije bikin diyar bikin.
  2. Hejmara herî zêde ya hêmanan bistînin
  3. Hemî navnîşan bi hejmara herî zêde ya hêmanan dagirtin
  4. Karanîna fonksiyona zip () bikar tîne
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

Di pêvajoya dagirtina hejmara herî mezin a hêmanan de, em jêrîn dikin.

  • Destpêkirina navnîşek bi nirxek kêfî û hejmarek hêmanan
  • + operator ku tev li lîsteyan bibin

Ger em vê yekê veguherînin fonksiyonek, ew wusa xuya dike. Lîsteya orîjînal û nirxên ku lîsteyê tije dikin, bi rêzê ve wekî argumanên dubare (lîste an pirjimar) têne destnîşan kirin.

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

Ew nîşana têgihîştina navnîşê û berfirehkirina navnîşê bi * bikar tîne.

Lîsteyek ji çend hêmanên pirhejmaran bistînin.

Fonksîyona zip() îteratorek (objeya zip) vedigerîne ku ew çend hêmanên gelek tiştên dubarekirî ye.
Di heman demê de ew dikare li derveyî lûleya for-ê jî were bikar anîn, û armanc bi navnîşan re ne sînorkirî ye.

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

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

Heke hûn dixwazin navnîşek hêmanên gelek tiştên dubarekirî wekî pirjimar bistînin, navnîşê () bikar bînin da ku navnîşek çêbikin.

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