Python filter(): केवल वही रखें जिसकी ज़रूरत है

Python में फ़िल्टरिंग सबसे आम कार्यों में से एक है, इसी कारण Python इसे आसान बनाता है। डेटा को फ़िल्टर करने के सबसे सरल तरीकों में से एक है बिल्ट-इन filter() फ़ंक्शन। जैसा कि नाम से स्पष्ट है, filter() आपको केवल वे आइटम खींचने देता है जो किसी निश्चित शर्त (या शर्तों) को पूरा करते हैं।

यह गाइड बताएगा कि यह कैसे काम करता है, इसे कब उपयोग करना है, और यह अन्य फ़िल्टरिंग टूल्स की तुलना में कैसा है। पढ़ते रहें!

Python filter() क्या करता है

filter() आपको किसी लिस्ट, ट्यूपल, या किसी भी iterable से एलिमेंट निकालने देता है, लेकिन केवल तब जब वे आपके टेस्ट को पास करें। आप एक फ़ंक्शन देते हैं (कभी-कभी इसे प्रेडिकेट भी कहा जाता है) जो हर आइटम लेता है और True या False लौटाता है। अगर टेस्ट पास होता है (अर्थात आपका फ़ंक्शन True लौटाता है) तो filter() उसे रखता है। वरना, वह आइटम छोड़ देता है। यह काफी स्वाभाविक है, तो आगे बढ़ते हैं।

Python filter() का सिंटैक्स

फ़ॉर्मेट इस प्रकार है:

filter(function, iterable)

• function: वह टेस्ट बताता है जिसे आप हर आइटम पर लागू करना चाहते हैं। इसे एक आर्ग्युमेंट लेना चाहिए और True या False लौटाना चाहिए।

• iterable: कोई लिस्ट, ट्यूपल, स्ट्रिंग, या ऐसा कोई ऑब्जेक्ट देता है जिस पर आप लूप लगा सकें।

जब आप filter() कॉल करते हैं, तो यह सीधे लिस्ट या ट्यूपल नहीं बल्कि एक विशेष फ़िल्टर ऑब्जेक्ट लौटाता है। फ़िल्टर किए गए नतीजों के साथ वास्तव में काम करने के लिए, आप आम तौर पर आउटपुट को लिस्ट या ट्यूपल में रैप करेंगे। यह डिज़ाइन filter() को कुशल रखता है, लेकिन कोड लिखते समय इसे ध्यान में रखना ज़रूरी है।

Python filter() के उदाहरण

थोड़ा अभ्यास करते हैं।

कस्टम फ़ंक्शन के साथ Python filter()

आइए filter() को ऐसे फ़ंक्शन के साथ उपयोग करें जिसे हम खुद लिखें।

मान लीजिए आप किसी लिस्ट से केवल सम (even) संख्याएँ रखना चाहते हैं:

def is_even(num):
    return num % 2 == 0

numbers = [1, 2, 3, 4, 5, 6]
result = filter(is_even, numbers)
print(list(result))

यह प्रिंट करेगा:

[2, 4, 6]

ध्यान दें कि is_even जाँचता है कि कोई संख्या 2 से विभाज्य है या नहीं। filter() हमारी कस्टम फ़ंक्शन से हर आइटम का टेस्ट करता है और वही रखता है जो हमारा टेस्ट पास करें।

लैम्ब्डा फ़ंक्शंस के साथ Python filter()

बेशक, हर फ़िल्टर के लिए पूरे फ़ंक्शन की परिभाषा ज़रूरी नहीं होती। कभी-कभी आपका नियम इतना सरल या किसी एक जगह तक सीमित होता है कि नामित फ़ंक्शन बनाना ज़्यादा काम लगता है।

वही सम-संख्या वाला उदाहरण यहाँ lambda के साथ, संक्षिप्त, इन-प्लेस टेस्ट के रूप में:

numbers = [1, 2, 3, 4, 5, 6] 
result = filter(lambda x: x % 2 == 0, numbers) 
print(list(result))

आपको पहले जैसा ही आउटपुट मिलेगा।

