पायथन सूची समझ संकेतन का उपयोग करना

व्यापार

पायथन में, नई सूची बनाते समय सूची समझ संकेतन का उपयोग करना सरल है।(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 . द्वारा

यदि संभव हो तो सशर्त शाखाकरण भी संभव है। यदि पोस्टफिक्स में इस प्रकार लिखें।

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

ज़िप के साथ संयोजन () और गणना ()

उपयोगी फ़ंक्शंस जो अक्सर कथन के लिए उपयोग किए जाते हैं, उनमें ज़िप (), जो कई पुनरावृत्तियों को जोड़ती है, और एन्यूमरेट (), जो इसके सूचकांक के साथ एक मान देता है।

बेशक, सूची बोध संकेतन के साथ zip() और enumerate() का उपयोग करना संभव है। यह एक विशेष वाक्यविन्यास नहीं है, और यदि आप के लिए कथन के साथ पत्राचार पर विचार करते हैं तो यह मुश्किल नहीं है।

ज़िप का उदाहरण ()।

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

इफ का उपयोग करते समय विचार पहले जैसा ही है।

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 के रूप में निर्दिष्ट करें।

{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}

कुंजियों और मानों की सूची से एक नया शब्दकोश बनाने के लिए, ज़िप () फ़ंक्शन का उपयोग करें।

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

प्रसंस्करण गति के लिए, सभी तत्वों को संसाधित करते समय सूची समझ नोटेशन जेनरेटर नोटेशन से अक्सर तेज़ होता है।

हालांकि, सभी () या किसी भी () के साथ निर्णय करते समय, उदाहरण के लिए, परिणाम गलत या सत्य मौजूद होने पर निर्धारित होता है, इसलिए जनरेटर अभिव्यक्तियों का उपयोग सूची समझ नोटेशन का उपयोग करने से तेज़ हो सकता है।

कोई टपल समझ संकेतन नहीं है, लेकिन यदि आप टुपल () के तर्क के रूप में एक जनरेटर अभिव्यक्ति का उपयोग करते हैं, तो आप समझ संकेतन में एक टपल उत्पन्न कर सकते हैं।

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

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

print(type(t))
# <class 'tuple'>
Copied title and URL