8.1 परिचय

हमने अध्याय 5 में पढ़ा है कि एक अनुक्रम वस्तुओं का एक क्रमबद्ध संग्रह होता है और प्रत्येक वस्तु एक पूर्णांक द्वारा अनुक्रमित होती है। पायथन में निम्नलिखित अनुक्रम डेटा प्रकारों का भी अध्याय 5 में संक्षेप में परिचय दिया गया था।

• स्ट्रिंग्स
• सूचियाँ
• टपल्स

“कंप्यूटर नोटबुक की सबसे बड़ी खासियत यह है कि चाहे आप इसमें कितना भी कुछ भर दें, यह बड़ी या भारी नहीं होती।”

$\quad$ - बिल गेट्स

एक अन्य डेटा प्रकार ‘डिक्शनरी’ का भी अध्याय 5 में परिचय दिया गया था जो मैपिंग श्रेणी में आता है। इस अध्याय में हम स्ट्रिंग्स का विस्तार से अध्ययन करेंगे। सूची को अध्याय 9 में कवर किया जाएगा जबकि टपल और डिक्शनरी की चर्चा अध्याय 10 में की जाएगी।

8.2 स्ट्रिंग्स

स्ट्रिंग एक अनुक्रम है जो एक या अधिक यूनिकोड वर्णों से बनी होती है। यहाँ वर्ण एक अक्षर, अंक, स्पेस या कोई अन्य प्रतीक हो सकता है। एक स्ट्रिंग बनाई जा सकती है एक या अधिक वर्णों को सिंगल, डबल या ट्रिपल कोट में लिखकर।

उदाहरण 8.1

>>> str1 = ‘Hello World!’
>>> str2 = “Hello World!”
>>> str3 = “““Hello World!”””
>>> str4 = ‘‘‘Hello World!’’

str1, str2, str3, str4 सभी स्ट्रिंग वेरिएबल हैं जिनमें समान मान ‘Hello World!’ है। str3 और str4 में संग्रहीत मानों को ट्रिपल कोट्स का उपयोग करके कई पंक्तियों तक बढ़ाया जा सकता है जैसा कि निम्नलिखित उदाहरण में देखा जा सकता है:

>>> str3 = “““Hello World!
welcome to the world of Python”””
>>> str4 = ‘‘‘Hello World!
welcome to the world of Python’’’

पायथन में कोई वर्ण (character) डेटा-प्रकार नहीं होता। एक लम्बाई वाला स्ट्रिंग ही वर्ण माना जाता है।

8.2.1 स्ट्रिंग के वर्णों तक पहुँचना

स्ट्रिंग के प्रत्येक वर्ण को इंडेक्सिंग नामक तकनीक से पहुँचा जा सकता है। इंडेक्स यह बताता है कि स्ट्रिंग का कौन-सा वर्ण चाहिए और वह वर्गाकार कोष्ठक ([ ]) में लिखा जाता है। सबसे बायें पहले वर्ण का इंडेक्स 0 होता है और सबसे दायाँ अंतिम वर्ण का इंडेक्स n-1 होता है, जहाँ n स्ट्रिंग की लम्बाई है। यदि हम इस सीमा से बाहर कोई इंडेक्स दें तो IndexError मिलता है। इंडेक्स अवश्य पूर्णांक (धनात्मक, शून्य या ऋणात्मक) होना चाहिए।

#एक स्ट्रिंग str1 प्रारंभित करता है
>>> str1 = ‘Hello World!’
#str1 का पहला वर्ण देता है
>>> str1[0]
‘H’
#str1 का सातवाँ वर्ण देता है
>>> str1[6]
‘W’
#str1 का अंतिम वर्ण देता है
>>> str1[11]
‘!’
#इंडेक्स सीमा से बाहर है इसलिए त्रुटि देता है
>>> str1[15]
IndexError: string index out of range

इंडेक्स चर तथा संचालकों सहित कोई भी व्यंजक हो सकता है, परंतु वह व्यंजक पूर्णांक परिणाम देना चाहिए।

#एक व्यंजक जो पूर्णांक इंडेक्स देता है
#इसलिए str1 का 6वाँ वर्ण देता है
>>> str1[2+4]
‘W’
#इंडेक्स पूर्णांक होना चाहिए इसलिए त्रुटि
>>> str1[1.5]
TypeError: string indices must be integers

