పైథాన్ జాబితా కాంప్రహెన్షన్స్ సంజ్ఞామానాన్ని ఉపయోగించడం

వ్యాపారం

పైథాన్‌లో, కొత్త జాబితాను రూపొందించేటప్పుడు జాబితా కాంప్రహెన్షన్‌ల సంజ్ఞామానాన్ని ఉపయోగించడం సులభం.(List comprehensions)

ఈ వ్యాసంలో, మేము మొదట ఈ క్రింది వాటిని చర్చిస్తాము

  • జాబితా గ్రహణ సంజ్ఞామానం యొక్క ప్రాథమిక రకం
  • if ద్వారా షరతులతో కూడిన బ్రాంచ్‌తో లిస్ట్ కాంప్రహెన్షన్ నోటేషన్
  • టెర్నరీ ఆపరేటర్‌లతో కలయిక (ఇతర ప్రాసెసింగ్ లాంటిది అయితే)
  • zip(),enumerate()వీటితో కలయిక
  • సమూహ జాబితా చేరిక సంజ్ఞామానం

తరువాత, మేము నమూనా కోడ్‌తో జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం సమితిని వివరిస్తాము.

  • చేరిక సంజ్ఞామానాన్ని సెట్ చేయండి(Set comprehensions)
  • నిఘంటువు చేరిక సంజ్ఞామానం(Dict comprehensions)
  • జనరేటర్ రకం(Generator expressions)

జాబితా గ్రహణ సంజ్ఞామానం యొక్క ప్రాథమిక రకం

జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం క్రింది విధంగా వ్రాయబడింది.

[Expression for Any Variable Name in Iterable Object]

ఇది జాబితా, టుపుల్ లేదా పరిధి వంటి పునరావృత వస్తువు యొక్క ప్రతి మూలకాన్ని ఏకపక్ష వేరియబుల్ పేరుతో తీసుకుంటుంది మరియు దానిని వ్యక్తీకరణతో మూల్యాంకనం చేస్తుంది. మూల్యాంకన ఫలితంతో కూడిన కొత్త జాబితా అందించబడుతుంది.

స్టేట్‌మెంట్‌కు సమానమైన దానితో పాటు ఒక ఉదాహరణ ఇవ్వబడింది.

squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]

squares = []
for i in range(5):
    squares.append(i**2)

print(squares)
# [0, 1, 4, 9, 16]

అదే ప్రక్రియ మ్యాప్()తో చేయవచ్చు, అయితే జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం దాని సరళత మరియు స్పష్టత కోసం ప్రాధాన్యతనిస్తుంది.

if ద్వారా షరతులతో కూడిన బ్రాంచ్‌తో లిస్ట్ కాంప్రహెన్షన్ నోటేషన్

if తో షరతులతో కూడిన శాఖలు కూడా సాధ్యమే. పోస్ట్‌ఫిక్స్‌లో if ని ఈ క్రింది విధంగా వ్రాయండి.

[Expression for Any Variable Name in Iterable Object if Conditional Expression]

షరతులతో కూడిన వ్యక్తీకరణ నిజం అయిన పునరావృత ఆబ్జెక్ట్ యొక్క మూలకాలు మాత్రమే వ్యక్తీకరణ ద్వారా మూల్యాంకనం చేయబడతాయి మరియు మూలకాల ఫలితంగా ఉన్న కొత్త జాబితా అందించబడుతుంది.

మీరు షరతులతో కూడిన వ్యక్తీకరణలో ఏదైనా వేరియబుల్ పేరును ఉపయోగించవచ్చు.

స్టేట్‌మెంట్‌కు సమానమైన దానితో పాటు ఒక ఉదాహరణ ఇవ్వబడింది.

odds = [i for i in range(10) if i % 2 == 1]
print(odds)
# [1, 3, 5, 7, 9]

odds = []
for i in range(10):
    if i % 2 == 1:
        odds.append(i)

print(odds)
# [1, 3, 5, 7, 9]

అదే ప్రక్రియను ఫిల్టర్()తో చేయవచ్చు, అయితే జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం దాని సరళత మరియు స్పష్టత కోసం ప్రాధాన్యతనిస్తుంది.

టెర్నరీ ఆపరేటర్‌లతో కలయిక (ఇతర ప్రాసెసింగ్ లాంటిది అయితే)

ఎగువ ఉదాహరణలో, ప్రమాణాలకు అనుగుణంగా ఉన్న అంశాలు మాత్రమే ప్రాసెస్ చేయబడతాయి మరియు ప్రమాణాలకు అనుగుణంగా లేనివి కొత్త జాబితా నుండి మినహాయించబడతాయి.

