Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> Python

पायथन स्ट्रिंग तरीके?

पायथन बहुत सारी अंतर्निहित विधियाँ प्रदान करता है जिनका उपयोग हम स्ट्रिंग्स पर कर सकते हैं।

पायथन 3 में उपलब्ध स्ट्रिंग विधियों की सूची नीचे दी गई है।

विधि
विवरण
उदाहरण
capitalize()
स्ट्रिंग की एक कॉपी लौटाता है, जिसके पहले कैरेक्टर को कैपिटल किया जाता है और बाकी को लोअरकेस किया जाता है।
>>> mystring = "hello python"
>>> print(mystring.capitalize())
Hello python
केसफोल्ड ()
स्ट्रिंग की केस फोल्डेड कॉपी लौटाता है। केस-फोल्डेड स्ट्रिंग्स का उपयोग केसलेस मिलान के लिए किया जा सकता है।
>>> mystring = "hello PYTHON"
>>> print(mystring.casefold())
hello python
केंद्र (चौड़ाई, [fillchar])
लंबाई की स्ट्रिंग में केंद्रित स्ट्रिंग लौटाता है चौड़ाई . निर्दिष्ट fillchar . का उपयोग करके पैडिंग की जा सकती है (डिफ़ॉल्ट पैडिंग ASCII स्थान का उपयोग करता है)। मूल स्ट्रिंग लौटा दी जाती है यदि चौड़ाई लेन से कम या बराबर है
>>> mystring = "Hello"
>>> x = mystring.center(12,
"-")
>>> print(x)
---Hello----
गणना (उप, [शुरू], [अंत])
सबस्ट्रिंग (sub) की गैर-अतिव्यापी घटनाओं की संख्या लौटाता है ) सीमा में [शुरू करें , समाप्त ]. वैकल्पिक तर्क शुरू करें और समाप्त स्लाइस नोटेशन के रूप में व्याख्या की जाती है।
>>> mystr = "Hello Python"
>>> print(mystr.count("o"))
2
>>> print(mystr.count("th"))
1
>>> print(mystr.count("l"))
2
>>> print(mystr.count("h"))
1
>>> print(mystr.count("H"))
1
>>> print(mystr.count("hH"))
0
एनकोड (एन्कोडिंग ="utf-g", त्रुटियां ="सख्त")
बाइट्स ऑब्जेक्ट के रूप में स्ट्रिंग का एन्कोडेड संस्करण देता है। डिफ़ॉल्ट एन्कोडिंग utf-8 है। एक अलग त्रुटि प्रबंधन योजना सेट करने के लिए त्रुटियां दी जा सकती हैं। त्रुटियों के लिए संभावित मान हैं:
  • सख्त (एन्कोडिंग त्रुटियां एक यूनिकोड त्रुटि उत्पन्न करती हैं)

  • अनदेखा करें

  • बदलें

  • xmlcharrereplace

  • बैकस्लैश रिप्लेस

  • codecs.register_error()

    . के माध्यम से पंजीकृत कोई अन्य नाम

