पाइथन सूची बुझाइ सङ्केत प्रयोग गर्दै

व्यापार

पाइथनमा, नयाँ सूची सिर्जना गर्दा सूची बुझाइ सङ्केत प्रयोग गर्न सरल छ।(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]

एउटै प्रक्रिया नक्शा() को साथ गर्न सकिन्छ, तर सूची बुझ्ने नोटेशन यसको सरलता र स्पष्टताको लागि रुचाइएको छ।

यदि द्वारा सशर्त ब्रान्चिङको साथ समझको सङ्केत सूचीबद्ध गर्नुहोस्

यदि सम्भव छ भने सशर्त शाखाहरू। यदि पोस्टफिक्समा निम्नानुसार लेख्नुहोस्।

[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 अपरेटर निम्नानुसार लेख्न सकिन्छ

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

यदि प्रयोग गर्दा विचार पहिले जस्तै हो।

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'>
Copied title and URL