पायथन इंडेक्स मान को नकारात्मक भी होने देता है। नकारात्मक इंडेक्स तब उपयोग किए जाते हैं जब हम स्ट्रिंग के वर्णों को दाएं से बाएं तक पहुंचना चाहते हैं। दाईं ओर से शुरू करते हुए, पहले वर्ण का इंडेक्स -1 होता है और अंतिम वर्ण का इंडेक्स $-\mathrm{n}$ होता है जहां $\mathrm{n}$ स्ट्रिंग की लंबाई है। तालिका 8.1 स्ट्रिंग ‘Hello World!’ में वर्णों की इंडेक्सिंग को दोनों मामलों में दिखाती है, यानी धनात्मक और ऋणात्मक इंडेक्स।

>>> str1[-1] #दाएं से पहला वर्ण देता है
‘!’
>>> str1[-12]#दाएं से अंतिम वर्ण देता है
‘H’

$\hspace{1cm}$ तालिका 8.1 स्ट्रिंग ‘Hello World!’ में वर्णों की इंडेक्सिंग

पायथन में एक अंतर्निहित फ़ंक्शन len() स्ट्रिंग की लंबाई लौटाता है जो पैरामीटर के रूप में पास किया जाता है। उदाहरण के लिए, स्ट्रिंग str1 = ‘Hello World!’ की लंबाई 12 है।

#स्ट्रिंग str1 की लंबाई देता है
>>> len(str1)
12
#स्ट्रिंग की लंबाई n को सौंपी गई है
>>> n = len(str1)
>>> print(n)
12
#स्ट्रिंग का अंतिम वर्ण देता है
>>> str1[n-1]
‘!’
#स्ट्रिंग का पहला वर्ण देता है
>>> str1[-n]
‘H’

8.2.2 स्ट्रिंग अपरिवर्तनीय है

एक स्ट्रिंग एक अपरिवर्तनीय डेटा प्रकार है। इसका अर्थ है कि स्ट्रिंग की सामग्री को बनाने के बाद बदला नहीं जा सकता। ऐसा करने का प्रयास त्रुटि का कारण बनेगा।

>>> str1 = “Hello World!”
#यदि हम ’e’ अक्षर को ‘a’ से बदलने की कोशिश करें
>>> str1[1] = ‘a’
TypeError: ‘str’ object does not support item assignment

8.3 स्ट्रिंग संचालन

जैसा कि हम जानते हैं कि स्ट्रिंग वर्णों का एक क्रम होता है। Python स्ट्रिंग डेटा प्रकार पर कुछ संचालनों की अनुमति देता है, जैसे कि संयोजन, पुनरावृत्ति, सदस्यता और स्लाइसिंग। ये संचालन निम्नलिखित उप-अनुभागों में उपयुक्त उदाहरणों के साथ समझाए गए हैं।

8.3.1 संयोजन

संयोजन का अर्थ है जोड़ना। Python हमें + प्रतीक द्वारा दर्शाए गए संयोजन ऑपरेटर का उपयोग करके दो स्ट्रिंग्स को जोड़ने की अनुमति देता है।

>>> str1 = ‘Hello’ $\hspace{2cm}$ #पहली स्ट्रिंग
>>> str2 = ‘World!’ $\hspace{2cm}$ #दूसरी स्ट्रिंग
>>> str1 + str2 $\hspace{2cm}$ #संयुक्त स्ट्रिंग्स
‘HelloWorld!’
$\hspace{3cm}$ #str1 और str2 समान रहते हैं
>>> str1 $\hspace{3cm}$ #इस संचालन के बाद.
‘Hello’
>>> str2
‘World!’

8.3.2 पुनरावृत्ति

Python हमें * प्रतीक द्वारा दर्शाए गए पुनरावृत्ति ऑपरेटर का उपयोग करके दी गई स्ट्रिंग को दोहराने की अनुमति देता है।

#str1 को ‘Hello’ स्ट्रिंग दें
>>> str1 = ‘Hello’
#str1 का मान 2 बार दोहराएं
>>> str1 * 2
‘HelloHello’
#str1 का मान 5 बार दोहराएं
>>> str1 * 5
‘HelloHelloHelloHelloHello’