filter() के साथ lambda का उपयोग खासकर तब सामान्य है जब आप कोड को छोटा और केंद्रित रखना चाहते हैं। यह एकबारगी फ़िल्टरिंग कार्यों के लिए उपयुक्त है, जिससे आप अपना नियम वहीं व्यक्त कर पाते हैं जहाँ उसकी ज़रूरत हो।

फ़ंक्शन के रूप में None के साथ Python filter()

कभी-कभी, आप खाली या फ़ॉल्स वैल्यूज़ को filter() के जरिए हटाना चाहते हैं। जैसे 0, खाली स्ट्रिंग्स, None, या False, और हम यह किसी कस्टम फ़ंक्शन के बिना करना चाहते हैं।

Python में इसके लिए एक तरकीब है: अगर आप filter() में function आर्ग्युमेंट को None सेट करते हैं, तो filter() अपने-आप वे सभी आइटम हटा देगा जिन्हें Python False मानता है।

उदाहरण देखें:

items = [0, 1, '', 'hello', [], [2, 3], None, False, True] 
result = filter(None, items) 
print(list(result))

यह प्रिंट करेगा:

[1, 'hello', [2, 3], True]

टेक्स्ट डेटा को फ़िल्टर करना

अब filter() को एक व्यावहारिक, रोज़मर्रा की समस्या पर लागू करते हैं। मान लें आपके पास शब्दों की एक लिस्ट है और आपको केवल वे चाहिए जो 'a' से शुरू होते हैं। टेक्स्ट प्रोसेसिंग में इस तरह की लक्षित फ़िल्टरिंग अक्सर आती है।

words = ['apple', 'banana', 'apricot', 'cherry', 'avocado'] 
result = filter(lambda word: word.startswith('a'), words) 
print(list(result))

आपको मिलेगा:

['apple', 'apricot', 'avocado']

एकाधिक शर्तों के साथ फ़िल्टरिंग

कभी-कभी आपके फ़िल्टरिंग मानदंड ज़्यादा जटिल हो जाते हैं। क्या हो अगर आपको ऐसी आइटम चाहिए जो कई शर्तें पूरी करें? आप इसे lambda से ऐसे कर सकते हैं। इस उदाहरण में, हम ऐसी संख्याएँ ढूँढ रहे हैं जो सम भी हों और 10 से बड़ी भी।

numbers = [4, 10, 12, 15, 20, 23, 28] 
result = filter(lambda x: x % 2 == 0 and x > 10, numbers) 
print(list(result))

यह प्रिंट करेगा:

[12, 20, 28]

(अगर शर्तें और भी बढ़ जाएँ, तो स्पष्टता के लिए मैं lambda से नामित फ़ंक्शन पर स्विच करने पर विचार करूँगा।)

filter() बनाम List Comprehension

List comprehension भी आइटम चुनने का एक लोकप्रिय तरीका है। दोनों तरीक़े आपको डेटा फ़िल्टर करने देते हैं, लेकिन प्रत्येक की अपनी शैली है।

सम-संख्या वाला उदाहरण फिर से, इस बार list comprehension के साथ:

numbers = [1, 2, 3, 4, 5, 6] 
result = [x for x in numbers if x % 2 == 0] 
print(result)

[2, 4, 6]

filter() और list comprehension दोनों काम कर देंगे। सरल फ़िल्टर्स के लिए list comprehension अक्सर पढ़ने में आसान होते हैं, खासकर जब नियम छोटा और सरल हो।

दूसरी ओर, filter() तब अच्छा काम करता है जब आप पहले से फ़ंक्शंस के साथ काम कर रहे हों, या जब आप कई प्रोसेसिंग चरणों को एकसाथ जोड़ना चाहते हों।

और उन्नत उपयोग

आइए कुछ और दिलचस्प मामलों को देखें:

अन्य iterables के साथ filter()

जैसे हमने लिस्ट के साथ किया, filter() किसी भी iterable के साथ काम करता है, जैसे ट्यूपल, सेट — यहाँ तक कि generator expressions के साथ भी। यह जानना अच्छा है क्योंकि आपका डेटा हमेशा लिस्ट के रूप में नहीं होगा।

