పైథాన్, జిప్() ఫంక్షన్‌ని ఉపయోగించడం: బహుళ జాబితాల మూలకాలను ఒకేసారి పొందడం

వ్యాపారం

పైథాన్ యొక్క అంతర్నిర్మిత ఫంక్షన్ జిప్() బహుళ పునరావృత వస్తువుల (జాబితాలు, టుపుల్స్, మొదలైనవి) యొక్క మూలకాలను మిళితం చేస్తుంది మరియు ఫర్ లూప్‌లోని బహుళ జాబితాల మూలకాలను తిరిగి పొందేందుకు ఉపయోగించబడుతుంది.

ఈ విభాగం జిప్() ఫంక్షన్ యొక్క క్రింది వినియోగాన్ని వివరిస్తుంది.

  • లూప్ కోసం బహుళ జాబితాల మూలకాలను పొందండి.
  • విభిన్న సంఖ్యలో మూలకాలతో వ్యవహరించడం
    • zip():ఫంక్షన్ చాలా ఎక్కువగా ఉన్న అంశాలను విస్మరిస్తుంది.
    • itertools.zip_longest():ఈ ఫంక్షన్ తప్పిపోయిన మూలకాలను పూరిస్తుంది.
  • బహుళ ఇటరబుల్స్ యొక్క మూలకాల యొక్క టుపుల్స్ జాబితాను పొందండి.

లూప్ కోసం బహుళ జాబితాల మూలకాలను పొందండి.

మీరు ఫర్ లూప్‌లో ఒకే సమయంలో బహుళ పునరావృత వస్తువుల (జాబితాలు, టుపుల్స్, మొదలైనవి) యొక్క మూలకాలను తిరిగి పొంది, ఉపయోగించాలనుకుంటే, వాటిని జిప్() ఫంక్షన్‌కు ఆర్గ్యుమెంట్‌లుగా పేర్కొనండి.

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

విభిన్న సంఖ్యలో మూలకాలతో వ్యవహరించడం

జిప్() ఫంక్షన్ పెద్ద సంఖ్యలో మూలకాలను విస్మరిస్తుంది.

జిప్() ఫంక్షన్‌లో, ప్రతి జాబితాలోని మూలకాల సంఖ్య భిన్నంగా ఉన్నట్లయితే, తక్కువ (తక్కువ) మూలకాల సంఖ్య వరకు తిరిగి ఇవ్వబడుతుంది మరియు ఎక్కువ సంఖ్య విస్మరించబడుతుంది.

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. జిప్() ఫంక్షన్‌ని ఉపయోగించడం
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

ఇది * ద్వారా జాబితా గ్రహణ సంజ్ఞామానం మరియు జాబితా విస్తరణను ఉపయోగిస్తుంది.

బహుళ ఇటరబుల్స్ యొక్క మూలకాల యొక్క టుపుల్స్ జాబితాను పొందండి.

జిప్() ఫంక్షన్ ఒక ఇటరేటర్ (జిప్ ఆబ్జెక్ట్)ని అందిస్తుంది, అది బహుళ మళ్ళించదగిన ఆబ్జెక్ట్‌ల యొక్క టూపుల్ ఎలిమెంట్స్.
ఇది లూప్ వెలుపల కూడా ఉపయోగించబడుతుంది మరియు లక్ష్యం జాబితాలకు పరిమితం కాదు.

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

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

మీరు బహుళ పునరావృత వస్తువుల మూలకాల జాబితాను టుపుల్‌గా పొందాలనుకుంటే, జాబితాను రూపొందించడానికి జాబితా()ని ఉపయోగించండి.

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