नोट: str1 पुनरावृत्ति ऑपरेटर के उपयोग के बाद भी वैसा ही रहता है।

8.3.3 सदस्यता

Python में दो सदस्यता ऑपरेटर हैं ‘in’ और ’not in’। ‘in’ ऑपरेटर दो स्ट्रिंग्स लेता है और True लौटाता है यदि पहली स्ट्रिंग दूसरी स्ट्रिंग में उप-स्ट्रिंग के रूप में दिखाई देती है, अन्यथा यह False लौटाता है।

>>> str1 = ‘Hello World!’
>>> ‘W’ in str1
True
>>> ‘Wor’ in str1
True
>>> ‘My’ in str1
False

’not in’ ऑपरेटर भी दो स्ट्रिंग्स लेता है और True लौटाता है यदि पहली स्ट्रिंग दूसरी स्ट्रिंग में उप-स्ट्रिंग के रूप में नहीं दिखाई देती है, अन्यथा False लौटाता है।

>>> str1 = ‘Hello World!’
>>> ‘My’ not in str1
True
>>> ‘Hello’ not in str1
False

8.3.4 स्लाइसिंग

Python में, किसी स्ट्रिंग के किसी भाग या उप-स्ट्रिंग तक पहुँचने के लिए हम स्लाइसिंग नामक विधि का उपयोग करते हैं। यह इंडेक्स रेंज निर्दिष्ट करके किया जा सकता है। एक स्ट्रिंग str1 दी गई है, स्लाइस ऑपरेशन $\operatorname{str} 1[n: m]$ स्ट्रिंग str1 का वह भाग लौटाता है जो इंडेक्स $n$ (सम्मिलित) से शुरू होता है और $m$ (असम्मिलित) पर समाप्त होता है। दूसरे शब्दों में, हम कह सकते हैं कि $\operatorname{str} 1[n: m]$ वे सभी वर्ण लौटाता है जो str1[n] से शुरू होकर str1[m-1] तक जाते हैं। उप-स्ट्रिंग में वर्णों की संख्या हमेशा दोनों इंडेक्स $m$ और n के अंतर के बराबर होती है, अर्थात् $(m-n)$।

>>> str1 = ‘Hello World!’
#index 1 से 4 तक का substring देता है
>>> str1[1:5]
’ello’
#index 7 से 9 तक का substring देता है
>>> str1[7:10]
‘orl’
#बहुत बड़ा index होने पर उसे string के अंत तक
#काट दिया जाता है
>>> str1[3:20]
’lo World!’
#पहला index दूसरे से बड़ा होने पर खाली
#’’ string मिलता है
>>> str1[7:2]

यदि पहला index नहीं दिया गया हो, तो slice index से शुरू होता है। #index 0 से 4 तक का substring देता है
>>> str1[:5]
‘Hello’

यदि दूसरा index नहीं दिया गया हो, तो slicing string की लंबाई तक की जाती है।

#index 6 से अंत तक का substring देता है
>>> str1[6:]
‘World!’

slice ऑपरेशन एक तीसरा index भी ले सकता है जो ‘step size’ निर्दिष्ट करता है। उदाहरण के लिए, str1[n : m : k] का अर्थ है string str1 से प्रत्येक $k^{\text {वाँ }}$ character निकालना, जो $\mathrm{n}$ से शुरू होकर $\mathrm{m}-1$ पर समाप्त होता है। डिफ़ॉल्ट रूप से step size एक होता है।

>>> str1[0:10:2]
‘HloWr’
>>> str1[0:10:3]
‘HlWl’

Negative indexes का भी उपयोग slicing के लिए किया जा सकता है।

#index -6,-5,-4,-3 और -2 वाले characters
#slice किए गए हैं
>>> str1[-6:-1]
‘World’

यदि हम दोनों indexes को छोड़ दें और step size -1 दें

#str1 string उल्टे क्रम में प्राप्त होता है
>>> str1[::-1]
‘!dlrow olleh’

8.4 TRAVERSING A STRING

हम string के प्रत्येक character तक पहुँच सकते हैं या string को traverse कर सकते हैं using for loop और while loop।

(A) String Traversal Using for Loop:

>>> str1 = ‘Hello World!’
>>> for ch in str1:
$\quad$ print(ch,end = ‘’)
Hello World! $\hspace{1cm}$ #output of for loop

उपरोक्त कोड में, लूप str1 के पहले वर्ण से शुरू होता है और स्वचालित रूप से समाप्त हो जाता है जब अंतिम वर्ण एक्सेस किया जाता है।

(B) while लूप का उपयोग करके स्ट्रिंग ट्रैवर्सल:

>>> str1 = ‘Hello World!’
>>> index = 0
#len(): स्ट्रिंग की लंबाई प्राप्त करने के लिए एक फ़ंक्शन
>>> while index < len(str1):
$\quad$ print(str1[index],end = ‘’)
$\quad$ index += 1

Hello World! $\hspace{1cm}$#output of while loop

यहाँ while लूप तब तक चलता है जब तक index $<$ len(str) शर्त True है, जहाँ index 0 से len(str1) 1 तक बदलता है।

8.5 स्ट्रिंग मेथड्स और बिल्ट-इन फंक्शन्स

Python में कई बिल्ट-इन फंक्शन्स होते हैं जो हमें स्ट्रिंग्स के साथ काम करने की अनुमति देते हैं। तालिका 8.2 स्ट्रिंग मैनिपुलेशन के लिए प्रयुक्त कुछ सामान्य बिल्ट-इन फंक्शन्स का वर्णन करती है।

$\hspace{3cm}$ तालिका 8.2 स्ट्रिंग मैनिपुलेशन के लिए बिल्ट-इन फंक्शन्स

8.6 स्ट्रिंग्स को संभालना

इस खंड में, हम स्ट्रिंग्स पर विभिन्न संचालन करने के लिए Python में उपयोगकर्ता-परिभाषित फ़ंक्शनों के बारे में सीखेंगे।

प्रोग्राम 8-1 एक ऐसा प्रोग्राम लिखें जिसमें एक उपयोगकर्ता-परिभाषित फ़ंक्शन हो जो दी गई स्ट्रिंग में किसी वर्ण (जिसे तर्क के रूप में पास किया जाता है) के आने की संख्या गिनता है।

#प्रोग्राम 8-1
#एक फ़ंक्शन जो किसी स्ट्रिंग में किसी वर्ण के आने की संख्या गिनता है
def charCount(ch,st):
$\quad$ count = 0
$\quad$ for character in st:
$\qquad$ if character == ch:
$\hspace{1cm}$ count += 1
$\quad$ return count
#फ़ंक्शन का अंत