మీరు షరతుపై ఆధారపడి ప్రక్రియను మార్చాలనుకుంటే, లేదా మీరు పరిస్థితిని సంతృప్తిపరచని మూలకాలను విభిన్నంగా ప్రాసెస్ చేయాలనుకుంటే, టెర్నరీ ఆపరేటర్‌ని ఉపయోగించండి.

పైథాన్‌లో, టెర్నరీ ఆపరేటర్‌ని ఈ క్రింది విధంగా వ్రాయవచ్చు

Value When True if Conditional Expression else Value When False

దిగువ చూపిన విధంగా ఇది జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం యొక్క వ్యక్తీకరణ భాగంలో ఉపయోగించబడుతుంది.

[Value When True if Conditional Expression else Value When False for Any Variable Name in Iterable Object]

స్టేట్‌మెంట్‌కు సమానమైన దానితో పాటు ఒక ఉదాహరణ ఇవ్వబడింది.

odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

odd_even = []
for i in range(10):
    if i % 2 == 1:
        odd_even.append('odd')
    else:
        odd_even.append('even')

print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

నిజమైన మరియు తప్పుడు విలువల కోసం ఏకపక్ష వేరియబుల్ పేర్లను ఉపయోగించి వ్యక్తీకరణలను వ్రాయడం కూడా సాధ్యమే.

షరతు సంతృప్తి చెందినట్లయితే, కొంత ప్రాసెసింగ్ చేయబడుతుంది, లేకుంటే అసలు మళ్లించదగిన వస్తువు యొక్క విలువ మారదు.

odd10 = [i * 10 if i % 2 == 1 else i for i in range(10)]
print(odd10)
# [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]

జిప్() మరియు ఎన్యూమరేట్()తో కలయిక

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

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

జిప్()కి ఉదాహరణ

l_str1 = ['a', 'b', 'c']
l_str2 = ['x', 'y', 'z']

l_zip = [(s1, s2) for s1, s2 in zip(l_str1, l_str2)]
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

l_zip = []
for s1, s2 in zip(l_str1, l_str2):
    l_zip.append((s1, s2))

print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

ఎన్యుమరేట్ () యొక్క ఉదాహరణ

l_enu = [(i, s) for i, s in enumerate(l_str1)]
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

l_enu = []
for i, s in enumerate(l_str1):
    l_enu.append((i, s))

print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

if ఉపయోగిస్తున్నప్పుడు ఆలోచన మునుపటిలాగే ఉంటుంది.

l_zip_if = [(s1, s2) for s1, s2 in zip(l_str1, l_str2) if s1 != 'b']
print(l_zip_if)
# [('a', 'x'), ('c', 'z')]

ప్రతి మూలకం కొత్త మూలకాన్ని లెక్కించడానికి కూడా ఉపయోగించవచ్చు.

l_int1 = [1, 2, 3]
l_int2 = [10, 20, 30]

l_sub = [i2 - i1 for i1, i2 in zip(l_int1, l_int2)]
print(l_sub)
# [9, 18, 27]

సమూహ జాబితా చేరిక సంజ్ఞామానం

లూప్‌ల కోసం గూడు కట్టినట్లు, జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం కూడా గూడులో ఉంటుంది.

[Expression for Variable Name 1 in Iterable Object 1
    for Variable Name 2 in Iterable Object 2
        for Variable Name 3 in Iterable Object 3 ... ]

సౌలభ్యం కోసం, లైన్ బ్రేక్‌లు మరియు ఇండెంటేషన్‌లు జోడించబడ్డాయి, కానీ వ్యాకరణానికి అవసరం లేదు; వాటిని ఒకే లైన్‌లో కొనసాగించవచ్చు.

స్టేట్‌మెంట్‌కు సమానమైన దానితో పాటు ఒక ఉదాహరణ ఇవ్వబడింది.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat = [x for row in matrix for x in row]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

flat = []
for row in matrix:
    for x in row:
        flat.append(x)

print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

బహుళ వేరియబుల్స్ ఉపయోగించడం కూడా సాధ్యమే.

cells = [(row, col) for row in range(3) for col in range(2)]
print(cells)
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

మీరు షరతులతో కూడిన శాఖలను కూడా చేయవచ్చు.

cells = [(row, col) for row in range(3)
         for col in range(2) if col == row]
print(cells)
# [(0, 0), (1, 1)]

ప్రతి పునరావృత వస్తువు కోసం షరతులతో శాఖ చేయడం కూడా సాధ్యమే.

cells = [(row, col) for row in range(3) if row % 2 == 0
         for col in range(2) if col % 2 == 0]
print(cells)
# [(0, 0), (2, 0)]

చేరిక సంజ్ఞామానాన్ని సెట్ చేయండి(Set comprehensions)

జాబితా కాంప్రహెన్షన్ సంజ్ఞామానంలోని స్క్వేర్ బ్రాకెట్‌లను [] కర్లీ బ్రాకెట్‌లకు మార్చడం {} ఒక సమితిని సృష్టిస్తుంది (సెట్-టైప్ ఆబ్జెక్ట్).

