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