पायथन का उपयोग करके स्ट्रिंग्स की तुलना करना

पायथन में, स्ट्रिंग्स वर्णों के अनुक्रम होते हैं, जो प्रभावी रूप से एक ऑब्जेक्ट के रूप में मेमोरी में संग्रहीत होते हैं। का उपयोग करके प्रत्येक वस्तु की पहचान की जा सकती है id() विधि, जैसा कि आप नीचे देख सकते हैं। पायथन मेमोरी में समान मूल्य वाली वस्तुओं का पुन: उपयोग करने का प्रयास करता है, जिससे पायथन में वस्तुओं की तुलना बहुत तेज हो जाती है:

$ python
Python 3.9.0 (v3.9.0:9cf6752276, Oct  5 2020, 11:29:23) 
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> a = "abc"
>>> b = "abc"
>>> c = "def"
>>> print (id(a), id(b), id(c))
(139949123041320, 139949123041320, 139949122390576)
>>> quit()

स्ट्रिंग्स की तुलना करने के लिए, पायथन ऐसा करने के लिए कुछ अलग-अलग ऑपरेटरों की पेशकश करता है। सबसे पहले, हम उन्हें नीचे और अधिक विस्तार से समझाएंगे। दूसरा, हम दोनों पर विचार करेंगे string और re मॉड्यूल, जिसमें केस-असंवेदनशील और सटीक मिलान को संभालने के तरीके शामिल हैं। तीसरा, मल्टी-लाइन स्ट्रिंग्स से निपटने के लिए डिफ़्लिब मॉड्यूल काफी उपयोगी है. कई उदाहरण आपको यह समझने में मदद करेंगे कि उनका उपयोग कैसे करें।

स्ट्रिंग्स की तुलना == और != ऑपरेटर्स से करें

एक बुनियादी तुलना ऑपरेटर के रूप में आप इसका उपयोग करना चाहेंगे == और !=. वे बिल्कुल उसी तरह से काम करते हैं जैसे पूर्णांक और फ़्लोट मानों के साथ। == ऑपरेटर लौटता है True यदि सटीक मिलान है, अन्यथा False लौटा दी जाएगी। इसके विपरीत, != ऑपरेटर लौटता है True यदि कोई मिलान नहीं है और अन्यथा वापस आ जाता है False. लिस्टिंग 1 यह प्रदर्शित करता है.

में for लूप, स्विस शहर "लॉज़ेन" के नाम वाली एक स्ट्रिंग की तुलना अन्य स्थानों की सूची से एक प्रविष्टि के साथ की जाती है, और तुलना परिणाम स्टडआउट पर मुद्रित होता है।

लिस्टिंग 1:

listOfPlaces = ["Berlin", "Paris", "Lausanne"]
currentCity = "Lausanne"

for place in listOfPlaces:
    print (f"comparing {place} with {currentCity}: %{place == currentCity}")

आउटपुट के ऊपर से पायथन स्क्रिप्ट चलाना इस प्रकार है:

$ python3 comparing-strings.py
comparing Berlin with Lausanne: False
comparing Paris with Lausanne: False
comparing Lausanne with Lausanne: True

RSI == और is ऑपरेटरों

पायथन में दो तुलना ऑपरेटर हैं == और is. पहली नजर में ये एक जैसे ही लगते हैं, लेकिन असल में ऐसा नहीं है।

== दो चरों की उनके द्वारा दर्शाए गए मान के आधार पर तुलना करता है। इसके विपरीत, is ऑपरेटर मेमोरी में ऑब्जेक्ट आईडी के आधार पर दो वेरिएबल्स की तुलना करता है।

जॉन (डो) और जॉन (मो) दोनों को जॉन कहा जाता है। यदि हम उन्हें केवल उनके नामों तक सीमित कर सकें, तो वे मूल्य में समान होंगे, लेकिन फिर भी गुणात्मक रूप से दो अलग-अलग लोग होंगे।

