स्ट्रिंग्स
टेक्स्ट लगभग हर प्रोग्राम में दिखाई देता है जो आप लिखते हैं। नाम, संदेश, स्कोर, लेबल। Python में, टेक्स्ट के किसी भी टुकड़े को string कहा जाता है: कोई भी मान जिसे आप उद्धरण चिह्नों में लपेटते हैं। सिंगल हो या डबल, दोनों एक ही तरह से काम करते हैं।
greeting = "Hello, world"
username = 'alice'केवल तभी उद्धरण का चुनाव मायने रखता है जब आपके टेक्स्ट में उद्धरण चिह्न हों। विपरीत शैली का उपयोग करें ताकि आपको उन्हें एस्केप न करना पड़े:
note = "It's a great day" # अंदर apostrophe है, डबल उद्धरण उपयोग करें
message = 'She said "hello"' # अंदर डबल उद्धरण हैं, सिंगल उद्धरण उपयोग करें
escaped = "She said \"hello\"" # या बैकस्लैश से एस्केप करेंअपरिवर्तनीयता (Immutability)
स्ट्रिंग्स अपरिवर्तनीय हैं: एक बार जब आप एक बनाते हैं, तो आप इसे बदल नहीं सकते। एक स्ट्रिंग को उसके बनने के क्षण से स्थायी रूप से तय समझें। कोई भी ऑपरेशन जो स्ट्रिंग को संशोधित करता हुआ दिखता है, वास्तव में एक बिल्कुल नया उत्पन्न कर रहा होता है। मूल बिल्कुल वैसा ही रहता है।
name = "alice"
name = name.upper() # "ALICE" एक नई स्ट्रिंग है; "alice" अपरिवर्तित हैप्रत्यक्ष परिणाम: आप किसी विशिष्ट स्थिति पर वर्ण नहीं बदल सकते। यदि आप कोशिश करते हैं तो Python एक त्रुटि उठाएगा।
name = "alice"
name[0] = "A" # TypeError: 'str' object does not support item assignmentसंशोधित स्ट्रिंग प्राप्त करने के लिए, स्लाइसिंग या मेथड का उपयोग करके एक नई बनाएं। दोनों नीचे कवर हैं।
इंडेक्सिंग और स्लाइसिंग
एक स्ट्रिंग में प्रत्येक वर्ण की एक क्रमांकित स्थिति होती है, जो शून्य से शुरू होती है। आप उस स्थिति संख्या को वर्गाकार कोष्ठक में रखकर अलग-अलग वर्ण पढ़ सकते हैं। ऋणात्मक संख्याएँ अंत से पीछे की ओर गिनती करती हैं।
word = "Python"
# 012345
print(word[0]) # "P"
print(word[2]) # "t"
print(word[5]) # "n"
print(word[-1]) # "n" (अंतिम वर्ण)
print(word[-2]) # "o" (अंत से दूसरा)-1 हमेशा अंतिम वर्ण होता है, -2 अंत से दूसरा, और इसी तरह। ये तब उपयोगी होते हैं जब आप स्ट्रिंग की सटीक लंबाई जाने बिना उसका अंत चाहते हैं।
स्लाइसिंग एक हिस्सा निकालता है। [start:stop] में start शामिल है और stop बाहर है:
word = "Python"
print(word[0:2]) # "Py" (स्थान 0 और 1)
print(word[2:]) # "thon" (स्थान 2 से अंत तक)
print(word[:3]) # "Pyt" (शुरू से स्थान 2 तक)
print(word[:]) # "Python" (पूरी स्ट्रिंग की एक प्रति)
print(word[::2]) # "Pto" (हर दूसरा वर्ण)
print(word[::-1]) # "nohtyP" (उल्टा)सबसे अधिक उपयोग किए जाने वाले तीन पैटर्न: पहले n वर्णों के लिए word[:n], स्थान n से आगे सब कुछ के लिए word[n:], अंतिम n वर्णों के लिए word[-n:]। word[::-1] एक स्ट्रिंग को उल्टा करता है। यह पहली बार अजीब लगता है, लेकिन यह मुहावरेदार Python है और आप इसे अक्सर देखेंगे।
आवश्यक स्ट्रिंग मेथड्स
स्ट्रिंग्स के साथ अंतर्निहित मेथड्स का एक सेट आता है: ऑपरेशन जो आप किसी भी स्ट्रिंग मान पर सीधे कॉल करते हैं। आप स्ट्रिंग (या वेरिएबल जो इसे रखता है) लिखते हैं, फिर एक डॉट, फिर मेथड का नाम। प्रत्येक मेथड एक नई स्ट्रिंग लौटाता है। मूल कभी नहीं बदला जाता।
केस
text = "Hello, World"
text.lower() # "hello, world"
text.upper() # "HELLO, WORLD"
text.title() # "Hello, World" (प्रत्येक शब्द कैपिटलाइज़्ड)
text.capitalize() # "Hello, world" (केवल पहला शब्द)lower() और upper() दो हैं जिनका आप सबसे अधिक उपयोग करेंगे। lower() विशेष रूप से तब उपयोगी होता है जब टेक्स्ट की तुलना की जाती है: "Alice" और "alice" एक ही चीज़ बन जाते हैं जब आप दोनों ओर .lower() कॉल करते हैं।
व्हाइटस्पेस
text = " hello "
text.strip() # "hello" (दोनों ओर)
text.lstrip() # "hello " (केवल बाएँ)
text.rstrip() # " hello" (केवल दाएँ)strip() एक स्ट्रिंग के दोनों सिरों से रिक्त स्थान हटाता है। आप इसका उपयोग लगभग हर बार करेंगे जब आप उपयोगकर्ता इनपुट या फ़ाइल से टेक्स्ट संभालते हैं, क्योंकि बेकार के रिक्त स्थान मूक विफलताओं का कारण बनते हैं: "alice" != "alice "।
खोजना
text = "Hello, world"
text.find("world") # 7
text.find("Python") # -1 (नहीं मिला)
text.count("l") # 3
text.startswith("Hello") # True
text.endswith("world") # Truefind() वह स्थिति लौटाता है जहाँ आपकी स्ट्रिंग के अंदर टेक्स्ट का एक टुकड़ा शुरू होता है। यदि यह वहाँ नहीं है, तो यह -1 लौटाता है। startswith() और endswith() का उपयोग करें जब आप केवल इस बारे में परवाह करते हैं कि स्ट्रिंग कुछ विशिष्ट से शुरू या समाप्त होती है या नहीं।
प्रतिस्थापन
text = "Hello, world"
text.replace("world", "Python") # "Hello, Python"
text.replace("l", "L") # "HeLLo, worLd" (सभी घटनाएँ)
text.replace("l", "L", 1) # "HeLlo, world" (केवल पहली)replace() टेक्स्ट के एक टुकड़े की हर घटना को दूसरे से बदल देता है और आपको एक नई स्ट्रिंग वापस देता है। मूल नहीं बदला जाता। यदि आप केवल पहली घटना को बदलना चाहते हैं तो एक तीसरा तर्क पास करें।
विभाजन और जुड़ाव
split() एक स्ट्रिंग को एक विभाजक पर टुकड़ों में काटता है और उन्हें एक list के रूप में लौटाता है। आप इसे बताते हैं कि किस पर काटना है:
csv_row = "आरव,28,नई दिल्ली"
parts = csv_row.split(",") # ["आरव", "28", "नई दिल्ली"]
" hello world ".split() # ["hello", "world"]List क्या है?
List मानों का एक क्रमबद्ध संग्रह है। ऊपर ["आरव", "28", "नई दिल्ली"] एक है। Lists को अपना अलग अध्याय मिलता है; अभी के लिए, उन्हें वस्तुओं के अनुक्रम के रूप में मानें जो split() उत्पन्न करता है और join() खपत करता है।
join() विपरीत करता है: यह स्ट्रिंग्स की एक list को एक में जोड़ता है। .join() से पहले की स्ट्रिंग प्रत्येक आइटम के बीच रखी जाती है:
words = ["Hello", "world"]
" ".join(words) # "Hello world"
", ".join(words) # "Hello, world"
"".join(words) # "Helloworld"याद रखने का पैटर्न: separator.join(list_of_strings)। विभाजक बाईं ओर जाता है, list दाईं ओर। " ".join(words) प्रत्येक शब्द के बीच एक स्पेस रखता है। "".join(words) उन्हें बिना कुछ बीच में जोड़ देता है।
f-strings
f-strings मानों को सीधे टेक्स्ट के अंदर एम्बेड करती हैं। शुरुआती उद्धरण से पहले f रखें, फिर किसी भी वेरिएबल या अभिव्यक्ति को घुंघराले कोष्ठक में लपेटें। कोड चलने पर Python इसे भर देता है। आप मान के बाद एक कोलन भी जोड़ सकते हैं ताकि यह नियंत्रित किया जा सके कि इसे कैसे प्रदर्शित किया जाए।
name = "आरव"
score = 94.5
print(f"Hello, {name}!") # "Hello, आरव!"
print(f"Score: {score:.1f}%") # "Score: 94.5%"
print(f"2 + 2 = {2 + 2}") # "2 + 2 = 4"
print(f"Name: {name.upper()}") # "Name: आरव": के बाद का format spec नियंत्रित करता है कि मान कैसे प्रदर्शित होता है:
| Spec | अर्थ | उदाहरण |
|---|---|---|
.2f | 2 दशमलव स्थान | f"{3.14159:.2f}" → "3.14" |
.0% | प्रतिशत, कोई दशमलव नहीं | f"{0.94:.0%}" → "94%" |
, | हजारों विभाजक | f"{1000000:,}" → "1,000,000" |
>10 | 10 वर्णों में दाएँ-संरेखित | f"{'hi':>10}" → " hi" |
आप .2f का सबसे अधिक उपयोग करेंगे: किसी भी समय जब आप एक दशमलव प्रदर्शित करते हैं और अंकों के एक लंबे रन के बजाय एक साफ-सुथरी संख्या चाहते हैं। तालिका में बाकी सब कुछ तब है जब आपको इसकी आवश्यकता हो। आप {} के अंदर कोई भी वेरिएबल, अंकगणित, या मेथड कॉल रख सकते हैं।
मल्टीलाइन स्ट्रिंग्स
एक स्ट्रिंग लिखने के लिए जो एक से अधिक पंक्ति में फैली हो, ट्रिपल उद्धरण चिह्नों का उपयोग करें: शुरू में तीन " और अंत में तीन। Python सभी लाइन ब्रेक्स और स्पेसिंग को ठीक वैसे ही संरक्षित करता है जैसा आपने लिखा है।
message = """
प्रिय आरव,
आपके ऑर्डर के लिए धन्यवाद।
सादर,
टीम
"""एस्केप अनुक्रम
कुछ वर्ण एक स्ट्रिंग के अंदर सीधे टाइप करना कठिन होता है। Python एस्केप अनुक्रमों का उपयोग करता है: एक बैकस्लैश के बाद एक अक्षर जो किसी चीज़ का प्रतिनिधित्व करता है। दो जिनका आप लगातार उपयोग करेंगे वे हैं नई पंक्ति के लिए \n और टैब के लिए \t।
| अनुक्रम | वर्ण |
|---|---|
\n | Newline |
\t | Tab |
\\ | लिटरल बैकस्लैश |
\" | डबल उद्धरण |
\' | सिंगल उद्धरण |
print("Line one\nLine two") # आउटपुट की दो पंक्तियाँ
print("Name:\tAlice") # Name: Alice
path = r"C:\Users\Alice\Documents" # raw स्ट्रिंग, कोई एस्केप प्रोसेसिंग नहींस्ट्रिंग सामग्री की जाँच
Python के पास ऐसे मेथड्स हैं जो हाँ/नहीं प्रश्नों का उत्तर देते हैं कि एक स्ट्रिंग में क्या है। वे True या False लौटाते हैं। शुरू में सबसे उपयोगी: isdigit() आपको यह जाँचने देता है कि क्या एक स्ट्रिंग केवल संख्याएँ हैं इसे परिवर्तित करने से पहले, ताकि आप अप्रत्याशित इनपुट पर क्रैश से बच सकें।
"42".isdigit() # True
"hello".isalpha() # True
"hello42".isalnum() # True
" ".isspace() # True
"Hello".islower() # False
"HELLO".isupper() # Trueव्यवहार में
व्हाइटस्पेस हटाएँ, केस सामान्यीकृत करें, फिर जो आपको चाहिए उसे निकालें। यह क्रम लगभग किसी भी उपयोगकर्ता-प्रदत्त टेक्स्ट को संभालता है:
raw_input = " [email protected] "
email = raw_input.strip().lower() # "[email protected]"
at_pos = email.find("@")
username = email[:at_pos]
domain = email[at_pos + 1:]
print(f"User: {username}") # "arav"
print(f"Domain: {domain}") # "example.com"मेथड संदर्भ
| मेथड | यह क्या करता है |
|---|---|
.lower() / .upper() | सभी lowercase / सभी uppercase में परिवर्तित करें |
.title() / .capitalize() | प्रत्येक शब्द को कैपिटलाइज़ करें / केवल पहला |
.strip() / .lstrip() / .rstrip() | आसपास के व्हाइटस्पेस हटाएँ |
.find(sub) | पहले मैच का इंडेक्स, या -1 |
.count(sub) | sub कितनी बार दिखाई देता है |
.startswith(s) / .endswith(s) | उपसर्ग / प्रत्यय जाँच |
.replace(old, new) | घटनाओं को बदलें |
.split(sep) | एक list में विभाजित करें |
sep.join(iterable) | वस्तुओं को एक स्ट्रिंग में जोड़ें |
.isdigit() / .isalpha() / .isalnum() | वर्ण प्रकार जाँच |