>>> mystr = 'python!'
>>> print('The string is:',
mystr)
The string is: python!
>>> print('The encoded
version is: ',
mystr.encode("ascii",
"ignore"))
The encoded version is:
b'python!'
>>> print('The encoded
version (with replace) is:',
mystr.encode("ascii",
"replace"))
The encoded version (with
replace) is: b'python!'
समाप्त होता है(प्रत्यय, [शुरू], [अंत])
यदि स्ट्रिंग निर्दिष्ट प्रत्यय के साथ समाप्त होती है, तो यह सही है, अन्यथा यह गलत है।
>>> mystr = "Python"
>>>
print(mystr.endswith("y"))
False
>>>
print(mystr.endswith("hon"))
True
Expandtabs(tabsize=8)
स्ट्रिंग की एक प्रति देता है जहां सभी टैब वर्णों को वर्तमान कॉलम और दिए गए टैब आकार के आधार पर एक या अधिक रिक्त स्थान से बदल दिया जाता है।
>>> mystr = "1\t2\t3"
>>> print(mystr)
1 2 3
>>>
print(mystr.expandtabs())
1 2 3
>>>
print(mystr.expandtabs(tabsi
ze=15))
1 2
3
>>>
print(mystr.expandtabs(tabsi
ze=2))
1 2 3
Find(sub, [start], [end])
स्ट्रिंग में सबसे कम इंडेक्स देता है जहां सबस्ट्रिंग उप है स्लाइस एस [प्रारंभ:अंत] के भीतर पाया जाता है।
>>> mystring = "Python"
>>>
print(mystring.find("P"))
0
>>>
print(mystring.find("on"))
4
Format(*args, **kwargs)
एक स्ट्रिंग स्वरूपण कार्रवाई करता है। जिस स्ट्रिंग पर इस विधि को कॉल किया जाता है, उसमें ब्रेसिज़ {} द्वारा सीमांकित शाब्दिक टेक्स्ट या प्रतिस्थापन फ़ील्ड हो सकते हैं।
>>> print("{} and
{}".format("Apple",
"Banana"))
Apple and Banana
>>> print("{1} and
{0}".format("Apple",
"Banana"))
Banana and Apple
>>> print("{lunch} and
{dinner}".format(lunch="Peas
", dinner="Beans"))
Peas and Beans
format_map(mapping)
प्रारूप (** मानचित्रण) के समान, सिवाय इसके कि मानचित्रण का उपयोग सीधे किया जाता है और किसी शब्दकोश में कॉपी नहीं किया जाता है।
>>> lunch = {"Food":
"Pizza", "Drink": "Wine"}
>>> print("Lunch: {Food},
{Drink}".format_map(lunch))
Lunch: Pizza, Wine
>>> class Default(dict):
def __missing__(self,
key):
return key
>>> lunch = {"Drink":
"Wine"}
>>> print("Lunch: {Food},
{Drink}".format_map(Default(
lunch)))
Lunch: Food, Wine
Index(sub, [start], [end])
एक निर्दिष्ट मान के लिए स्ट्रिंग की खोज करता है और जहां पाया गया था उसकी स्थिति देता है
>>> mystr = "HelloPython"
>>> print(mystr.index("P"))
5
>>>
print(mystr.index("hon"))
8
>>> print(mystr.index("o"))
4
isalnum
यदि स्ट्रिंग में सभी वर्ण अक्षरांकीय हैं तो सही है
>>> mystr = "HelloPython"
>>> print(mystr.isalnum())
True
>>> a = "123"
>>> print(a.isalnum())
True
>>> a= "$*%!!!"
>>> print(a.isalnum())
False
Isalpha()
यदि स्ट्रिंग में सभी वर्ण वर्णमाला में हैं तो सही है
>>> mystr = "HelloPython"
>>> print(mystr.isalpha())
True
>>> a = "123"
>>> print(a.isalpha())
False
>>> a= "$*%!!!"
>>> print(a.isalpha())
False
Isdecimal()
यदि स्ट्रिंग में सभी वर्ण दशमलव हैं तो सही है
>>> mystr = "HelloPython"
>>> print(mystr.isdecimal())
False
>>> a="1.23"
>>> print(a.isdecimal())
False
>>> c = u"\u00B2"
>>> print(c.isdecimal())
False
>>> c="133"
>>> print(c.isdecimal())
True
Isdigit()
यदि स्ट्रिंग में सभी वर्ण अंक हैं तो सही है
>>> c="133"
>>> print(c.isdigit())
True
>>> c = u"\u00B2"
>>> print(c.isdigit())
True
>>> a="1.23"
>>> print(a.isdigit())
False
isidentifier()
यदि स्ट्रिंग एक पहचानकर्ता है तो सही है
>>> c="133"
>>> print(c.isidentifier())
False
>>> c="_user_123"
>>> print(c.isidentifier())
True
>>> c="Python"
>>> print(c.isidentifier())
True
Islower()
यदि स्ट्रिंग में सभी वर्ण लोअरकेस हैं तो सही है
>>> c="Python"
>>> print(c.islower())
False
>>> c="_user_123"
>>> print(c.islower())
True
>>> print(c.islower())
False
Isnumeric()
यदि स्ट्रिंग में सभी वर्ण संख्यात्मक हैं तो सही है
>>> c="133"
>>> print(c.isnumeric())
True
>>> c="_user_123"
>>> print(c.isnumeric())
False
>>> c="Python"
>>> print(c.isnumeric())
False
isprintable()
यदि स्ट्रिंग में सभी वर्ण प्रिंट करने योग्य हैं तो सही है
>>> c="133"
>>> print(c.isprintable())
True
>>> c="_user_123"
>>> print(c.isprintable())
True
>>> c="\t"
>>> print(c.isprintable())
False
isspace()
यदि स्ट्रिंग में सभी वर्ण रिक्त स्थान हैं तो सही है
>>> c="133"
>>> print(c.isspace())
False
>>> c="Hello Python"
>>> print(c.isspace())
False
73
>>> c="Hello"
>>> print(c.isspace())
False
>>> c="\t"
>>> print(c.isspace())
True
istitle()
यदि स्ट्रिंग शीर्षक के नियमों का पालन करती है तो सही है
>>> c="133"
>>> print(c.istitle())
False
>>> c="Python"
>>> print(c.istitle())
True
>>> c="\t"
>>> print(c.istitle())
False
isupper()
यदि स्ट्रिंग में सभी वर्ण अपरकेस हैं तो सही है
>>> c="Python"
>>> print(c.isupper())
False
>>> c="PYHTON"
>>> print(c.isupper())
True
>>> c="\t"
>>> print(c.isupper())
False
join(iterable)
स्ट्रिंग के अंत तक चलने योग्य तत्वों को जोड़ता है
>>> a ="-"
>>> print(a.join("123"))
1-2-3
>>> a="Hello Python"
>>> a="**"
>>> print(a.join("Hello
Python"))
H**e**l**l**o**
**P**y**t**h**o**n
ljust( चौड़ाई [, भरना ])
स्ट्रिंग का बायां उचित संस्करण देता है
>>> a="Hello"
>>> b = a.ljust(12, "_")
>>> print(b)
Hello_______
lower()
एक स्ट्रिंग को निचले मामले में परिवर्तित करता है
>>> a = "Python"
>>> print(a.lower())
Python
lstrip([ वर्ण ])
स्ट्रिंग का बायां ट्रिम संस्करण देता है
>>> a = " Hello "
>>> print(a.lstrip(), "!")
Hello
maketrans( x [, y [, z ]])
अनुवादों में उपयोग की जाने वाली अनुवाद तालिका लौटाता है
>>> frm = "SecretCode"
>>> to = "4203040540"
>>> trans_table =
str.maketrans(frm,to)
>>> sec_code = "Secret
Code".translate(trans_table)
>>> print(sec_code)
400304 0540
विभाजन( सितंबर )
एक टपल देता है जहां स्ट्रिंग को तीन भागों में विभाजित किया जाता है
>>> mystr = "Hello-Python"
>>> print(mystr.partition("-
"))
('Hello', '-', 'Python')
74
>>>
print(mystr.partition("."))
('Hello-Python', '', '')
प्रतिस्थापित करें( पुराना , नया [, गिनती ])
एक स्ट्रिंग देता है जहां निर्दिष्ट मान को निर्दिष्ट मान से बदल दिया जाता है
>>> mystr = "Hello Python.
Hello Java. Hello C++."
>>>
print(mystr.replace("Hello",
"Bye"))
Bye Python. Bye Java. Bye
C++.
>>>
print(mystr.replace("Hello",
"Hell", 2))
Hell Python. Hell Java.
Hello C++.
rfind( उप [, शुरू करें [, समाप्त ]])
निर्दिष्ट मान के लिए स्ट्रिंग की खोज करता है और जहां पाया गया था उसकी अंतिम स्थिति देता है
>>> mystr = "Hello-Python"
>>> print(mystr.rfind("P"))
6
>>> print(mystr.rfind("-"))
5
>>> print(mystr.rfind("z"))
-1
rindex( उप [, शुरू करें [, समाप्त ]])
निर्दिष्ट मान के लिए स्ट्रिंग की खोज करता है और जहां पाया गया था उसकी अंतिम स्थिति देता है
>>> mystr = "Hello-Python"
>>> print(mystr.rindex("P"))
6
>>> print(mystr.rindex("-"))
5
>>> print(mystr.rindex("z"))
Traceback (most recent call
last):
File "<pyshell#253>", line
1, in <module>
print(mystr.rindex("z"))
ValueError: substring not
found
rjust( चौड़ाई [, भरना ])
लंबाई चौड़ाई की एक स्ट्रिंग में उचित सही स्ट्रिंग लौटाता है .
>>> mystr = "Hello Python"
>>> mystr1 = mystr.rjust(20,
"-")
>>> print(mystr1)
--------Hello Python
rpartition( सितंबर )
एक टपल देता है जहां स्ट्रिंग को तीन भागों में विभाजित किया जाता है
>>> mystr = "Hello Python"
>>>
print(mystr.rpartition("."))
('', '', 'Hello Python')
>>> print(mystr.rpartition("
"))
('Hello', ' ', 'Python')
rsplit(sep=None, maxsplit=-1)
निर्दिष्ट विभाजक पर स्ट्रिंग को विभाजित करता है, और एक सूची देता है
>>> mystr = "Hello Python"
>>> print(mystr.rsplit())
['Hello', 'Python']
>>> mystr = "Hello-Python-
Hello"
>>>
print(mystr.rsplit(sep="-",
maxsplit=1))
['Hello-Python', 'Hello']
rstrip([ वर्ण ])
स्ट्रिंग का दायां ट्रिम संस्करण देता है
>>> mystr = "Hello Python"
>>> print(mystr.rstrip(),
"!")
Hello Python !
>>> mystr = "------------
Hello Python-----------"
>>> print(mystr.rstrip(), "-
")
------------Hello Python----
------- -
>>> print(mystr.rstrip(),
"_")
------------Hello Python----
------- _
split(sep=None, maxsplit=-1)
निर्दिष्ट विभाजक पर स्ट्रिंग को विभाजित करता है, और एक सूची देता है
>>> mystr = "Hello Python"
>>> print(mystr.split())
['Hello', 'Python']
>>> mystr1="Hello,,Python"
>>> print(mystr1.split(","))
['Hello', '', 'Python']
स्प्लिटलाइन्स([keepends])
पंक्ति विराम पर स्ट्रिंग को विभाजित करता है और एक सूची देता है
>>> mystr = "Hello:\n\n
Python\r\nJava\nC++\n"
>>>
print(mystr.splitlines())
['Hello:', '', ' Python',
'Java', 'C++']
>>>
print(mystr.splitlines(keepe
nds=True))
['Hello:\n', '\n', '
Python\r\n', 'Java\n',
'C++\n']
शुरू होता है ( उपसर्ग [, शुरू करें [, समाप्त ]])
यदि स्ट्रिंग निर्दिष्ट मान से शुरू होती है तो सत्य लौटाता है
>>> mystr = "Hello Python"
>>>
print(mystr.startswith("P"))
False
>>>
print(mystr.startswith("H"))
True
>>>
print(mystr.startswith("Hell
"))
True
strip([ वर्ण ])
स्ट्रिंग का एक छोटा संस्करण देता है
>>> mystr = "
Hello Python
"
>>> print(mystr.strip(),
"!")
Hello Python !
>>> print(mystr.strip(), "
")
Hello Python
स्वैपकेस ()
मामलों को स्वैप करें, निचला मामला ऊपरी मामला बन जाता है और इसके विपरीत
>>> mystr = "Hello PYthon"
>>> print(mystr.swapcase())
hELLO python
शीर्षक()
प्रत्येक शब्द के पहले वर्ण को ऊपरी मामले में परिवर्तित करता है
>>> mystr = "Hello PYthon"
>>> print(mystr.title())
Hello Python
>>> mystr = "HELLO JAVA"
>>> print(mystr.title())
Hello Java
अनुवाद करें( टेबल )
एक अनुवादित स्ट्रिंग देता है
>>> frm = "helloPython"
>>> to = "40250666333"
>>> trans_table =
str.maketrans(frm, to)
>>> secret_code = "Secret
Code".translate(trans_table)
>>> print(secret_code)
S0cr06 C3d0
upper()
एक स्ट्रिंग को ऊपरी मामले में परिवर्तित करता है
>>> mystr = "hello Python"
>>> print(mystr.upper())
HELLO PYTHON
zfill( चौड़ाई )
शुरुआत में 0 मानों की निर्दिष्ट संख्या के साथ स्ट्रिंग भरता है
>>> mystr = "999"
>>> print(mystr.zfill(9))
000000999
>>> mystr = "-40"
>>> print(mystr.zfill(5))
-0040

  1. पायथन में एस्केप कैरेक्टर प्रिंट करने के तरीके

    इस लेख में, हम यह देखने जा रहे हैं कि हम पायथन में एस्केप कैरेक्टर को कैसे प्रिंट कर सकते हैं। मुझे लगता है कि आप जानते हैं कि बचने वाले पात्र क्या हैं? आइए देखें कि उन लोगों के लिए कौन से एस्केप पात्र हैं जो नहीं जानते हैं? स्ट्रिंग्स में अलग-अलग अर्थों के लिए एस्केप वर्णों का उपयोग किया जाता है।

  1. अजगर में डंडर या जादू के तरीके

    जादू के तरीके जो हमें ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में कुछ सुंदर साफ-सुथरी तरकीबें करने की अनुमति देते हैं। इन विधियों को उपसर्ग और प्रत्यय के रूप में उपयोग किए जाने वाले दो अंडरस्कोर (__) द्वारा पहचाना जाता है। उदाहरण के लिए, इंटरसेप्टर के रूप में कार्य करते हैं जो कुछ शर्तों के पूरा होने पर स्वच

  1. पायथन में समेकित स्ट्रिंग कैसे मुद्रित करें?

    जब स्ट्रिंग्स के साथ प्रयोग किया जाता है, प्लस (+) को कॉन्सटेनेशन ऑपरेटर के रूप में परिभाषित किया जाता है। यह दूसरी स्ट्रिंग को पहली स्ट्रिंग में जोड़ता है। >>> s1 = TutorialsPoint >>> s2 = Hyderabad >>> print (s1+s2) TutorialsPoint Hyderabad