अगला उदाहरण दर्शाता है कि स्ट्रिंग मानों वाले तीन चरों के लिए। दो चर a और b समान मूल्य है, और मेमोरी उपयोग को कम करने के लिए पायथन एक ही ऑब्जेक्ट को संदर्भित करता है।

यह डिफ़ॉल्ट रूप से सरल प्रकार और स्ट्रिंग के लिए किया जाता है, लेकिन अन्य ऑब्जेक्ट के लिए नहीं:

>>> a = 'hello'
>>> b = 'hello'
>>> c = 'world'
>>> a is b
True
>>> a is c
False
>>> id(a)
140666888153840
>>> id(b)
140666888153840
>>> 

जैसे ही मान बदलता है, पायथन ऑब्जेक्ट को पुनः स्थापित करेगा और वेरिएबल असाइन करेगा। अगले कोड स्निपेट में b 2 का मान प्राप्त होता है, और उसके बाद b और c एक ही वस्तु का संदर्भ लें:

>>> b = 'world'
>>> id(b)
140666888154416
>>> id(c)
140666888154416

अधिक तुलना ऑपरेटर

किसी शब्दावली क्रम के संबंध में तुलना के लिए आप तुलना ऑपरेटरों का उपयोग कर सकते हैं <, >, <=, तथा >=. तुलना स्वयं चरित्र दर चरित्र की जाती है। क्रम वर्णमाला में वर्णों के क्रम पर निर्भर करता है। यह क्रम उस वर्ण तालिका पर निर्भर करता है जो पायथन कोड निष्पादित करते समय आपकी मशीन पर उपयोग में है।

ध्यान रखें कि आदेश केस-संवेदी है। लैटिन वर्णमाला के उदाहरण के रूप में, "बस" "बस" से पहले आता है। लिस्टिंग 2 दिखाता है कि ये तुलना ऑपरेटर व्यवहार में कैसे काम करते हैं।

लिस्टिंग 2:

listOfPlaces = ["Berlin", "Paris", "Lausanne"]
currentCity = "Lausanne"

for place in listOfPlaces:
    if place < currentCity:
            print (f"{place} comes before {currentCity}")
    elif place > currentCity:
            print (f"{place} comes after {currentCity}")
    else:
            print (f"{place} is equal to {currentCity}")

आउटपुट के ऊपर से पायथन स्क्रिप्ट चलाना इस प्रकार है:

$ python3 comparing-strings-order.py
Berlin comes before Lausanne
Paris comes after Lausanne
Lausanne is equal to Lausanne

केस-असंवेदनशील स्ट्रिंग तुलना

पिछले उदाहरण स्ट्रिंग्स के बीच सटीक मिलान पर केंद्रित थे। केस-असंवेदनशील तुलनाओं की अनुमति देने के लिए पायथन विशेष स्ट्रिंग विधियाँ प्रदान करता है जैसे upper() और lower(). ये दोनों सीधे स्ट्रिंग ऑब्जेक्ट के तरीकों के रूप में उपलब्ध हैं।

upper() संपूर्ण स्ट्रिंग को बड़े अक्षरों में परिवर्तित करता है, और lower() क्रमशः छोटे अक्षरों में। पर आधारित लिस्टिंग 1 अगली सूची बताती है कि इसका उपयोग कैसे करना है lower() विधि.

लिस्टिंग 3:

listOfPlaces = ["Berlin", "Paris", "Lausanne"]
currentCity = "lausANne"

for place in listOfPlaces:
    print (f"comparing {place} with {place.lower() == currentCity.lower()}: {currentCity}")

आउटपुट इस प्रकार है:

$ python3 comparing-strings-case-insensitive.py
comparing Berlin with lausANne: False
comparing Paris with lausANne: False
comparing Lausanne with lausANne: True

रेगुलर एक्सप्रेशन (RegEx) का उपयोग करके स्ट्रिंग्स की तुलना करें

A नियमित अभिव्यक्ति - या संक्षेप में "रेगेक्स" - वर्णों के एक विशिष्ट पैटर्न को परिभाषित करता है।

