Python, zip() ફંક્શનનો ઉપયોગ કરીને: એકસાથે બહુવિધ સૂચિના ઘટકો મેળવવું

બિઝનેસ

પાયથોનનું બિલ્ટ-ઇન ફંક્શન zip() બહુવિધ પુનરાવર્તિત ઑબ્જેક્ટ્સ (સૂચિઓ, ટ્યુપલ્સ, વગેરે) ના ઘટકોને જોડે છે અને તેનો ઉપયોગ લૂપ માટે બહુવિધ સૂચિના ઘટકોને પુનઃપ્રાપ્ત કરવા માટે થાય છે.

આ વિભાગ zip() ફંક્શનના નીચેના ઉપયોગનું વર્ણન કરે છે.

  • લૂપ માટે બહુવિધ સૂચિના ઘટકો મેળવો.
  • તત્વોની વિવિધ સંખ્યા સાથે વ્યવહાર
    • zip():ફંક્શન એ તત્વોને અવગણશે જે ખૂબ વધારે છે.
    • itertools.zip_longest():આ કાર્ય ખૂટતા તત્વોને ભરી દેશે.
  • બહુવિધ પુનરાવર્તિત તત્વોના ટ્યુપલ્સની સૂચિ મેળવો.

લૂપ માટે બહુવિધ સૂચિના ઘટકો મેળવો.

જો તમે લૂપ માટે એક જ સમયે બહુવિધ પુનરાવર્તિત ઑબ્જેક્ટ્સ (સૂચિઓ, ટ્યુપલ્સ, વગેરે) ના ઘટકોને પુનઃપ્રાપ્ત કરવા અને ઉપયોગ કરવા માંગતા હો, તો તેમને 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

માત્ર બે નહીં, પણ ત્રણ કે તેથી વધુ.

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

તત્વોની વિવિધ સંખ્યા સાથે વ્યવહાર

zip() ફંક્શન મોટી સંખ્યામાં તત્વોને અવગણે છે.

zip() ફંક્શનમાં, જો દરેક સૂચિમાં ઘટકોની સંખ્યા અલગ હોય, તો ઘટકોની ઓછી (ટૂંકી) સંખ્યા સુધી પરત કરવામાં આવશે, અને મોટી સંખ્યાને અવગણવામાં આવશે.

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

itertools.zip_longest() ફંક્શન ગુમ થયેલા તત્વોને ભરી દેશે.

સ્ટાન્ડર્ડ લાઇબ્રેરી itertools મોડ્યુલમાં zip_longest() નો ઉપયોગ કરીને, દરેક યાદીમાં તત્વોની સંખ્યા અલગ હોય ત્યારે ખૂટતા તત્વોને મનસ્વી મૂલ્યો સાથે ભરવાનું શક્ય છે.

મૂળભૂત રીતે, તે None થી ભરેલું છે.

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

જો ફિલવેલ્યુ દલીલ ઉલ્લેખિત છે, તો તે તે મૂલ્યથી ભરવામાં આવશે.

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

જો ગુમ થયેલ તત્વો સાથે બહુવિધ સૂચિઓ હોય, તો પણ ભરવાનું મૂલ્ય એકસમાન છે. વિવિધ મૂલ્યોનો ઉલ્લેખ કરવો શક્ય નથી.

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

zip_longest() ની અંદર zip_longest() નો ઉપયોગ કરીને અલગ મૂલ્ય નિર્દિષ્ટ કરવું શક્ય છે, પરંતુ તે વ્યવહારુ નથી કારણ કે તમારે સૂચિમાં કયા ઘટકો ખૂટે છે તે અગાઉથી જાણવાની જરૂર છે.

જો તમે ઘટકોની અજ્ઞાત સંખ્યા સાથે બહુવિધ યાદીઓ ભરવા માંગતા હો, તો દરેક અલગ મૂલ્ય સાથે, નીચેની પ્રક્રિયાને ધ્યાનમાં લઈ શકાય છે.

  1. બધી સૂચિઓ ભરવા માટે મૂલ્યો વ્યાખ્યાયિત કરો.
  2. ઘટકોની મહત્તમ સંખ્યા મેળવો
  3. ઘટકોની મહત્તમ સંખ્યામાં બધી સૂચિ ભરો
  4. 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

તત્વોની સૌથી મોટી સંખ્યામાં ભરવાની પ્રક્રિયામાં, અમે નીચે મુજબ કરીએ છીએ.

  • મનસ્વી મૂલ્ય અને ઘટકોની સંખ્યા સાથે સૂચિની શરૂઆત કરવી
  • + એકસાથે યાદીમાં જોડાવા માટે ઓપરેટર

જો આપણે આને ફંક્શનમાં ફેરવીએ, તો તે આના જેવું દેખાય છે. મૂળ સૂચિ અને મૂલ્યો જે સૂચિને ભરે છે તે અનુક્રમે પુનરાવર્તિત (સૂચિ અથવા ટ્યુપલ) દલીલો તરીકે ઉલ્લેખિત છે.

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

તે સૂચિ સમજણ સંકેત અને * દ્વારા સૂચિ વિસ્તરણનો ઉપયોગ કરે છે.

બહુવિધ પુનરાવર્તિત તત્વોના ટ્યુપલ્સની સૂચિ મેળવો.

zip() ફંક્શન એક પુનરાવર્તક (ઝિપ ઑબ્જેક્ટ) આપે છે જે બહુવિધ પુનરાવર્તિત ઑબ્જેક્ટના ઘટકોનું ટ્યુપલ છે.
તેનો ઉપયોગ લૂપની બહાર પણ થઈ શકે છે, અને લક્ષ્ય સૂચિઓ સુધી મર્યાદિત નથી.

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

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

જો તમે ટ્યુપલ તરીકે બહુવિધ પુનરાવર્તિત ઑબ્જેક્ટના ઘટકોની સૂચિ મેળવવા માંગતા હો, તો સૂચિ બનાવવા માટે list() નો ઉપયોગ કરો.

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