पायथन सूची आकलन संकेतन वापरणे

व्यवसाय

पायथनमध्ये, नवीन सूची तयार करताना सूची आकलन नोटेशन वापरणे सोपे आहे.(List comprehensions)

या लेखात आपण प्रथम पुढील गोष्टींवर चर्चा करू

  • सूची आकलन नोटेशनचा मूलभूत प्रकार
  • जर द्वारे कंडिशनल ब्रँचिंगसह आकलन नोटेशन सूचीबद्ध करा
  • टर्नरी ऑपरेटरसह संयोजन (जर इतर सारखी प्रक्रिया असेल तर)
  • 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 लिहा.

[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]

हीच प्रक्रिया filter() सह केली जाऊ शकते, परंतु सूची आकलन नोटेशनला त्याच्या साधेपणासाठी आणि स्पष्टतेसाठी प्राधान्य दिले जाते.

टर्नरी ऑपरेटरसह संयोजन (जर इतर सारखी प्रक्रिया असेल तर)

वरील उदाहरणामध्ये, निकष पूर्ण करणाऱ्या घटकांवरच प्रक्रिया केली जाते आणि जे निकष पूर्ण करत नाहीत त्यांना नवीन सूचीमधून वगळण्यात आले आहे.

जर तुम्हाला परिस्थितीनुसार प्रक्रिया बदलायची असेल किंवा तुम्हाला अट पूर्ण न करणाऱ्या घटकांवर वेगळ्या पद्धतीने प्रक्रिया करायची असेल, तर तिरंगी ऑपरेटर वापरा.

Python मध्ये, ternary operator खालीलप्रमाणे लिहिता येईल

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]

zip() आणि enumerate() सह संयोजन

फॉर स्टेटमेंटमध्ये वापरल्या जाणार्‍या उपयुक्त फंक्शन्समध्ये zip(), जे एकापेक्षा जास्त पुनरावृत्ती एकत्र करते, आणि enumerate(), जे त्याच्या निर्देशांकासह मूल्य परत करते.

अर्थात, zip() आणि enumerate() वापरणे शक्य आहे सूची आकलन नोटेशनसह. हे एक विशेष वाक्यरचना नाही, आणि जर तुम्ही फॉर स्टेटमेंटसह पत्रव्यवहाराचा विचार केला तर ते अवघड नाही.

zip() चे उदाहरण.

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')]

enumerate() चे उदाहरण.

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

जनरेटर एक्स्प्रेशन्स इफ तसेच यादी आकलन नोटेशन वापरून कंडिशनल ब्रँचिंग आणि नेस्टिंगला अनुमती देतात.

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

प्रक्रियेच्या गतीसाठी, जेव्हा सर्व घटकांवर प्रक्रिया केली जाते तेव्हा सूची आकलन नोटेशन जनरेटर नोटेशनपेक्षा वेगवान असते.

तथापि, सर्व() किंवा कोणत्याही() सह न्याय करताना, उदाहरणार्थ, खोटे किंवा सत्य उपस्थित असताना परिणाम निर्धारित केला जातो, म्हणून जनरेटर अभिव्यक्ती वापरणे सूची आकलन संकेतन वापरण्यापेक्षा जलद असू शकते.

कोणतेही ट्यूपल आकलन नोटेशन नाही, परंतु जर तुम्ही जनरेटर अभिव्यक्ती tuple() च्या युक्तिवाद म्हणून वापरत असाल, तर तुम्ही आकलन नोटेशनमध्ये ट्यूपल तयार करू शकता.

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

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

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