st = input(“Enter a string: “)
ch = input(“Enter the character to be searched: “)
count = charCount(ch,st)
print(“Number of times character”,ch,“occurs in the string is:",count)

आउटपुट:

Enter a string: Today is a Holiday
Enter the character to be searched: a
Number of times character a occurs in the string is: 3

प्रोग्राम 8-2 एक ऐसा प्रोग्राम लिखें जिसमें एक उपयोगकर्ता-परिभाषित फ़ंक्शन हो जिसका पैरामीटर स्ट्रिंग हो और जो स्ट्रिंग में सभी स्वरों को ‘*’ से बदल दे।

#प्रोग्राम 8-2
#स्ट्रिंग में सभी स्वरों को ‘’ से बदलने के लिए फ़ंक्शन
def replaceVowel(st):
$\quad$#एक खाली स्ट्रिंग बनाएं
$\quad$newstr = ’’
$\quad$for character in st:
$\qquad$#जाँचें कि अगला अक्षर स्वर है या नहीं
$\qquad$if character in ‘aeiouAEIOU’:
$\hspace{1cm}$#स्वर को * से बदलें
$\hspace{1cm}$newstr += ‘’
$\qquad$else:
$\hspace{1cm}$newstr += character
$\qquad$return newstr
#फ़ंक्शन का अंत
st = input(“Enter a String: “)
st1 = replaceVowel(st)
print(“The original String is:",st)
print(“The modified String is:",st1)

आउटपुट:

Enter a String: Hello World
The original string is: Hello World
The modified String is: Hll W*rld

प्रोग्राम 8-3 उपयोगकर्ता से एक स्ट्रिंग इनपुट करें और उसे नई स्ट्रिंग बनाए बिना उल्टे क्रम में प्रिंट करने के लिए एक प्रोग्राम लिखें।

#प्रोग्राम 8-3
#स्ट्रिंग को उल्टे क्रम में दिखाने का प्रोग्राम
st = input(“Enter a string: “)
for i in range(-1,-len(st)-1,-1):
$\qquad$print(st[i],end=’’)

आउटपुट:

Enter a string: Hello World
dlrow olleH

**प्रोग्राम 8-4 एक ऐसा प्रोग्राम लिखें जो पैरामीटर के रूप में पास की गई स्ट्रिंग को उल्टा करे और उल्टी हुई स्ट्रिंग को एक नई स्ट्रिंग में संग्रहित करे। स्ट्रिंग को उल्टा करने के लिए एक उपयोगकर्ता-परिभाषित फ़ंक्शन का प्रयोग करें।_

#प्रोग्राम 8-4
#स्ट्रिंग को उलटने के लिए फंक्शन
def reverseString(st):
$\quad$ newstr = ’’ $\qquad$ #एक नई स्ट्रिंग बनाएं
$\quad$ length = len(st)
$\quad$ for i in range(-1,-length-1,-1):
$\qquad$ newstr += st[i]
$\quad$ return newstr
#फंक्शन का अंत
st = input(“एक स्ट्रिंग दर्ज करें: “)
st1 = reverseString(st)
print(“मूल स्ट्रिंग है:",st)
print(“उलटी स्ट्रिंग है:",st1)

आउटपुट:

एक स्ट्रिंग दर्ज करें: Hello World
मूल स्ट्रिंग है: Hello World
उलटी स्ट्रिंग है: dlrow olleH

प्रोग्राम 8-5 एक प्रोग्राम लिखें जो यूज़र-डिफ़ाइंड फंक्शन का उपयोग करके जाँचे कि कोई स्ट्रिंग पैलिंड्रोम है या नहीं। (एक स्ट्रिंग को पैलिंड्रोम कहा जाता है यदि वह पीछे से पढ़ने पर भी वैसी ही रहती है जैसे आगे से। उदाहरण के लिए, Kanak एक पैलिंड्रोम है।)

#प्रोग्राम 8-5
#फंक्शन यह जाँचने के लिए कि स्ट्रिंग पैलिंड्रोम है या नहीं
def checkPalin(st):
$\quad$ i = 0
$\quad$ j = len(st) - 1
$\quad$ while(i <= j):
$\qquad$ if(st[i] != st[j]):
$\hspace{1cm}$ return False
$\qquad$ i += 1
$\qquad$ j -= 1
$\quad$ return True
#फंक्शन का अंत
st = input(“एक स्ट्रिंग दर्ज करें: “)
result = checkPalin(st)
if result == True:
$\quad$ print(“दी गई स्ट्रिंग”,st,“एक पैलिंड्रोम है”)
else:
$\quad$ print(“दी गई स्ट्रिंग”,st,“एक पैलिंड्रोम नहीं है”)

आउटपुट 1:

एक स्ट्रिंग दर्ज करें: kanak
दी गई स्ट्रिंग kanak एक पैलिंड्रोम है

आउटपुट 2:

एक स्ट्रिंग दर्ज करें: computer
दी गई स्ट्रिंग computer एक पैलिंड्रोम नहीं है

सारांश

• एक स्ट्रिंग वर्णों का एक क्रम होता है जो एकल, दोहरे या तिहरे उद्धरण चिह्नों में बंद होता है।
• व्यक्तिगत वर्णों तक पहुँचने के लिए इंडेक्सिंग का उपयोग किया जाता है।
• पहले वर्ण का इंडेक्स 0 होता है और अंतिम वर्ण का इंडेक्स $\mathrm{n}-1$ होता है जहाँ $\mathrm{n}$ स्ट्रिंग की लंबाई है। नकारात्मक इंडेक्सिंग $-n$ से -1 तक होती है।
• Python में स्ट्रिंग्स अपरिवर्तनीय होती हैं, अर्थात् एक बार बनने के बाद स्ट्रिंग को बदला नहीं जा सकता।
• सदस्यता ऑपरेटर in दो स्ट्रिंग्स लेता है और True लौटाता है यदि पहली स्ट्रिंग दूसरी में उप-स्ट्रिंग के रूप में दिखाई देती है, अन्यथा False लौटाता है। सदस्यता ऑपरेटर ’not in’ इसका उल्टा करता है।
• स्ट्रिंग का एक भाग प्राप्त करना स्लाइसिंग कहलाता है। यह इंडेक्स रेंज निर्दिष्ट करके किया जा सकता है। स्लाइस ऑपरेशन $\operatorname{str} 1[\mathrm{n}: \mathrm{m}]$ स्ट्रिंग str 1 का वह भाग लौटाता है जो इंडेक्स $\mathrm{n}$ (सम्मिलित) से शुरू होकर $\mathrm{m}$ (असम्मिलित) पर समाप्त होता है।
• स्ट्रिंग के प्रत्येक वर्ण तक या तो for लूप या while लूप का उपयोग करके पहुँचा जा सकता है।
• Python में स्ट्रिंग्स के साथ काम करने के लिए कई अंतर्निहित फ़ंक्शन होते हैं।

अभ्यास

1. निम्नलिखित स्ट्रिंग mySubject पर विचार करें:

mySubject = “Computer Science”

निम्नलिखित स्ट्रिंग ऑपरेशंस का आउटपुट क्या होगा :

i. print(mySubject[0:len(mySubject)])
ii. print(mySubject[-7:-1])
iii. print(mySubject[::2])
iv. print(mySubject[len(mySubject)-1])
v. print(2*mySubject)
vi. print(mySubject[::-2])
vii. print(mySubject[:3] + mySubject[3:])
viii. print(mySubject.swapcase())
ix. print(mySubject.startswith(‘Comp’))
x. print(mySubject.isalpha())

2. निम्नलिखित स्ट्रिंग myAddress पर विचार करें:

myAddress = “WZ-1,New Ganga Nagar,New Delhi”

निम्नलिखित स्ट्रिंग संचालनों का आउटपुट क्या होगा :

i. print(myAddress.lower())
ii. print(myAddress.upper())
iii. print(myAddress.count(‘New’))
iv. print(myAddress.find(‘New’))
v. print(myAddress.rfind(‘New’))
vi. print(myAddress.split(’,’))
vii. print(myAddress.split(’ ‘))
viii. print(myAddress.replace(‘New’,‘Old’))
ix. print(myAddress.partition(’,’))
x. print(myAddress.index(‘Agra’))

प्रोग्रामिंग समस्याएं

1. उपयोगकर्ता से पंक्ति(याँ) टेक्स्ट इनपुट करने के लिए एक प्रोग्राम लिखें जब तक कि एंटर दबाया न जाए। टेक्स्ट में कुल वर्णों (खाली स्थान सहित), कुल वर्णमालाओं, कुल अंकों, कुल विशेष प्रतीकों और दिए गए टेक्स्ट में कुल शब्दों की गिनती करें। (यह मान लें कि प्रत्येक शब्द एक रिक्त स्थान से अलग होता है)।

2. एक उपयोगकर्ता परिभाषित फ़ंक्शन लिखें जो एक से अधिक शब्दों वाली स्ट्रिंग को टाइटल केस स्ट्रिंग में बदलता है जहाँ स्ट्रिंग को पैरामीटर के रूप में पास किया जाता है। (टाइटल केस का अर्थ है कि प्रत्येक शब्द का पहला अक्षर बड़ा होता है)

3. एक ऐसा फ़ंक्शन deleteChar() लिखिए जो दो पैरामीटर ले—एक स्ट्रिंग और दूसरा एक वर्ण। यह फ़ंक्शन उस वर्ण की सभी उपस्थितियों को स्ट्रिंग से हटाकर एक नई स्ट्रिंग बनाए और उसे लौटाए।

4. एक ऐसी स्ट्रिंग इनपुट करें जिसमें कुछ अंक हों। उन अंकों का योग लौटाने वाला एक फ़ंक्शन लिखिए।

5. एक ऐसा फ़ंक्शन लिखिए जो इनपुट पैरामीटर के रूप में एक वाक्य ले, जिसमें प्रत्येक शब्द एक स्पेस से अलग हो। फ़ंक्शन को प्रत्येक खाली जगह को हाइफ़न से बदलना है और फिर संशोधित वाक्य लौटाना है।