स्ट्रिंग का समर्थन करने के लिए बिल्टइन भाषा. स्ट्रिंग की लिटरल वैल्यू के उदाहरण:
a = 'abc\ndef' b = "ab'cd" c = """multiline string""" # Strings support slicing (negative index starts from the end): x = "hello"[2:4] # "ll" y = "hello"[1:-1] # "ell" z = "hello"[:4] # "hell" # Slice steps can be used, too: s = "hello"[::2] # "hlo" t = "hello"[3:0:-1] # "lle"स्ट्रिंग को सीधे तौर पर दोहराया नहीं जा सकता है. अपने वर्णों को फिर से दोहराने के लिए,
.elems() तरीके का इस्तेमाल करें. उदाहरण:"bc" in "abcd" # evaluates to True x = [c for c in "abc".elems()] # x == ["a", "b", "c"]स्ट्रिंग को सीधे तौर पर जोड़ने की अनुमति नहीं है; इसके बजाय,
+ ऑपरेटर का इस्तेमाल करें. तुलना करने वाले ऑपरेटर, शब्दों की तुलना करके नतीजे दिखाते हैं; समानता की जांच करने के लिए == का इस्तेमाल करें.
सदस्य
- capitalize
- count
- एल्म्स
- endswith
- ढूंढें
- format
- index
- isalnum
- isalpha
- isdigit
- islower
- isspace
- istitle
- isupper
- शामिल हों
- कम
- लिस्टस्ट्रिप
- पार्टिशन
- Removeprefix
- removesuffix
- बदलें
- rfind
- rindex
- rpartition
- rsplit
- rstrip
- split
- स्प्लिटलाइन
- इससे शुरू होता है
- strip
- टाइटल
- ऊपरी
अक्षर बड़े करें
string string.capitalize()स्ट्रिंग की एक ऐसी कॉपी दिखाता है, जिसका पहला वर्ण (अगर कोई हो) कैपिटल लेटर में होता है और बाकी वर्ण लोअरकेस में होता है. इस तरीके में गैर-ASCII वर्ण इस्तेमाल नहीं किए जा सकते.
सोलर पैनलों की संख्या
int string.count(sub, start=0, end=None)स्ट्रिंग में सबस्ट्रिंग
sub के ओवरलैप न होने वाली जगहों की संख्या दिखाता है. इसके लिए, [start:end], start, और end का इस्तेमाल किया जा सकता है. [start:end] में ओवरलैप वाली जगहें शामिल होती हैं, जबकि start और end में नहीं.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string;
ज़रूरी है गिनती करने के लिए सबस्ट्रिंग. |
start
|
int या None;
डिफ़ॉल्ट तौर पर 0होता है इस पोज़िशन से खोजने पर पाबंदी लगाएं. |
end
|
int या None;
डिफ़ॉल्ट तौर पर Noneखोज के लिए पाबंदी लगाने से पहले की वैकल्पिक स्थिति. |
elems
sequence string.elems()यह बार-बार इस्तेमाल की जा सकने वाली ऐसी वैल्यू दिखाता है जिसमें स्ट्रिंग के एक एलिमेंट की सबस्ट्रिंग होती है. यह
[s[i] for i in range(len(s))] के बराबर है. हालांकि, हो सकता है कि लौटाई गई वैल्यू सूची न हो.
endswith
bool string.endswith(sub, start=0, end=None)अगर स्ट्रिंग
sub पर खत्म होती है, तो True दिखाता है. ऐसा न होने पर False दिखाता है. इसके अलावा, [start:end] पर भी फ़ंक्शन को सीमित किया जा सकता है. start में शामिल और end में शामिल नहीं होने वाले वैल्यू को दिखाया जाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string; या स्ट्रिंग का टपल;
ज़रूरी है मिलान करने के लिए प्रत्यय (या वैकल्पिक सफ़िक्स का टपल). |
start
|
int या None;
डिफ़ॉल्ट 0है इस पोज़िशन से टेस्ट शुरू करें. |
end
|
int या None;
डिफ़ॉल्ट तौर पर Noneतुलना बंद करने की वैकल्पिक स्थिति. |
ढूंढें
int string.find(sub, start=0, end=None)वह इंडेक्स दिखाता है जहां
sub मिलता है. अगर ऐसा कोई इंडेक्स नहीं है, तो -1 दिखाता है. इसके अलावा, [start:end], start, और end में से किसी एक पर भी पाबंदी लगाई जा सकती है. start में शामिल और end में शामिल नहीं होने वाले वैल्यू को शामिल किया जाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string;
ज़रूरी है ढूंढने के लिए सबस्ट्रिंग. |
start
|
int; या None;
डिफ़ॉल्ट 0है इस स्थान से खोजने तक सीमित करें. |
end
|
int या None;
डिफ़ॉल्ट तौर पर Noneखोज के लिए पाबंदी लगाने से पहले की वैकल्पिक स्थिति. |
फ़ॉर्मैट
string string.format(*args, **kwargs)स्ट्रिंग इंटरपोलेशन करें. फ़ॉर्मैट स्ट्रिंग में, कर्ली ब्रैकेट
{} से घिरे रीप्लेसमेंट फ़ील्ड होते हैं. जो कुछ भी ब्रैकेट में नहीं होता है उसे लिटरल टेक्स्ट माना जाता है, जिसे आउटपुट में कॉपी नहीं किया जाता है.अगर आपको लिटरल टेक्स्ट में कोई ब्रेस वर्ण शामिल करना है, तो इसे दोगुना करके एस्केप किया जा सकता है: {{ और }}रीप्लेसमेंट फ़ील्ड कोई नाम, संख्या या खाली हो सकता है. str फ़ंक्शन का इस्तेमाल करके वैल्यू को स्ट्रिंग में बदला जाता है.# Access in order:
"{} < {}".format(4, 5) == "4 < 5"
# Access by position:
"{1}, {0}".format(2, 1) == "1, 2"
# Access by name:
"x{key}x".format(key = 2) == "x2x"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
args
|
डिफ़ॉल्ट रूप से ()है आर्ग्युमेंट की सूची. |
kwargs
|
डिफ़ॉल्ट रूप से {}आर्ग्युमेंट की डिक्शनरी. |
इंडेक्स
int string.index(sub, start=0, end=None)वह पहला इंडेक्स लौटाता है जहां
sub मिलता है या अगर ऐसा कोई इंडेक्स मौजूद नहीं है, तो गड़बड़ी को दिखाता है. वैकल्पिक तौर पर, [start:end]start को शामिल करने और end को खास होने तक सीमित करता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string;
ज़रूरी है ढूंढने के लिए सबस्ट्रिंग. |
start
|
int या None;
डिफ़ॉल्ट तौर पर 0होता है इस पोज़िशन से खोजने पर पाबंदी लगाएं. |
end
|
int या None;
डिफ़ॉल्ट तौर पर Noneखोज के लिए पाबंदी लगाने से पहले की वैकल्पिक स्थिति. |
Isalnum
bool string.isalnum()सही है अगर स्ट्रिंग में सभी वर्ण अक्षर और अंक ([a-zA-Z0-9]) हैं और कम से कम एक वर्ण है.
isalpha
bool string.isalpha()अगर स्ट्रिंग में सभी वर्ण अंग्रेज़ी के वर्ण ([a-zA-Z]) हैं और कम से कम एक वर्ण है, तो True दिखाता है.
इज़डिजिट
bool string.isdigit()सही है अगर स्ट्रिंग के सभी वर्ण अंक ([0-9]) हैं और कम से कम एक वर्ण है.
islower
bool string.islower()अगर स्ट्रिंग में सभी केस वाले वर्ण लोअरकेस में हैं और कम से कम एक वर्ण है, तो True दिखाता है.
isspace
bool string.isspace()अगर सभी वर्ण व्हाइट स्पेस वर्ण हैं और स्ट्रिंग में कम से कम एक वर्ण है, तो True दिखाता है.
istitle
bool string.istitle()सही है अगर स्ट्रिंग, टाइटल केस में है और उसमें कम से कम एक वर्ण है. इसका मतलब है कि अंग्रेज़ी के हर बड़े वर्ण के बाद, अंग्रेज़ी के बड़े अक्षरों (जैसे कि खाली सफ़ेद जगह) का सही से इस्तेमाल होना ज़रूरी है. साथ ही, अंग्रेज़ी के हर छोटे अक्षर के बाद, अंग्रेज़ी के बड़े या छोटे अक्षरों में अंतर होना ज़रूरी है.
Isupper
bool string.isupper()अगर स्ट्रिंग में सभी केस वाले वर्ण अपरकेस हैं और कम से कम एक वर्ण है, तो True दिखाता है.
जोड़ना
string string.join(elements)एक ऐसी स्ट्रिंग दिखाता है जिसमें आर्ग्युमेंट के स्ट्रिंग एलिमेंट को सेपरेटर के तौर पर इस स्ट्रिंग से जोड़ा गया है. उदाहरण:
"|".join(["a", "b", "c"]) == "a|b|c"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
elements
|
ज़रूरी है जोड़े जाने वाले ऑब्जेक्ट. |
निचला
string string.lower()इस स्ट्रिंग के लोअर केस वाला वर्शन दिखाता है.
lstrip
string string.lstrip(chars=None)
chars में दिखने वाले शुरुआती वर्णों को हटाकर, स्ट्रिंग की कॉपी दिखाता है. ध्यान दें कि chars कोई प्रीफ़िक्स नहीं है: इसकी वैल्यू के सभी कॉम्बिनेशन हटा दिए जाते हैं:"abcba".lstrip("ba") == "cba"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
chars
|
string; या None;
डिफ़ॉल्ट रूप से Noneहै हटाए जाने वाले वर्ण या कोई खाली सफ़ेद जगह न होने पर, सभी खाली सफ़ेद जगह. |
पार्टीशन
tuple string.partition(sep)इनपुट स्ट्रिंग को सेपरेटर
sep की पहली एंट्री पर बांटा जाता है. साथ ही, नतीजे के तौर पर मिलने वाले सेगमेंट को, फ़ॉर्म के तीन एलिमेंट वाले ट्यूपल (पहले, सेपरेटर, बाद में) के तौर पर दिखाता है. अगर इनपुट स्ट्रिंग में सेपरेटर नहीं है, तो partition फ़ंक्शन (self, '', '') दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
string;
ज़रूरी है विभाजित की जाने वाली स्ट्रिंग. |
प्रीफ़िक्स हटाएं
string string.removeprefix(prefix)अगर स्ट्रिंग
prefix से शुरू होती है, तो प्रीफ़िक्स को हटाकर नई स्ट्रिंग डाली जाती है. ऐसा न होने पर, स्ट्रिंग दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
prefix
|
स्ट्रिंग;
ज़रूरी है अगर प्रीफ़िक्स मौजूद है, तो उसे हटाएं. |
removesuffix
string string.removesuffix(suffix)अगर स्ट्रिंग
suffix पर खत्म होती है, तो सफ़िक्स हटाकर एक नई स्ट्रिंग दिखाती है. ऐसा न होने पर, स्ट्रिंग दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
suffix
|
string;
ज़रूरी है अगर कोई सफ़िक्स मौजूद है, तो उसे हटाएं. |
बदलें
string string.replace(old, new, count=-1)उस स्ट्रिंग की कॉपी दिखाता है जिसमें
old को new से बदल दिया गया है. यह फ़ंक्शन, वैकल्पिक तौर पर count को सीमित करता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
old
|
string;
ज़रूरी है बदली जाने वाली स्ट्रिंग. |
new
|
string;
ज़रूरी है वह स्ट्रिंग जिसे बदलना है. |
count
|
int;
डिफ़ॉल्ट रूप से -1है आइटम बदलने की ज़्यादा से ज़्यादा संख्या. अगर वैल्यू नहीं दी गई है या वैल्यू नेगेटिव है, तो कोई सीमा नहीं होगी. |
rfind
int string.rfind(sub, start=0, end=None)वह आखिरी इंडेक्स लौटाता है जहां
sub मिलता है या अगर कोई इंडेक्स मौजूद नहीं है, तो -1 दिखाता है. वैकल्पिक तौर पर, इसे [start:end] तक सीमित करता है, start को शामिल करता है और end को खास बनाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string;
ज़रूरी है ढूंढने के लिए सबस्ट्रिंग. |
start
|
int या None;
डिफ़ॉल्ट तौर पर 0होता है इस पोज़िशन से खोजने पर पाबंदी लगाएं. |
end
|
int या None;
डिफ़ॉल्ट तौर पर Noneखोज के लिए पाबंदी लगाने से पहले की वैकल्पिक स्थिति. |
rindex
int string.rindex(sub, start=0, end=None)यह उस आखिरी इंडेक्स की वैल्यू दिखाता है जहां
sub मिलता है. अगर ऐसा कोई इंडेक्स नहीं मिलता है, तो गड़बड़ी का मैसेज दिखाता है. इसके अलावा, [start:end], start, और end में से किसी एक पर भी पाबंदी लगाई जा सकती है. start में शामिल और end में शामिल नहीं होने वाले वैल्यू को शामिल किया जाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string;
ज़रूरी है वह सबस्ट्रिंग जिसे ढूंढना है. |
start
|
int; या None;
डिफ़ॉल्ट 0है इस स्थान से खोजने तक सीमित करें. |
end
|
int या None;
डिफ़ॉल्ट तौर पर Noneखोज के लिए पाबंदी लगाने से पहले की वैकल्पिक स्थिति. |
rपार्टिशन
tuple string.rpartition(sep)यह फ़ंक्शन, सेपरेटर
sep की आखिरी बार आने पर इनपुट स्ट्रिंग को बांट देता है. साथ ही, नतीजे के तौर पर मिलने वाले सेगमेंट को, फ़ॉर्म के तीन एलिमेंट वाले ट्यूपल (पहले, सेपरेटर, बाद में) के तौर पर दिखाता है. अगर इनपुट स्ट्रिंग में सेपरेटर नहीं है, तो rpartition फ़ंक्शन ('', '', self) दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
string;
ज़रूरी है वह स्ट्रिंग जिसे बांटना है. |
rsplit
list string.rsplit(sep, maxsplit=None)यह फ़ंक्शन
sep को सेपरेटर के तौर पर इस्तेमाल करके, स्ट्रिंग में मौजूद सभी शब्दों की सूची दिखाता है. हालांकि, यह फ़ंक्शन, स्प्लिट की संख्या को maxsplit तक सीमित करता है. दाईं ओर से बांटने के अलावा, यह तरीका split() की तरह काम करता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
string;
ज़रूरी है वह स्ट्रिंग जिसे बांटना है. |
maxsplit
|
int या None;
डिफ़ॉल्ट तौर पर Noneस्प्लिट की ज़्यादा से ज़्यादा संख्या. |
आरएसट्रिप
string string.rstrip(chars=None)
chars में दिखने वाले आखिरी वर्णों को हटाकर, स्ट्रिंग की कॉपी दिखाता है. ध्यान दें कि chars कोई सफ़िक्स नहीं है: इसकी वैल्यू के सभी कॉम्बिनेशन हटा दिए जाते हैं:"abcbaa".rstrip("ab") == "abc"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
chars
|
string या None;
डिफ़ॉल्ट तौर पर Noneहोता है हटाने के लिए वर्ण या None होने पर सभी खाली जगहें. |
बांटें
list string.split(sep, maxsplit=None)
sep को सेपरेटर के तौर पर इस्तेमाल करके, स्ट्रिंग में मौजूद सभी शब्दों की सूची दिखाता है. इसके अलावा, आपके पास स्ट्रिंग को maxsplit तक के हिस्सों में बांटने का विकल्प भी होता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
string;
ज़रूरी है वह स्ट्रिंग जिसे बांटना है. |
maxsplit
|
int या None;
डिफ़ॉल्ट तौर पर Noneस्प्लिट की ज़्यादा से ज़्यादा संख्या. |
splitlines
sequence string.splitlines(keepends=False)यह फ़ंक्शन, स्ट्रिंग को लाइन की सीमाओं ('\n', '\r\n', '\r') पर बांटता है और नतीजे को बदली जा सकने वाली नई सूची के तौर पर दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
keepends
|
bool;
डिफ़ॉल्ट रूप से Falseहै नतीजे की सूची में लाइन ब्रेक को शामिल किया जाना चाहिए या नहीं. |
इससे शुरू होता है
bool string.startswith(sub, start=0, end=None)अगर स्ट्रिंग
sub से शुरू होती है, तो True दिखाता है. ऐसा न होने पर False दिखाता है. इसके अलावा, [start:end], start, और end पर भी पाबंदी लगाई जा सकती है. start में sub शामिल होता है, जबकि end में शामिल नहीं होता.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string; या स्ट्रिंग का टपल;
ज़रूरी है मिलान करने के लिए प्रीफ़िक्स (या वैकल्पिक प्रीफ़िक्स का टपल). |
start
|
int; या None;
डिफ़ॉल्ट 0है इस पोज़िशन से शुरू होने वाली जांच. |
end
|
int; या None;
डिफ़ॉल्ट रूप से Noneहै इस पोज़िशन पर तुलना करना बंद करें. |
स्ट्रिप
string string.strip(chars=None)उस स्ट्रिंग की कॉपी देता है जिसमें
chars में दिखने वाले आगे या पीछे के वर्ण हटा दिए जाते हैं. ध्यान दें कि chars न तो प्रीफ़िक्स है और न ही सफ़िक्स: इसकी वैल्यू के सभी कॉम्बिनेशन हटा दिए जाते हैं:"aabcbcbaa".strip("ab") == "cbc"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
chars
|
string या None;
डिफ़ॉल्ट तौर पर Noneहोता है हटाने के लिए वर्ण या None होने पर सभी खाली जगहें. |
title
string string.title()इनपुट स्ट्रिंग को टाइटल केस में बदलता है. इसका मतलब है कि हर शब्द अपरकेस लेटर से शुरू होता है, जबकि बाकी अक्षर लोअरकेस में होते हैं. इस संदर्भ में शब्द का मतलब है, पूरी तरह से अक्षरों का क्रम. इस तरीके में, यूनिकोड के अतिरिक्त वर्णों का इस्तेमाल नहीं किया जा सकता.
ऊपर का
string string.upper()इस स्ट्रिंग का अपरकेस वर्शन दिखाता है.