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 = [s for s.elems() in "abc"] # x == ["a", "b", "c"]स्ट्रिंग को किसी दूसरे तरीके से जोड़ने की अनुमति नहीं है. इसके बजाय,
+ ऑपरेटर का इस्तेमाल करें. कंपैरिज़न ऑपरेटर, शब्दों की मदद से तुलना करते हैं. बराबरी की जांच करने के लिए, == का इस्तेमाल करें.
पैसे चुकाकर बने सदस्य
- कैपिटल लेटर का इस्तेमाल करें
- count
- elems
- endswith
- ढूंढें
- फ़ॉर्मैट
- इंडेक्स
- isalnum
- isऐल्फ़ा
- isडिजिट
- कम संख्या में
- isspace
- istitle
- isupper
- join
- कम
- एलस्ट्रिप
- पार्टिशन
- प्रीफ़िक्स हटाएं
- हटाएं
- बदलें
- आरफ़ाइंड
- इंडेक्स
- पार्टिशन
- rsplit
- आरस्ट्रिप
- स्प्लिट
- स्प्लिटलाइन
- startswith
- स्ट्रिप
- टाइटल
- ऊपरी
अक्षर बड़े करें
string string.capitalize()स्ट्रिंग की ऐसी कॉपी दिखाता है जिसमें पहला वर्ण (अगर कोई है) कैपिटल लेटर का हो और बाकी वर्ण छोटे अक्षरों में हो. यह विधि गैर-ascii वर्णों का समर्थन नहीं करती है.
सोलर पैनलों की संख्या
int string.count(sub, start=0, end=None)स्ट्रिंग में
sub सबस्ट्रिंग की (ओवरलैपिंग नहीं होने वाली) की संख्या दिखाता है. हालांकि, वैकल्पिक रूप से [start:end] तक सीमित करके, start को शामिल किया जाता है और end खास होता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
ज़रूरी है वह सबस्ट्रिंग डालें जिसकी गिनती करनी है. |
start
|
int; or None;
डिफ़ॉल्ट = 0इस पोज़िशन से खोजने के लिए सीमित करें. |
end
|
int; or None;
डिफ़ॉल्ट = कोई नहींवैकल्पिक स्थिति जिससे पहले खोज के लिए सीमित करना है. |
Elems
sequence string.elems()स्ट्रिंग की क्रमिक 1-तत्व सबस्ट्रिंग वाला कोई बार-बार किया जा सकने वाला मान देता है. यह
[s[i] for i in range(len(s))] के बराबर है. हालांकि, हो सकता है कि लौटाया गया वैल्यू, सूची न हो.
इससे खत्म होता है
bool string.endswith(sub, start=0, end=None)अगर स्ट्रिंग
sub पर खत्म होती है, तो 'सही' दिखाता है. ऐसा न होने पर 'गलत' दिखाता है. वैकल्पिक रूप से, [start:end] तक सीमित करके, start को शामिल करता है और end खास होता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string; or tuple of strings;
ज़रूरी हैमिलान करने के लिए सफ़िक्स (या वैकल्पिक सफ़िक्स का टपल) क्या है. |
start
|
int; or None;
डिफ़ॉल्ट = 0इस पोज़िशन से शुरू होने वाला टेस्ट करें. |
end
|
int; or None;
डिफ़ॉल्ट = कोई नहींवैकल्पिक स्थिति जिस पर तुलना को बंद करना है. |
ढूंढें
int string.find(sub, start=0, end=None)वह पहला इंडेक्स दिखाता है जहां
sub मिला है. अगर ऐसा कोई इंडेक्स मौजूद नहीं है, तो -1 दिखाता है. वैकल्पिक रूप से, [start:end] तक सीमित करके, start को शामिल करता है और end को खास बनाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
ज़रूरी है वह सबस्ट्रिंग जिसे ढूंढना है. |
start
|
int; or None;
डिफ़ॉल्ट = 0इस पोज़िशन से खोजने के लिए सीमित करें. |
end
|
int; or 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
|
ज़रूरी है वह सबस्ट्रिंग जिसे ढूंढना है. |
start
|
int; or None;
डिफ़ॉल्ट = 0इस पोज़िशन से खोजने के लिए सीमित करें. |
end
|
int; or None;
डिफ़ॉल्ट = कोई नहींवैकल्पिक स्थिति जिससे पहले खोज के लिए सीमित करना है. |
Isalnum
bool string.isalnum()अगर स्ट्रिंग के सभी वर्ण अक्षर और अंक ([a-zA-Z0-9]) हैं और कम से कम एक वर्ण है, तो 'सही' दिखाता है.
इलाफ़ा
bool string.isalpha()अगर स्ट्रिंग में सभी वर्ण अक्षर ([a-zA-Z]) हैं और कम से कम एक वर्ण है, तो 'सही' दिखाता है.
isडिजिट
bool string.isdigit()अगर स्ट्रिंग में सभी वर्ण ([0-9]) हैं और कम से कम एक वर्ण है, तो 'सही' दिखाता है.
इलोवर
bool string.islower()अगर स्ट्रिंग में सभी केस वाले वर्ण छोटे हैं और कम से कम एक वर्ण है, तो 'सही' दिखाता है.
isspace (स्पेस)
bool string.isspace()अगर सभी वर्ण व्हाइट स्पेस वाले वर्ण हैं और स्ट्रिंग में कम से कम एक वर्ण है, तो 'सही' दिखाता है.
istitle
bool string.istitle()अगर स्ट्रिंग, टाइटल केस में है और उसमें कम से कम एक वर्ण है, तो 'सही' दिखाता है. इसका मतलब है कि हर अपरकेस वर्ण को, अंग्रेज़ी के बड़े अक्षरों वाले वर्ण के बाद आना चाहिए, जैसे कि खाली सफ़ेद जगह. साथ ही, हर अंग्रेज़ी के छोटे अक्षर के बाद, केस वाला वर्ण होना चाहिए (जैसे कि अंग्रेज़ी के बड़े अक्षर या छोटे अक्षर).
Isupper
bool string.isupper()अगर स्ट्रिंग में सभी केस वाले वर्ण अपरकेस हैं और कम से कम एक वर्ण है, तो 'सही' दिखाता है.
join
string string.join(elements)ऐसी स्ट्रिंग दिखाता है जिसमें आर्ग्युमेंट के स्ट्रिंग एलिमेंट, सेपरेटर के तौर पर इस स्ट्रिंग की मदद से जोड़े गए हैं. उदाहरण:
"|".join(["a", "b", "c"]) == "a|b|c"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
elements
|
ज़रूरी है जुड़ने के लिए ऑब्जेक्ट. |
निचला
string string.lower()इस स्ट्रिंग के लोअर केस वर्शन दिखाता है.
एलस्ट्रिप
string string.lstrip(chars=None)स्ट्रिंग की कॉपी दिखाता है, जहां
chars में दिखने वाले मुख्य वर्ण हटा दिए जाते हैं. ध्यान दें कि chars, कोई प्रीफ़िक्स नहीं है: इसकी वैल्यू के सभी कॉम्बिनेशन हटा दिए जाते हैं:"abcba".lstrip("ba") == "cba"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
chars
|
string; or None;
डिफ़ॉल्ट = कोई नहींहटाए जाने वाले वर्ण या अगर कोई नहीं है, तो सभी खाली सफ़ेद जगह. |
बंटवारा
tuple string.partition(sep)सेपरेटर
sep की पहली एंट्री पर, इनपुट स्ट्रिंग को अलग-अलग कर देता है. इसके बाद, नतीजे के तौर पर मिलने वाले पार्टीशन को फ़ॉर्म के तीन एलिमेंट वाले टपल (पहले, सेपरेटर, बाद में) के तौर पर दिखाता है. अगर इनपुट स्ट्रिंग में सेपरेटर को शामिल नहीं किया गया है, तो सेगमेंट में बांटा जाता है (self, '', '').
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
ज़रूरी है वह स्ट्रिंग जिसे अलग करना है. |
उपसर्ग हटाएं
string string.removeprefix(prefix)अगर स्ट्रिंग
prefix से शुरू होती है, तो प्रीफ़िक्स हटाकर नई स्ट्रिंग दिखाता है. ऐसा न होने पर, स्ट्रिंग दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
prefix
|
ज़रूरी है अगर कोई प्रीफ़िक्स मौजूद हो, तो उसे हटाना ज़रूरी है. |
CANNOT TRANSLATE
string string.removesuffix(suffix)अगर स्ट्रिंग
suffix पर खत्म होती है, तो सफ़िक्स हटाकर नई स्ट्रिंग दिखाता है. ऐसा न होने पर, स्ट्रिंग दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
suffix
|
ज़रूरी है अगर कोई सफ़िक्स मौजूद हो, तो उसे हटाना ज़रूरी है. |
बदलें
string string.replace(old, new, count=-1)उस स्ट्रिंग की कॉपी दिखाता है जिसमें
old को new से बदल दिया गया है. वैकल्पिक रूप से, आइटम बदलने की संख्या को maxsplit तक सीमित कर दिया गया है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
old
|
ज़रूरी है वह स्ट्रिंग जिसे बदलना है. |
new
|
ज़रूरी है वह स्ट्रिंग जिसे बदला जाना है. |
count
|
डिफ़ॉल्ट = -1 आइटम बदलने की ज़्यादा से ज़्यादा संख्या. अगर छोड़ दिया जाता है या मान नेगेटिव है, तो कोई सीमा नहीं है. |
आरफ़ाइंड
int string.rfind(sub, start=0, end=None)वह आखिरी इंडेक्स दिखाता है जहां
sub मिला था. अगर ऐसा कोई इंडेक्स मौजूद नहीं है, तो -1 दिखाता है. वैकल्पिक रूप से, [start:end] तक सीमित करके, start को शामिल करता है और end को खास बनाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
ज़रूरी है वह सबस्ट्रिंग जिसे ढूंढना है. |
start
|
int; or None;
डिफ़ॉल्ट = 0इस पोज़िशन से खोजने के लिए सीमित करें. |
end
|
int; or None;
डिफ़ॉल्ट = कोई नहींवैकल्पिक स्थिति जिससे पहले खोज के लिए सीमित करना है. |
rindex
int string.rindex(sub, start=0, end=None)वह आखिरी इंडेक्स दिखाता है जहां
sub मिला था. अगर ऐसा कोई इंडेक्स मौजूद नहीं है, तो यह गड़बड़ी दिखाता है. वैकल्पिक रूप से, यह [start:end] को सीमित करता है, start को शामिल करता है, और end को खास बनाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
ज़रूरी है वह सबस्ट्रिंग जिसे ढूंढना है. |
start
|
int; or None;
डिफ़ॉल्ट = 0इस पोज़िशन से खोजने के लिए सीमित करें. |
end
|
int; or None;
डिफ़ॉल्ट = कोई नहींवैकल्पिक स्थिति जिससे पहले खोज के लिए सीमित करना है. |
विभाजन
tuple string.rpartition(sep)यह इनपुट स्ट्रिंग को सेपरेटर
sep के आखिरी बार आने पर बांट देता है. इसके बाद, नतीजे के तौर पर मिलने वाले बंटवारे को फ़ॉर्म के तीन एलिमेंट वाले टपल के तौर पर लौटाता है (पहले, सेपरेटर, बाद में). अगर इनपुट स्ट्रिंग में सेपरेटर को शामिल नहीं किया गया है, तो रा पार्टीशन ('', '', सेल्फ़) दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
ज़रूरी है वह स्ट्रिंग जिसे अलग करना है. |
rsplit
list string.rsplit(sep, maxsplit=None)
sep को सेपरेटर के तौर पर इस्तेमाल करके, स्ट्रिंग के सभी शब्दों की सूची दिखाता है. हालांकि, स्प्लिट की संख्या को maxsplit तक सीमित कर दिया जाता है. दाईं ओर से स्प्लिट करने के अलावा, यह तरीका स्प्लिट() की तरह काम करता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
ज़रूरी है वह स्ट्रिंग जिसे अलग करना है. |
maxsplit
|
int; or None;
डिफ़ॉल्ट = कोई नहींस्प्लिट की ज़्यादा से ज़्यादा संख्या. |
आरस्ट्रिप
string string.rstrip(chars=None)स्ट्रिंग की कॉपी दिखाता है, जहां
chars में दिखने वाले बाद के वर्ण हटा दिए जाते हैं. ध्यान दें कि chars, सफ़िक्स नहीं है: इसकी वैल्यू के सभी कॉम्बिनेशन हटा दिए जाते हैं:"abcbaa".rstrip("ab") == "abc"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
chars
|
string; or None;
डिफ़ॉल्ट = कोई नहींहटाए जाने वाले वर्ण या अगर कोई नहीं है, तो सभी खाली सफ़ेद जगह. |
बांटें
list string.split(sep, maxsplit=None)
sep को सेपरेटर के तौर पर इस्तेमाल करके, स्ट्रिंग के सभी शब्दों की सूची दिखाता है. हालांकि, स्प्लिट की संख्या को maxsplit तक सीमित कर दिया जाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
ज़रूरी है वह स्ट्रिंग जिसे अलग करना है. |
maxsplit
|
int; or None;
डिफ़ॉल्ट = कोई नहींस्प्लिट की ज़्यादा से ज़्यादा संख्या. |
स्प्लिटलाइन
sequence string.splitlines(keepends=False)स्ट्रिंग को लाइन की सीमाओं ('\n', '\r\n', '\r') पर बांट देता है और नतीजे को बदली जा सकने वाली नई सूची के तौर पर दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
keepends
|
डिफ़ॉल्ट = गलत तय करें कि नतीजे वाली सूची में लाइन ब्रेक शामिल किए जाने चाहिए या नहीं. |
startswith
bool string.startswith(sub, start=0, end=None)सही है अगर स्ट्रिंग
sub से शुरू होती है, नहीं तो 'गलत' है, वैकल्पिक रूप से [start:end], start शामिल है, और end खास है पर सीमित होती है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string; or tuple of strings;
ज़रूरी हैमिलान करने के लिए, प्रीफ़िक्स (या वैकल्पिक प्रीफ़िक्स का टपल) डालें. |
start
|
int; or None;
डिफ़ॉल्ट = 0इस पोज़िशन से शुरू होने वाला टेस्ट करें. |
end
|
int; or None;
डिफ़ॉल्ट = कोई नहींइस पोज़िशन पर तुलना करना बंद करें. |
पट्टी
string string.strip(chars=None)स्ट्रिंग की कॉपी दिखाता है, जहां
chars में दिखने वाले शुरुआत या आखिर के वर्णों को हटा दिया जाता है. ध्यान दें कि chars, न तो कोई प्रीफ़िक्स है और न ही कोई सफ़िक्स: इसकी वैल्यू के सभी कॉम्बिनेशन हटा दिए जाते हैं:"aabcbcbaa".strip("ab") == "cbc"
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
chars
|
string; or None;
डिफ़ॉल्ट = कोई नहींहटाए जाने वाले वर्ण या अगर कोई नहीं है, तो सभी खाली सफ़ेद जगह. |
टाइटल
string string.title()इनपुट स्ट्रिंग को टाइटल केस में बदलता है, यानी कि हर शब्द अपरकेस अक्षर से शुरू होता है, जबकि बाकी के अक्षर लोअरकेस में होते हैं. इस संदर्भ में, शब्द का मतलब है अक्षरों का क्रम. यह तरीका, यूनिकोड वर्णों के साथ काम नहीं करता.
ऊपर का
string string.upper()इस स्ट्रिंग के बड़े अक्षरों वाला वर्शन दिखाता है.