Python में स्ट्रिंग सर्च और रिप्लेस: in, .find(), .index(), .count(), और .replace()

किसी स्ट्रिंग में पाठ मौजूद है या नहीं, यह जांचने के लिए .find() या .index() का सहारा लेना आम है—और फिर ValueError जैसी अजीब समस्याओं या स्ट्रिंग की शुरुआत पर छूटा हुआ मिलान देखने को मिल सकता है। केस-सेंसिटिविटी, स्लाइस सीमाओं में एक-से-गलती, और यह तथ्य कि str पर .contains() मेथड नहीं है, भ्रम बढ़ाते हैं। समाधान सीधा है: काम के लिए सही टूल का उपयोग करें। अस्तित्व जांच के लिए हम in ऑपरेटर पर, स्थानों के लिए .find()/.index() पर, गणना के लिए .count() पर, और प्रतिस्थापन के लिए .replace() पर निर्भर करते हैं—और जब केस-इनसेंसिटिविटी मायने रखती है, तो कुछ Unicode-सुरक्षित तकनीकों का उपयोग करते हैं।

Python सबस्ट्रिंग सर्च को कैसे संभालता है

Python की टेक्स्ट स्ट्रिंग्स Unicode होती हैं। सबस्ट्रिंग ऑपरेशन डिफ़ॉल्ट रूप से केस-सेंसिटिव हैं और तेज़ी के लिए C में इम्प्लीमेंट किए गए हैं। यह जांचने का सबसे सीधा तरीका कि कोई टेक्स्ट स्ट्रिंग के भीतर आता है या नहीं, in ऑपरेटर है, जो स्ट्रिंग के __contains__() इम्प्लीमेंटेशन का उपयोग करते हुए Boolean लौटाता है। जब आपको स्थान या गणना चाहिए, तो समर्पित str मेथड्स का उपयोग करें। वैकल्पिक start और end पैरामीटर्स स्लाइस सेमैटिक्स का पालन करते हैं: start समावेशी है; end बहिष्कृत है।

in के साथ समावेशन

जब आपको केवल यह परवाह है कि सबस्ट्रिंग मौजूद है या नहीं, तो "needle" in haystack का उपयोग करें। यह पठनीय है और इंडेक्स हैंडलिंग से बचाता है।

text = "Banana bread"
print("ban" in text)   # False (case-sensitive)
print("Ban" in text)   # Trueसंचालित द्वारा

केस-इनसेंसिटिव जांच के लिए, दोनों ओर नॉर्मलाइज़ करें। .casefold() .lower() की तुलना में अधिक Unicode-सचेत है और केसलेस मिलान के लिए मेरा डिफ़ॉल्ट है।

pattern = "ban"
print(pattern.casefold() in text.casefold())  # Trueसंचालित द्वारा

• कब उपयोग करें: त्वरित अस्तित्व जांच, इनपुट वैलिडेशन, सूचियों को फ़िल्टर करना।

• किनारी मामला: "" in s हमेशा True होता है (खाली स्ट्रिंग हर स्ट्रिंग में होती है)।

str.find() मेथड

सिन्टैक्स

str.find() सबस्ट्रिंग का सबसे कम इंडेक्स लौटाता है, या न मिलने पर -1। वैकल्पिक start और end खोज को सीमित करते हैं।

s.find(substring, start=0, end=len(s))संचालित द्वारा

उदाहरण और उपयोग के मामले

जब आपको स्थिति चाहिए और आप एक्सेप्शन के बिना “नहीं मिला” मान संभाल सकते हैं, तो .find() का उपयोग करें।

tagline = "Ship fast. Fix faster."
print(tagline.find("fast"))         # 5
print(tagline.find("fast", 6))      # 16
print(tagline.find("slow"))         # -1संचालित द्वारा

अस्तित्व जांच के लिए if s.find(sub): न लिखें। यदि मिलान इंडेक्स 0 पर है, तो शर्त falsey होगी।

name = "Alice"
if name.find("A"):         # Wrong: 0 is Falsey
    print("Found A")       # Will not run
if name.find("A") != -1:   # Correct
    print("Found A")संचालित द्वारा

str.index() मेथड

सिन्टैक्स

.index() .find() जैसा है, पर सबस्ट्रिंग न मिलने पर ValueError उठाता है।

s.index(substring, start=0, end=len(s))संचालित द्वारा