ट्यूपल को फ़िल्टर करने का तरीका:

numbers = (10, 15, 20, 25, 30) 
result = filter(lambda x: x > 20, numbers) 
print(tuple(result))

यह प्रिंट करेगा:

(25, 30)

जब आपको नतीजों का सीधे उपयोग करना हो, तो फ़िल्टर ऑब्जेक्ट को मनचाहे टाइप (लिस्ट, ट्यूपल, आदि) में बदलना याद रखें।

मैंने जेनरेटर का भी ज़िक्र किया, तो पूरी तरह से बताने के लिए, जेनरेटर के साथ फ़िल्टरिंग का एक उदाहरण भी देखें:

numbers = (x for x in range(10))
result = filter(lambda x: x % 2 == 0, numbers)
print(list(result))

यह एक जेनरेटर है क्योंकि यह लाइन: numbers = (x for x in range(10)) एक जेनरेटर ऑब्जेक्ट बनाती है। (यह lazy होता है और सभी वैल्यूज़ एक साथ जेनरेट नहीं करता।)

अंतिम लाइन: print(list(result)) आलसी फ़िल्टर ऑब्जेक्ट को लिस्ट में बदलकर evaluation करवा देती है।

filter() को map() के साथ जोड़ना

क्या हो अगर आप डेटा को फ़िल्टर भी करना चाहते हों और ट्रांसफ़ॉर्म भी, जैसे हमारे अगले उदाहरण में, किसी लिस्ट की केवल सम संख्याओं का वर्ग करना?

Python इसे आसान बनाता है क्योंकि आप filter() और map() को जोड़ सकते हैं। पहले, filter() वे आइटम चुनता है जो आपको चाहिए, और फिर map() हर एक पर दूसरा फ़ंक्शन लगाता है।

व्यवहार में यह ऐसे दिखता है:

numbers = [1, 2, 3, 4, 5, 6] 
evens = filter(lambda x: x % 2 == 0, numbers) 
squared = map(lambda x: x ** 2, evens) 
print(list(squared))

यह प्रिंट करेगा:

[4, 16, 36]

filter() और map() को चेन करके, आप स्पष्ट, पठनीय डेटा पाइपलाइंस बना सकते हैं—पहले वही आइटम चुनें जो मायने रखते हैं, फिर ज़रूरत अनुसार उन्हें बदलें। अपने काम में इस पैटर्न का उपयोग करने के अवसर मिलेंगे।

ध्यान देने योग्य बातें

भले ही filter() उपयोगी है, कुछ आम गलतियाँ होती हैं:

• filter() एक फ़िल्टर ऑब्जेक्ट लौटाता है, लिस्ट नहीं। अगर आप तुरंत नतीजे देखने की उम्मीद करते हैं तो यह उलझा सकता है। नतीजे देखने या दोबारा उपयोग करने के लिए इसे हमेशा लिस्ट (या ट्यूपल) में रैप करें।

• filter() एक समय में केवल एक iterable के साथ काम करता है। अगर आप कई लिस्टों के आधार पर फ़िल्टर करना चाहते हैं, तो आपको उन्हें zip करना होगा या दूसरा तरीका अपनाना होगा।

• filter() lazy है। यह तब तक वास्तव में डेटा प्रोसेस नहीं करता जब तक आप इसे लिस्ट, ट्यूपल में न बदलें या उस पर लूप न चलाएँ। डिबगिंग के समय इस व्यवहार को ध्यान में रखें।

निष्कर्ष

जैसा आपने देखा, Python का filter() फ़ंक्शन केवल ज़रूरी चीज़ों को निकालकर डेटा को जल्दी से साफ़ करने का एक तरीका देता है। चाहे आप एकबारगी lambda लिख रहे हों या नामित फ़ंक्शन प्लग कर रहे हों, filter() मददगार है। 

अगर आपको filter() के उपयोग पर स्पष्टता चाहिए, या आपको यह सरल लगा हो और आप आगे सीखना चाहते हों, तो हमारे संसाधन मदद करेंगे। मैं हमारे Python Programming Fundamentals स्किल ट्रैक की सिफारिश करता/करती हूँ।