Python स्ट्रिंग

Python में पहले से मौजूद "str" नाम की स्ट्रिंग क्लास है. इसमें कई आसान सुविधाएं हैं (यहां "string" नाम का एक पुराना मॉड्यूल है, जिसका इस्तेमाल नहीं किया जाना चाहिए). स्ट्रिंग की लिटरल वैल्यू को डबल या सिंगल कोट के अंदर रखा जा सकता है. हालांकि, आम तौर पर सिंगल कोट का इस्तेमाल किया जाता है. बैकस्लैश सिंगल और डबल कोट किए गए लिटरल, दोनों के अंदर सामान्य तरीके से काम करता है -- उदाहरण के लिए, \n \\ \". डबल कोट वाली स्ट्रिंग के लिटरल में बिना किसी गड़बड़ी के सिंगल कोट हो सकते हैं (जैसे, "मैंने यह नहीं किया") और इसी तरह सिंगल कोट वाली स्ट्रिंग में डबल कोट हो सकते हैं. स्ट्रिंग लिटरल वैल्यू कई लाइनों में हो सकती है, लेकिन नई लाइन से बचने के लिए हर लाइन के आखिर में एक बैकस्लैश \ होना चाहिए. ट्रिपल कोट, """ या ''' में मौजूद स्ट्रिंग की लिटरल वैल्यू में, टेक्स्ट की कई लाइनें हो सकती हैं.

Python स्ट्रिंग "अम्यूटेबल" होती हैं. इसका मतलब है कि इन्हें बनाने के बाद, इन्हें बदला नहीं जा सकता. JavaScript स्ट्रिंग भी इस स्टाइल का इस्तेमाल करती हैं जिसमें बदलाव नहीं किया जा सकता. स्ट्रिंग को बदला नहीं जा सकता. इसलिए, कैलकुलेट की गई वैल्यू को दिखाने के लिए हम *नई* स्ट्रिंग बनाते हैं. उदाहरण के लिए, एक्सप्रेशन ('hello' + 'there'), दो स्ट्रिंग 'hello' और 'there' लेता है और एक नई स्ट्रिंग बनाता है 'hellothere'.

स्ट्रिंग में वर्णों को स्टैंडर्ड [ ] सिंटैक्स का इस्तेमाल करके ऐक्सेस किया जा सकता है. Java और C++ की तरह, Python शून्य-आधारित इंडेक्स का इस्तेमाल करता है. इसलिए, अगर s 'hello' s[1] है, तो 'e' है. अगर इंडेक्स स्ट्रिंग की सीमा से बाहर है, तो Python एक गड़बड़ी दिखाता है. Python स्टाइल (पर्ल के उलट) को तब रोक दिया जाता है, जब यह नहीं बता पाता कि क्या करना है. सिर्फ़ डिफ़ॉल्ट वैल्यू बनाने के बजाय, इसे बंद कर दिया जाता है. आसान "स्लाइस" सिंटैक्स (नीचे) किसी स्ट्रिंग से किसी भी सबस्ट्रिंग को निकालने के लिए भी काम करता है. len(string) फ़ंक्शन स्ट्रिंग की लंबाई दिखाता है. [ ] सिंटैक्स और len() फ़ंक्शन किसी भी तरह के क्रम -- स्ट्रिंग, लिस्ट वगैरह पर काम करते हैं. Python, अलग-अलग तरह के काम लगातार करने की कोशिश करता है. Python newbie getcha: len() फ़ंक्शन को ब्लॉक करने से बचने के लिए, वैरिएबल के नाम के तौर पर "len" का इस्तेमाल न करें. '+' ऑपरेटर दो स्ट्रिंग को जोड़ सकता है. नीचे दिए गए कोड में ध्यान दें कि वैरिएबल पहले से तय नहीं हैं -- बस उन्हें असाइन करें और जाएं.

  s = 'hi'
  print(s[1])          ## i
  print(len(s))        ## 2
  print(s + ' there')  ## hi there

Java के उलट, '+' संख्याओं या अन्य टाइप को अपने-आप स्ट्रिंग के रूप में नहीं बदलता. str() फ़ंक्शन, वैल्यू को स्ट्रिंग के रूप में बदल देता है, ताकि उन्हें अन्य स्ट्रिंग के साथ जोड़ा जा सके.

  pi = 3.14
  ##text = 'The value of pi is ' + pi      ## NO, does not work
  text = 'The value of pi is '  + str(pi)  ## yes

संख्याओं के लिए, स्टैंडर्ड ऑपरेटर, +, /, * सामान्य तरीके से काम करते हैं. कोई ++ ऑपरेटर नहीं है, लेकिन +=, -= वगैरह काम करते हैं. अगर आपको पूर्णांक को बांटना है, तो 2 स्लैश का इस्तेमाल करें -- जैसे कि 6 // 5 है 1

"प्रिंट" फ़ंक्शन सामान्य तौर पर एक या उससे ज़्यादा Python आइटम प्रिंट करता है और उसके बाद नई लाइन दिखाता है. "रॉ" स्ट्रिंग की लिटरल वैल्यू के तौर पर, 'r' जुड़ा होता है और बैकस्लैश का इस्तेमाल किए बिना सभी वर्णों को पास किया जाता है. इसलिए, r'x\nx', लंबाई-4 वाली स्ट्रिंग 'x\nx' का आकलन करता है. "प्रिंट" कई तर्क लेकर, चीज़ों को प्रिंट करने का तरीका बदल सकता है (python.org प्रिंट फ़ंक्शन परिभाषा देखें). जैसे "end" को "" पर सेट करने से सभी आइटम प्रिंट करने के बाद नई लाइन को प्रिंट नहीं किया जाता है.

  raw = r'this\t\n and that'

  # this\t\n and that
  print(raw)

  multi = """It was the best of times.
  It was the worst of times."""

  # It was the best of times.
  #   It was the worst of times.
  print(multi)

स्ट्रिंग के तरीके

यहां स्ट्रिंग के कुछ सबसे आम तरीके दिए गए हैं. तरीका, फ़ंक्शन की तरह होता है, लेकिन यह किसी ऑब्जेक्ट पर चलता है. अगर वैरिएबल s कोई स्ट्रिंग है, तो कोड s.lower() उस स्ट्रिंग ऑब्जेक्ट पर Low() तरीके को चलाता है और नतीजा दिखाता है (किसी ऑब्जेक्ट पर चलने वाले तरीके का यह आइडिया उन बुनियादी आइडिया में से एक है जो ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग, OOP को बनाते हैं). यहां स्ट्रिंग के कुछ सबसे सामान्य तरीके दिए गए हैं:

• s.lower(), s.upper() -- स्ट्रिंग का लोअरकेस या अपरकेस वर्शन लौटाता है
• s.strip() -- शुरू और आखिर से खाली सफ़ेद जगह वाली स्ट्रिंग देता है
• s.isalpha()/s.isअंक()/s.isspace()... -- यह जांच करता है कि सभी स्ट्रिंग वर्ण अलग-अलग वर्ण क्लास में हैं या नहीं
• s.startswith('other'), s.endswith('other') -- जांच करता है कि स्ट्रिंग, दी गई किसी दूसरी स्ट्रिंग से शुरू या खत्म होती है या नहीं
• s.find('other') -- दी गई अन्य स्ट्रिंग (रेगुलर एक्सप्रेशन नहीं) को s के अंदर खोजता है और जहां से यह शुरू होता है पहला इंडेक्स लौटाता है या नहीं मिलने पर -1 देता है
• s.Replace('old', 'new') -- वह स्ट्रिंग देता है जिसमें 'पुराने' की सभी आवृत्तियों को 'new' से बदल दिया गया है
• s.split('delim') -- दिए गए डेलिमिटर से अलग की गई सबस्ट्रिंग की सूची देता है. डीलिमिटर कोई रेगुलर एक्सप्रेशन नहीं है. यह सिर्फ़ टेक्स्ट होता है. 'aaa,bbb,खोलकर'.split(',') -> ['aaa', 'bbb', 'cc']. एक सुविधाजनक खास केस के तौर पर, s.split() (बिना किसी तर्क के) को सभी व्हाइटस्पेस वर्णों पर अलग कर दिया जाता है.
• s.join(list) -- स्प्लिट() के विपरीत, स्ट्रिंग को डीलिमिटर के रूप में इस्तेमाल करके दी गई सूची के तत्वों को एक साथ जोड़ता है. उदा. '---'.join(['aaa', 'bbb', 'cc']) -> aaa---bbb---cc

"python str" के लिए Google पर कोई खोज आपको आधिकारिक python.org स्ट्रिंग तरीकों पर ले जाएगी, जिसमें सभी str मेथड की सूची होती है.

Python में कोई अलग कैरेक्टर टाइप नहीं होता है. इसके बजाय, s[8] जैसा कोई एक्सप्रेशन, वर्ण वाली स्ट्रिंग-length-1 दिखाता है. स्ट्रिंग-length-1 के साथ, ऑपरेटर ==, <=, ... सभी आपकी उम्मीद के मुताबिक काम करते हैं. इसलिए, आपको यह जानने की ज़रूरत नहीं है कि Python के पास अलग स्केलर "char" टाइप नहीं है.

स्ट्रिंग स्लाइस

"स्लाइस" सिंटैक्स, क्रम के उप-हिस्सों के बारे में बताने का एक आसान तरीका है. आम तौर पर, यह स्ट्रिंग और सूचियां होती हैं. स्लाइस s[start:end] वे एलिमेंट हैं जो शुरू से शुरू होते हैं और खत्म होते हैं, लेकिन खत्म को शामिल नहीं करते. मान लें कि हमारे पास s = "नमस्ते" है

• s[1:4] 'ell' है -- इंडेक्स 1 से शुरू होने वाले और इंडेक्स 4 से लेकर आगे तक जाने वाले वर्ण, लेकिन इनमें इंडेक्स 4 शामिल नहीं हैं
• s[1:] 'ello' है -- किसी भी इंडेक्स को अनदेखा करके, स्ट्रिंग की शुरुआत या आखिर में होना चाहिए
• s[:] 'नमस्ते' है -- दोनों को छोड़ने पर, हमेशा हमें पूरी चीज़ की एक कॉपी मिलती है (यह किसी स्ट्रिंग या सूची जैसे क्रम को कॉपी करने का पाइथनिक तरीका है)
• s[1:100], 'ello' है -- एक इंडेक्स जो बहुत बड़ा है उसे स्ट्रिंग की लंबाई तक छोटा कर दिया जाता है

शून्य पर आधारित स्टैंडर्ड इंडेक्स नंबर, स्ट्रिंग की शुरुआत के करीब वाले वर्णों का ऐक्सेस देते हैं. विकल्प के तौर पर, Python, स्ट्रिंग के आखिर में मौजूद वर्णों का आसान ऐक्सेस देने के लिए नेगेटिव नंबर का इस्तेमाल करता है: s[-1] आखिरी वर्ण 'o' है, s[-2] आखिरी वर्ण 'l' है और यह क्रम इसी तरह जारी रहता है. नेगेटिव इंडेक्स नंबर, स्ट्रिंग के आखिर से गिने जाते हैं:

• s[-1] 'o' है -- अंतिम वर्ण (आखिर से 1ला)
• s[-4], 'e' है -- अंत से 4ठा
• s[:-3] 'वह' है -- अंतिम 3 वर्णों को शामिल नहीं करता, लेकिन ऊपर जा रहा है.
• s[-3:] 'llo' है -- अंत से तीसरे वर्ण से शुरू होता है और स्ट्रिंग के आखिर तक विस्तार करता है.

यह स्लाइस का एक छोटा रूप है, जो किसी भी इंडेक्स n, s[:n] + s[n:] == s के लिए होता है. यह n नेगेटिव या सीमा से बाहर के लिए भी काम करता है. इसके अलावा, s[:n] और s[n:] जैसे दूसरे तरीके से भी स्ट्रिंग को हमेशा स्ट्रिंग के दो हिस्सों में बांटा जा सकता है. इससे सभी वर्ण सुरक्षित रहते हैं. जैसा कि हम बाद में सूची सेक्शन में देखेंगे, स्लाइस भी सूचियों के साथ काम करते हैं.

स्ट्रिंग फ़ॉर्मैटिंग

अजगर एक और चीज़ कर सकता है कि वह चीज़ें अपने-आप ऐसी स्ट्रिंग में बदल जाए जो प्रिंटिंग के लिए सही हो. ऐसा करने के दो तरीके हैं. फ़ॉर्मैट की गई स्ट्रिंग लिटरल को "f-स्ट्रिंग" और str.format() भी कहा जाता है.

फ़ॉर्मैट की गई स्ट्रिंग की लिटरल वैल्यू

आपको आम तौर पर इन स्थितियों में इस्तेमाल किए गए फ़ॉर्मैट किए गए स्ट्रिंग लिटरल दिखेंगे:

  value = 2.791514
  print(f'approximate value = {value:.2f}')  # approximate value = 2.79

  car = {'tires':4, 'doors':2}
  print(f'car = {car}') # car = {'tires': 4, 'doors': 2}

फ़ॉर्मैट की गई लिटरल स्ट्रिंग के आगे 'f' होता है. जैसे, रॉ स्ट्रिंग के लिए इस्तेमाल होने वाला 'r' प्रीफ़िक्स. कर्ली ब्रैकेट '{}' के बाहर का कोई भी टेक्स्ट, सीधे प्रिंट कर दिया जाता है. '{}' में मौजूद एक्सप्रेशन को फ़ॉर्मैट स्पेसिफ़िकेशन में बताए गए फ़ॉर्मैट स्पेसिफ़िकेशन का इस्तेमाल करके प्रिंट किया जाता है. फ़ॉर्मैटिंग से कई चीज़ें आसान हो जाती हैं. जैसे, काट-छांट करना और वैज्ञानिक नोटेशन में बदलाव करना और लेफ़्ट/राइट/सेंटर अलाइनमेंट.

f-स्ट्रिंग बहुत उपयोगी होती है, जब आप ऑब्जेक्ट की एक तालिका को प्रिंट करना चाहते हैं और अलग-अलग ऑब्जेक्ट विशेषताओं को प्रदर्शित करने वाले कॉलम को अलाइन करना चाहते हैं,

  address_book = [{'name':'N.X.', 'addr':'15 Jones St', 'bonus': 70},
      {'name':'J.P.', 'addr':'1005 5th St', 'bonus': 400},
      {'name':'A.A.', 'addr':'200001 Bdwy', 'bonus': 5},]

  for person in address_book:
    print(f'{person["name"]:8} || {person["addr"]:20} || {person["bonus"]:>5}')

  # N.X.     || 15 Jones St          ||    70
  # J.P.     || 1005 5th St          ||   400
  # A.A.     || 200001 Bdwy          ||     5

स्ट्रिंग %

Python में स्ट्रिंग को एक साथ रखने के लिए, Printf() जैसी पुरानी सुविधा भी होती है. % ऑपरेटर, बाईं ओर प्रिंटf-टाइप फ़ॉर्मैट स्ट्रिंग (%d int, %s स्ट्रिंग, %f/%g फ़्लोटिंग पॉइंट) और दाईं ओर एक टपल में मेल खाने वाली वैल्यू (एक टपल वैल्यू को कॉमा से अलग करके बनाया जाता है, जिसे आम तौर पर ब्रैकेट में ग्रुप किया जाता है):

  # % operator
  text = "%d little pigs come out, or I'll %s, and I'll %s, and I'll blow your %s down." % (3, 'huff', 'puff', 'house')

ऊपर दी गई लाइन कुछ हद तक लंबी है -- मान लीजिए कि आपको इसे अलग-अलग लाइनों में बांटना है. आप अन्य भाषाओं की तरह, '%' के बाद लाइन को नहीं बांट सकते. ऐसा इसलिए, क्योंकि डिफ़ॉल्ट रूप से Python, हर लाइन को अलग स्टेटमेंट मानता है (प्लस साइड पर, इसलिए हमें हर लाइन में सेमी-कोलन लिखने की ज़रूरत नहीं होती). इसे ठीक करने के लिए, पूरे एक्सप्रेशन को ब्रैकेट के बाहरी सेट में रखें -- इसके बाद एक्सप्रेशन को कई लाइनों में पूरा किया जा सकता है. यह कोड-अक्रॉस-लाइन तकनीक नीचे दिए गए अलग-अलग ग्रुपिंग कंस्ट्रक्ट के साथ काम करती है, जिनके बारे में नीचे बताया गया है: ( ), [ ], { }.

  # Add parentheses to make the long line work:
  text = (
    "%d little pigs come out, or I'll %s, and I'll %s, and I'll blow your %s down."
    % (3, 'huff', 'puff', 'house'))

यह बेहतर है, लेकिन लाइन अब भी थोड़ी लंबी है. Python की मदद से, किसी लाइन को कई हिस्सों में बांटा जा सकता है. इसके बाद, लाइन अपने-आप जुड़ जाती है. इसलिए, इस लाइन को और भी छोटा करने के लिए, हम ऐसा कर सकते हैं:

  # Split the line into chunks, which are concatenated automatically by Python
  text = (
    "%d little pigs come out, "
    "or I'll %s, and I'll %s, "
    "and I'll blow your %s down."
    % (3, 'huff', 'puff', 'house'))

स्ट्रिंग (यूनिकोड बनाम बाइट)

रेगुलर Python स्ट्रिंग, यूनिकोड होती हैं.

Python, सामान्य बाइट वाली स्ट्रिंग के साथ भी काम करता है (इसे स्ट्रिंग लिटरल से पहले 'b' प्रीफ़िक्स से दिखाया जाता है) जैसे:

> byte_string = b'A byte string'
> byte_string
  b'A byte string'

यूनिकोड स्ट्रिंग, बाइट स्ट्रिंग से अलग तरह का ऑब्जेक्ट है, लेकिन किसी भी तरह की स्ट्रिंग को पास करने पर रेगुलर एक्सप्रेशन जैसी कई लाइब्रेरी सही तरीके से काम करती हैं.

सामान्य Python स्ट्रिंग को बाइट में बदलने के लिए, स्ट्रिंग पर encode() तरीके का इस्तेमाल करें. दूसरी दिशा पर जाने पर, बाइट स्ट्रिंग डिकोड करने वाला तरीका, कोड में बदले गए सादे बाइट को यूनिकोड स्ट्रिंग में बदलता है:

> ustring = 'A unicode \u018e string \xf1'
> b = ustring.encode('utf-8')
> b
b'A unicode \xc6\x8e string \xc3\xb1'  ## bytes of utf-8 encoding. Note the b-prefix.
> t = b.decode('utf-8')                ## Convert bytes back to a unicode string
> t == ustring                         ## It's the same as the original, yay!
True

फ़ाइल रीडिंग सेक्शन में, एक उदाहरण दिया गया है जिसमें कुछ एन्कोडिंग वाली टेक्स्ट फ़ाइल को खोलने और यूनिकोड स्ट्रिंग को पढ़ने का तरीका बताया गया है.

अगर स्टेटमेंट

Python, if/loops/Function वगैरह के लिए, कोड के ब्लॉक को बंद करने के लिए { } का इस्तेमाल नहीं करता.. इसके बजाय, Python ग्रुप स्टेटमेंट में कोलन (:) और इंडेंटेशन/व्हाइटस्पेस इस्तेमाल करता है. if के लिए बूलियन टेस्ट को ब्रैकेट (C++/Java से बड़ा अंतर) में रखने की ज़रूरत नहीं है. इसमें *elif* और *else* क्लॉज़ हो सकते हैं (mnemonic: "elif" शब्द की लंबाई "else" शब्द की लंबाई के बराबर होती है).

किसी भी वैल्यू को if-test के तौर पर इस्तेमाल किया जा सकता है. सभी "शून्य" वैल्यू को गलत के तौर पर गिना जाता है: कोई नहीं, 0, खाली स्ट्रिंग, खाली सूची, खाली सूची. बूलियन टाइप में भी दो वैल्यू होती हैं: सही और गलत (इंटरैक्ट में बदला गया, ये 1 और 0 हैं). Python में, तुलना करने के लिए आम तौर पर ये कार्रवाइयां की जाती हैं: ==, !=, <, <=, >, >=. Java और C से अलग, स्ट्रिंग के साथ ठीक से काम करने के लिए == ओवरलोड है. बूलियन ऑपरेटर ऐसे शब्द होते हैं *और*, *या*, *नहीं* (Python में C-style &&| ! का इस्तेमाल नहीं किया जाता). हेल्थ ऐप्लिकेशन के लिए, दिन भर में ड्रिंक के सुझाव देने वाले ऐप्लिकेशन के कोड, कुछ इस तरह दिखते हैं -- ध्यान दें कि उस समय/else स्टेटमेंट का हर ब्लॉक : से शुरू होता है और स्टेटमेंट को उनके इंडेंट के आधार पर ग्रुप किया जाता है:

  if time_hour >= 0 and time_hour <= 24:
    print('Suggesting a drink option...')
    if mood == 'sleepy' and time_hour < 10:
      print('coffee')
    elif mood == 'thirsty' or time_hour < 2:
      print('lemonade')
    else:
      print('water')

मुझे लगता है कि ऊपर दिए गए कोड में टाइप करते समय, लगी को छोड़ देना मेरी सबसे आम सिंटैक्स गलती है. शायद यह मेरे C++/Java की आदतों के मुकाबले टाइप करने के लिए एक अतिरिक्त चीज़ है. साथ ही, बूलियन टेस्ट को ब्रैकेट में न रखें -- यह C/Java की आदत है. अगर कोड छोटा है, तो आप कोड को ',' के बाद उसी लाइन में रख सकते हैं, इस तरह (यह फ़ंक्शन, लूप वगैरह पर भी लागू होता है), हालांकि कुछ लोगों को लगता है कि चीज़ों को अलग-अलग लाइन में रखने में यह ज़्यादा आसानी से पढ़ा जा सकता है.

  if time_hour < 10: print('coffee')
  else: print('water')

व्यायाम: स्ट्रिंग1.py

इस सेक्शन में दिए गए कॉन्टेंट की प्रैक्टिस करने के लिए, बुनियादी कसरतें में जाकर string1.py व्यायाम को आज़माएं.