उदाहरण और कब चुनें

जब सबस्ट्रिंग का होना अनिवार्य हो और असफलता पर एक्सेप्शन सही फ़ेल्योर मोड हो, तब .index() का उपयोग करें।

product = "USB-C Cable"
print(product.index("Cable"))  # 6

try:
    product.index("HDMI")
except ValueError:
    print("Required label missing")संचालित द्वारा

str.count() मेथड

सिन्टैक्स

.count() गैर-ओवरलैपिंग उपस्थिति की संख्या लौटाता है। यह start और end सीमाएँ भी स्वीकार करता है।

s.count(substring, start=0, end=len(s))संचालित द्वारा

उदाहरण और किनारी मामले

त्वरित गिनती के लिए .count() का उपयोग करें, regex के बिना।

log_line = "ERROR: timeout. ERROR: retry. ERROR: gave up."
print(log_line.count("ERROR"))     # 3
print(log_line.count("WARN"))      # 0संचालित द्वारा

विशेष मामला: खाली स्ट्रिंग।

print("abc".count(""))   # 4 (len(s) + 1)संचालित द्वारा

str.replace() मेथड

.replace() एक नई स्ट्रिंग लौटाता है जिसमें old की उपस्थितियों को new से बदल दिया जाता है। रिप्लेसमेंट सीमित करने के लिए count का उपयोग करें।

s.replace(old, new, count=-1)संचालित द्वारा

सबस्ट्रिंग्स को बदलना

यह मेथड इन-प्लेस नहीं है; यह एक कॉपी लौटाता है।

message = "The red house is between the blue house and the old house"
print(message.replace("house", "car"))
# The red car is between the blue car and the old car

print(message.replace("house", "car", 2))
# The red car is between the blue car and the old houseसंचालित द्वारा

केस-इनसेंसिटिव रिप्लेसमेंट

मूल केस-पैटर्न को बनाए रखते हुए केस-इनसेंसिटिव रिप्लेसमेंट के लिए re.IGNORECASE के साथ re.sub() का उपयोग करें, या यदि आपको मूल केसिंग बनाए रखने की आवश्यकता नहीं है तो .casefold() से नॉर्मलाइज़ करें।

.casefold() के साथ केस-इनसेंसिटिव मिलान

.casefold() आक्रामक, Unicode-सचेत केस नॉर्मलाइज़ेशन प्रदान करता है और केसलेस जांच के लिए .lower() पर वरीय है।

query = "straße"           # German 'straße'
text  = "STRASSE und mehr" # Uppercase variant
print(query.casefold() in text.casefold())  # Trueसंचालित द्वारा

प्रिफिक्स और सफिक्स के लिए संबंधित टूल्स

ज्ञात शुरुआत/अंत के लिए समर्पित मेथड्स का उपयोग करें—वे स्लाइसिंग या regex से तेज़ और स्पष्ट हैं:

• s.startswith(prefix) और s.endswith(suffix) (एकाधिक विकल्पों के लिए ट्यूपल स्वीकार करते हैं)

• s.removeprefix(prefix) और s.removesuffix(suffix) (Python 3.9+)

filename = "draft_report_v2.pdf"
print(filename.removeprefix("draft_"))  # report_v2.pdf
print(filename.endswith((".pdf", ".docx")))  # Trueसंचालित द्वारा

Pandas कॉलम्स के साथ काम करना

DataFrame कॉलम में कई स्ट्रिंग्स को खोजते समय, वेक्टराइज़्ड स्ट्रिंग मेथड्स का उपयोग करें। लिटरल टेक्स्ट मिलान के लिए regex=False सेट करें।

import pandas as pd

cities = pd.Series(["New York", "Yorktown", None, "Toronto"], dtype="string")
mask = cities.str.contains("York", regex=False, na=False)
print(mask.tolist())  # [True, True, False, False]संचालित द्वारा

टिप्पणियाँ:

• डिफ़ॉल्ट रूप से regex=True होता है, इसलिए . जैसे विशेष अक्षर तब तक किसी भी अक्षर से मेल खाते हैं जब तक आप regex अक्षम नहीं करते।

• नल मानों को na=... के माध्यम से संभालें। StringDtype के साथ, मिसिंग मान मास्क में डिफ़ॉल्ट रूप से False होते हैं।