पायथन में इस तंत्र का उपयोग करने के लिए आयात करें re मॉड्यूल पहले और एक विशिष्ट पैटर्न को परिभाषित करें, अगला। पुनः, निम्नलिखित उदाहरण पर आधारित है लिस्टिंग 1. खोज पैटर्न "बे" से मेल खाता है, और लोअरकेस या अपरकेस अक्षर से शुरू होता है। संक्षेप में, निम्नलिखित पायथन कोड उन सभी स्ट्रिंग्स को ढूंढता है जिनमें खोज पैटर्न होता है, इससे कोई फर्क नहीं पड़ता कि स्ट्रिंग की कौन सी स्थिति है - शुरुआत में, या मध्य में, या अंत में।

लिस्टिंग 4:

import re


listOfPlaces = ["Bayswater", "Table Bay", "Bejing", "Bombay"]


pattern = re.compile("[Bb]ay")

for place in listOfPlaces:
    if pattern.search(place):
        print (f"{place} matches the search pattern")

आउटपुट इस प्रकार है, और स्थानों की सूची से "बेज़वाटर", "टेबल बे" और "बॉम्बे" से मेल खाता है:

$ python3 comparing-strings-re.py
Bayswater matches the search pattern
Table Bay matches the search pattern
Bombay matches the search pattern

मल्टी-लाइन और सूची तुलना

अभी तक हमारी तुलना केवल कुछ शब्दों पर ही होती रही है। का उपयोग difflib मॉड्यूल पायथन मल्टी-लाइन स्ट्रिंग्स और शब्दों की संपूर्ण सूचियों की तुलना करने का एक तरीका भी प्रदान करता है। आउटपुट को भिन्न टूल के विभिन्न प्रारूपों के अनुसार कॉन्फ़िगर किया जा सकता है।

अगला उदाहरण (लिस्टिंग 5) दो मल्टी-लाइन स्ट्रिंग्स की लाइन दर लाइन तुलना करता है, और विलोपन के साथ-साथ परिवर्धन भी दिखाता है। के आरंभीकरण के बाद Differ पंक्ति 12 में ऑब्जेक्ट की तुलना का उपयोग करके की जाती है compare() पंक्ति 15 में विधि। परिणाम मानक आउटपुट पर मुद्रित होता है:

import difflib
 


original = ["About the IIS", "", "IIS 8.5 has several improvements related", "to performance in large-scale scenarios, such", "as those used by commercial hosting providers and Microsoft's", "own cloud offerings."]


edited = ["About the IIS", "", "It has several improvements related", "to performance in large-scale scenarios."]


d = difflib.Differ()
 

diff = d.compare(original, edited)
 

print ('n'.join(diff))

जैसा कि नीचे देखा गया है, स्क्रिप्ट चलाने से आउटपुट बनता है। विलोपन वाली पंक्तियाँ द्वारा इंगित की जाती हैं - चिह्न जबकि जोड़ वाली रेखाएँ a से प्रारंभ होती हैं + संकेत। इसके अलावा, परिवर्तन वाली पंक्तियाँ प्रश्न चिह्न से शुरू होती हैं। का उपयोग करके परिवर्तन दर्शाए गए हैं ^ तदनुसार स्थिति पर संकेत. संकेतक के बिना पंक्तियाँ अभी भी वही हैं:

$ python comparing-strings-difflib.py
  About the IIS
  
- IIS 8.5 has several improvements related
?  ^^^^^^

+ It has several improvements related
?  ^

- to performance in large-scale scenarios, such
?                                        ^^^^^^

+ to performance in large-scale scenarios.
?                                        ^

- as those used by commercial hosting providers and Microsoft's
- own cloud offerings.

निष्कर्ष

इस लेख में आपने पायथन में स्ट्रिंग्स की तुलना करने के विभिन्न तरीके सीखे हैं। हमें उम्मीद है कि यह अवलोकन आपके डेवलपर के जीवन में प्रभावी ढंग से प्रोग्रामिंग करने में आपकी मदद करेगा।

आभार

लेखिका लेख तैयार करते समय समर्थन के लिए मैंडी न्यूमेयर को धन्यवाद देना चाहती है।