{Expression for Any Variable Name in Iterable Object}

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

నిఘంటువు చేరిక సంజ్ఞామానం(Dict comprehensions)

డిక్షనరీలను (డిక్ట్ టైప్ ఆబ్జెక్ట్స్) కూడా కాంప్రహెన్షన్ నోటేషన్‌తో రూపొందించవచ్చు.

{}, మరియు వ్యక్తీకరణ భాగంలో కీ మరియు విలువను కీగా పేర్కొనండి: విలువ.

{Key: Value for Any Variable Name in Iterable Object}

కీ మరియు విలువ కోసం ఏదైనా వ్యక్తీకరణను పేర్కొనవచ్చు.

l = ['Alice', 'Bob', 'Charlie']

d = {s: len(s) for s in l}
print(d)
# {'Alice': 5, 'Bob': 3, 'Charlie': 7}

కీలు మరియు విలువల జాబితా నుండి కొత్త నిఘంటువుని సృష్టించడానికి, zip() ఫంక్షన్‌ని ఉపయోగించండి.

keys = ['k1', 'k2', 'k3']
values = [1, 2, 3]

d = {k: v for k, v in zip(keys, values)}
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}

జనరేటర్ రకం(Generator expressions)

జాబితా కాంప్రహెన్షన్స్ సంజ్ఞామానంలోని స్క్వేర్ బ్రాకెట్‌లు [] రౌండ్ బ్రాకెట్‌లుగా ఉపయోగించబడితే (), టుపుల్‌కు బదులుగా జనరేటర్ తిరిగి ఇవ్వబడుతుంది. దీనిని జనరేటర్ వ్యక్తీకరణలు అంటారు.

జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం యొక్క ఉదాహరణ.

l = [i**2 for i in range(5)]

print(l)
# [0, 1, 4, 9, 16]

print(type(l))
# <class 'list'>

జనరేటర్ వ్యక్తీకరణకు ఉదాహరణ. మీరు జనరేటర్‌ను ప్రింట్() చేస్తే, అది దాని కంటెంట్‌లను ప్రింట్ అవుట్ చేయదు, కానీ మీరు దానిని ఫర్ స్టేట్‌మెంట్‌తో అమలు చేస్తే, మీరు కంటెంట్‌లను పొందవచ్చు.

g = (i**2 for i in range(5))

print(g)
# <generator object <genexpr> at 0x10af944f8>

print(type(g))
# <class 'generator'>

for i in g:
    print(i)
# 0
# 1
# 4
# 9
# 16

జనరేటర్ ఎక్స్‌ప్రెషన్‌లు షరతులతో కూడిన బ్రాంచింగ్ మరియు గూడును if అలాగే లిస్ట్ కాంప్రహెన్షన్ నోటేషన్‌ని ఉపయోగించి అనుమతిస్తాయి.

g_cells = ((row, col) for row in range(0, 3)
           for col in range(0, 2) if col == row)

print(type(g_cells))
# <class 'generator'>

for i in g_cells:
    print(i)
# (0, 0)
# (1, 1)

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

జెనరేటర్ వ్యక్తీకరణ మాత్రమే ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్ అయితే, రౌండ్ బ్రాకెట్లు () విస్మరించబడతాయి.

print(sum([i**2 for i in range(5)]))
# 30

print(sum((i**2 for i in range(5))))
# 30

print(sum(i**2 for i in range(5)))
# 30

ప్రాసెసింగ్ వేగం విషయానికొస్తే, అన్ని మూలకాలు ప్రాసెస్ చేయబడినప్పుడు జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం తరచుగా జనరేటర్ సంజ్ఞామానం కంటే వేగంగా ఉంటుంది.

అయితే, అన్ని() లేదా ఏదైనా()తో తీర్పునిచ్చేటప్పుడు, ఉదాహరణకు, తప్పు లేదా ఒప్పు ఉన్నప్పుడు ఫలితం నిర్ణయించబడుతుంది, కాబట్టి జనరేటర్ వ్యక్తీకరణలను ఉపయోగించడం జాబితా కాంప్రహెన్షన్ సంజ్ఞామానాన్ని ఉపయోగించడం కంటే వేగంగా ఉంటుంది.

టుపుల్ కాంప్రహెన్షన్ సంజ్ఞామానం లేదు, కానీ మీరు టుపుల్ () యొక్క ఆర్గ్యుమెంట్‌గా జనరేటర్ వ్యక్తీకరణను ఉపయోగిస్తే, మీరు కాంప్రహెన్షన్ సంజ్ఞామానంలో టుపుల్‌ను రూపొందించవచ్చు.

t = tuple(i**2 for i in range(5))

print(t)
# (0, 1, 4, 9, 16)

print(type(t))
# <class 'tuple'>