आम गलतियाँ और किनारी मामले

• str पर .contains() नहीं: "sub" in s का उपयोग करें। "abc".contains("a") AttributeError उठाता है।

• .find() की truthiness: इंडेक्स 0 falsey है; != -1 से तुलना करें या अस्तित्व के लिए in को प्राथमिकता दें।

• .index() raises: यदि सबस्ट्रिंग अनुपस्थित हो सकती है, तो ValueError को संभालें।

• खाली सबस्ट्रिंग: "" in s True है; s.find("") 0 लौटाता है; s.count("") len(s)+1 होता है।

• केस सेंसिटिविटी: जब तक आप नॉर्मलाइज़ न करें या regex फ्लैग्स न उपयोग करें, सभी ऑपरेशन केस-सेंसिटिव होते हैं।

• बाइट्स बनाम टेक्स्ट: खोज में bytes और str को न मिलाएँ; प्रकार मिलाने के लिए डिकोड या एन्कोड करें।

• सबस्ट्रिंग सेमैटिक्स: "ab" in "cat,bat" False है, भले ही "a" और "b" अलग-अलग मौजूद हों—मिलान सन्निहित (contiguous) होना चाहिए।

हैंड्स-ऑन उदाहरण जिन्हें आप चला सकते हैं

ये छोटे स्निपेट्स सही पैटर्न दिखाते हैं और आम गॉटचाज़ को उजागर करते हैं।

अस्तित्व जांच

headline = "Where's Waldo?"
print("Waldo" in headline)          # True
print("Wenda" in headline)          # False
print(headline.find("Waldo"))       # 8
print(headline.find("Wenda"))       # -1संचालित द्वारा

start और end के साथ सीमित खोज

End बहिष्कृत है, इसलिए खोज की स्थितियाँ स्लाइस सेमैटिक्स को दर्शाती हैं।

headline = "Where's Waldo?"
print(headline.find("Waldo", 0, 6))   # -1 (searching "Where'")
print(headline.find("Waldo", 0, 13))  # 8  (searching up to the 'o' in Waldo)संचालित द्वारा

गिनती और रिप्लेसमेंट

inventory = "apple, apple, pear, apple"
print(inventory.count("apple"))                # 3
print(inventory.replace("apple", "orange", 2)) # orange, orange, pear, appleसंचालित द्वारा

Python स्ट्रिंग सर्च और रिप्लेस अभ्यास उदाहरण 

यह उदाहरण मूवी ब्लर्ब्स की सूची को प्रोसेस करता है। यह अस्तित्व जांच, सीमित खोज, और regex के बिना सुरक्षित रिप्लेसमेंट दर्शाता है।

blurbs = [
    "Critics say the lead actor delivers a career-best performance.",
    "Fans argue the actor actor scene was intentionally repetitive.",
    "A clever cameo steals the show."
]

for blurb in blurbs:
    # Check whether "actor" appears between indexes 20 and 40 (end exclusive).
    window_has_actor = "actor".casefold() in blurb[20:40].casefold()
    if not window_has_actor:
        print("Window check: actor not found")
        continue

    # If "actor actor" appears, collapse to a single "actor".
    if "actor actor" in blurb:
        print(blurb.replace("actor actor", "actor"))
    # If "actor actor actor" appears, collapse to a single "actor".
    elif "actor actor actor" in blurb:
        print(blurb.replace("actor actor actor", "actor"))
    else:
        print(blurb)संचालित द्वारा

आउटपुट:

Window check: actor not found
Fans argue the actor scene was intentionally repetitive.
Window check: actor not foundसंचालित द्वारा

निष्कर्ष

सरल समावेशन के लिए in ऑपरेटर का उपयोग करें, स्थानों की ज़रूरत पर .find() या .index(), गैर-ओवरलैपिंग गिनती के लिए .count(), और प्रतिस्थापन के लिए .replace()। केस-इनसेंसिटिव जांच के लिए .casefold() से नॉर्मलाइज़ करें, और उचित होने पर समर्पित प्रिफिक्स/सफिक्स हेल्पर्स को प्राथमिकता दें। हम .find() के परिणामों को Boolean में कन्वर्ट करने से बचते हैं और स्ट्रिंग कोड को सही और स्पष्ट रखने के लिए खाली-सबस्ट्रिंग व्यवहार को विशेष मामला मानते हैं।