स्ट्रिंग के साथ काम करने के लिए, पहले से मौजूद भाषा का टाइप. स्ट्रिंग लिटरल के उदाहरण:
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"]स्ट्रिंग को सीधे तौर पर जोड़ने की अनुमति नहीं है. इसके बजाय,
+ ऑपरेटर का इस्तेमाल करें. तुलना करने वाले ऑपरेटर, शब्दों की मदद से तुलना करते हैं. समानता की जांच करने के लिए, == का इस्तेमाल करें.
सदस्य
- कैपिटल लेटर
- संख्या
- एल्म्स
- endswith
- find
- format
- index
- isalnum
- इसऐल्फ़ा
- isdigit
- islower
- isspace
- istitle
- isupper
- शामिल हों
- कम
- लिस्टस्ट्रिप
- पार्टिशन
- removeprefix
- removesuffix
- बदलें
- rfind
- rindex
- पार्टिशन
- rsplit
- आरएसट्रिप
- split
- splitlines
- startswith
- strip
- title
- upper
अक्षर बड़े करें
string string.capitalize()स्ट्रिंग की एक कॉपी दिखाता है, जिसमें पहले वर्ण (अगर कोई है) को अपरकेस में और बाकी वर्णों को लोअरकेस में दिखाया जाता है. इस तरीके में, ASCII के अलावा दूसरे वर्ण काम नहीं करते.
सोलर पैनलों की संख्या
int string.count(sub, start=0, end=None)स्ट्रिंग में सबस्ट्रिंग
sub के ओवरलैप न होने वाली जगहों की संख्या दिखाता है. इसके लिए, [start:end], start, और end का इस्तेमाल किया जा सकता है. [start:end] में ओवरलैप वाली जगहें शामिल होती हैं, जबकि start और end में नहीं.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
ज़रूरी है वह सबस्ट्रिंग जिसकी गिनती करनी है. |
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 पर खत्म होती है, नहीं तो गलत, वैकल्पिक रूप से [start:end] तक सीमित होती है, start को शामिल किया जाता है और end को शामिल नहीं किया जाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
string; या string का टपल;
ज़रूरी है मैच करने के लिए सफ़िक्स (या वैकल्पिक सफ़िक्स के टपल). |
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]) हैं और कम से कम एक वर्ण है, तो True दिखाता है.
इज़डिजिट
bool string.isdigit()सही है अगर स्ट्रिंग के सभी वर्ण अंक ([0-9]) हैं और कम से कम एक वर्ण है.
islower
bool string.islower()अगर स्ट्रिंग में सभी केस वाले वर्ण लोअरकेस में हैं और कम से कम एक वर्ण है, तो True दिखाता है.
isspace
bool string.isspace()अगर सभी वर्ण व्हाइट स्पेस वर्ण हैं और स्ट्रिंग में कम से कम एक वर्ण है, तो True वैल्यू मिलती है.
istitle
bool string.istitle()सही है अगर स्ट्रिंग, टाइटल केस में है और उसमें कम से कम एक वर्ण है. इसका मतलब है कि हर अपरकेस वर्ण के बाद, कोई ऐसा वर्ण होना चाहिए जिसमें केस न हो (जैसे, खाली जगह). साथ ही, हर लोअरकेस वर्ण के बाद, कोई ऐसा वर्ण होना चाहिए जिसमें केस हो (जैसे, अपरकेस या लोअरकेस).
Isupper
bool string.isupper()सही है अगर स्ट्रिंग के सभी केस-सेंसिटिव (बड़े और छोटे अक्षरों में अंतर) वर्ण हैं और कम से कम एक वर्ण है.
जोड़ना
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
|
ज़रूरी है वह स्ट्रिंग जिसे बांटना है. |
removeprefix
string string.removeprefix(prefix)अगर स्ट्रिंग
prefix से शुरू होती है, तो प्रीफ़िक्स हटाकर एक नई स्ट्रिंग दिखाता है. ऐसा न होने पर, स्ट्रिंग दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
prefix
|
ज़रूरी अगर प्रीफ़िक्स मौजूद है, तो उसे हटाने के लिए. |
removesuffix
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 में से किसी एक पर पाबंदी लगाई जा सकती है. start में शामिल और end में शामिल नहीं होने वाले वैल्यू को शामिल किया जाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
ज़रूरी है ढूंढने के लिए सबस्ट्रिंग. |
start
|
int; या None;
डिफ़ॉल्ट 0 हैइस पोज़िशन से खोजने पर सीमित करें. |
end
|
int; या None;
डिफ़ॉल्ट जगह Noneवैकल्पिक होती है, जिसके पहले खोज करनी है. |
rपार्टिशन
tuple string.rpartition(sep)यह फ़ंक्शन, इनपुट स्ट्रिंग को सेपरेटर
sep के आखिरी बार दिखने पर बांट देता है. साथ ही, इस फ़ंक्शन से मिलने वाले हिस्से को (before, separator, after) फ़ॉर्मैट में तीन एलिमेंट वाले टपल के तौर पर दिखाता है. अगर इनपुट स्ट्रिंग में सेपरेटर नहीं है, तो rpartition फ़ंक्शन ('', '', self) दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
ज़रूरी है वह स्ट्रिंग जिसे बांटना है. |
rsplit
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होता है हटाने के लिए वर्ण या 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 से शुरू होती है, तो True दिखाता है. ऐसा न होने पर False दिखाता है. इसके अलावा, [start:end], start, और end पर भी पाबंदी लगाई जा सकती है. start में शामिल और end में शामिल नहीं होने वाले वैल्यू को दिखाया जाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sub
|
स्ट्रिंग या स्ट्रिंग का ट्यूपल;
ज़रूरी है मैच करने के लिए प्रीफ़िक्स (या वैकल्पिक प्रीफ़िक्स का ट्यूपल). |
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()इस स्ट्रिंग के अपर केस वर्शन को दिखाता है.