Python Language
स्ट्रिंग के तरीके

वाक्य - विन्यास

• str.capitalize () -> str
• str.casefold () -> str [केवल पायथन के लिए> 3.3]
• str.center (चौड़ाई [, भराव]) -> str
• str.count (उप [, प्रारंभ [, अंत]]) -> int
• str.decode (एन्कोडिंग = "utf-8" [, त्रुटियाँ]) -> यूनिकोड [केवल पायथन 2.x में]
• str.encode (एन्कोडिंग = "utf-8", त्रुटियां = "सख्त") -> बाइट्स
• str.endswith (प्रत्यय [, शुरू [, अंत]]) -> बूल
• str.expandtabs (टैबसाइज़ = 8) -> str
• str.find (उप [, प्रारंभ [, अंत]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (मानचित्रण) -> str
• str.index (उप [, प्रारंभ [, अंत]]) -> int
• str.isalnum () -> बूल
• str.isalpha () -> बूल
• str.isdecimal () -> बूल
• str.isdigit () -> बूल
• str.isidentifier () -> बूल
• str.islower () -> बूल
• str.isnumeric () -> बूल
• str.isprintable () -> बूल
• str.isspace () -> बूल
• str.istitle () -> बूल
• str.isupper () -> बूल
• str.join (iterable) -> str
• str.ljust (चौड़ाई [, भराव]) -> str
• str.lower () -> str
• str.lstrip ([वर्ण]) -> str
• स्थिर str.maketrans (x [, y [, z]])
• str.partition (sep) -> (सिर, sep, पूंछ)
• str.replace (पुराना, नया [, गिनती]) -> str
• str.rfind (उप [, प्रारंभ [, अंत]]) -> int
• str.rindex (उप [, प्रारंभ [, अंत]]) -> int
• str.rjust (चौड़ाई [, भराव]) -> str
• str.rpartition (sep) -> (सिर, sep, पूंछ)
• str.rsplit (sep = none, maxsplit = -1) -> स्ट्रिंग्स की सूची
• str.rstrip ([वर्ण]) -> str
• str.split (sep = none, maxsplit = -1) -> स्ट्रिंग्स की सूची
• str.splitlines ([रखता है]) -> तार की सूची
• str.startswith (उपसर्ग [, प्रारंभ [, अंत]]) -> पुस्तक
• str.strip ([वर्ण]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (तालिका) -> str
• str.upper () -> str
• str.zfill (चौड़ाई) -> str

टिप्पणियों

एक स्ट्रिंग का पूंजीकरण बदलना

पायथन का स्ट्रिंग प्रकार कई कार्य प्रदान करता है जो एक स्ट्रिंग के पूंजीकरण पर कार्य करता है। इसमें शामिल है :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

1 मैपिंग या प्रतिवर्ती: यूनिकोड तार (अजगर 3 में डिफ़ॉल्ट) के साथ, इन आपरेशनों नहीं 1 है। इनमें से अधिकांश ऑपरेशन सामान्यीकरण के बजाय प्रदर्शन उद्देश्यों के लिए किए गए हैं।

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper प्रत्येक वर्ण को एक स्ट्रिंग में लेता है और इसे उसके अपरकेस समकक्ष में परिवर्तित करता है, उदाहरण के लिए:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower विपरीत करता है; यह प्रत्येक वर्ण को एक स्ट्रिंग में ले जाता है और इसे उसके निचले हिस्से के समतुल्य में परिवर्तित करता है:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalize स्ट्रिंग का एक कैपिटलाइज्ड संस्करण लौटाता है, अर्थात यह बनाता है कि पहले वर्ण में ऊपरी केस हो और बाकी निचला:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.title स्ट्रिंग के str.title संस्करण का शीर्षक देता है, अर्थात, किसी शब्द की शुरुआत में प्रत्येक अक्षर को ऊपरी केस बनाया जाता है और अन्य सभी को निचला केस बनाया जाता है:

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase एक नया स्ट्रिंग ऑब्जेक्ट देता है जिसमें सभी लोअर केस कैरेक्टर्स को अपर केस में स्वैप किया जाता है और सभी अपर केस कैरेक्टर्स को लोअर में:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

str क्लास विधियों के रूप में उपयोग

यह ध्यान देने योग्य है कि इन तरीकों (जैसा कि ऊपर दिखाया गया है) स्ट्रिंग वस्तुओं पर या तो कहा जा सकता है लायक है या के एक वर्ग पद्धति के रूप में str वर्ग (करने के लिए एक स्पष्ट कॉल के साथ str.upper , आदि)

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

यह एक map फ़ंक्शन में एक बार में कई स्ट्रिंग्स में से किसी एक में इन विधियों को लागू करते समय सबसे उपयोगी है।

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

स्ट्रिंग की सूची में सीमांकक के आधार पर एक स्ट्रिंग को विभाजित करें

str.split(sep=None, maxsplit=-1)

str.split एक स्ट्रिंग लेता है और मूल स्ट्रिंग के सबस्ट्रिंग की सूची देता है। व्यवहार इस पर निर्भर करता है कि क्या sep तर्क प्रदान किया गया है या छोड़ा गया है।

यदि sep प्रदान नहीं किया गया है, या None , तो जहां कहीं भी व्हाट्सएप होता है वहां विभाजन होता है। हालांकि, व्हाट्सएप को लीड करने और उसका पालन करने पर ध्यान नहीं दिया जाता है, और कई लगातार व्हाट्सएप पात्रों को एक ही व्हाट्सएप चरित्र के रूप में माना जाता है:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

sep पैरामीटर का उपयोग सीमांकक स्ट्रिंग को परिभाषित करने के लिए किया जा सकता है। मूल स्ट्रिंग का विभाजन होता है जहां सीमांकक स्ट्रिंग होती है, और सीमांकक खुद को छोड़ दिया जाता है। एकाधिक लगातार परिसीमाकों को एक ही घटना के रूप में एक ही नहीं माना जाता है, बल्कि खाली तारों का निर्माण होता है।

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

डिफ़ॉल्ट को सीमांकक की प्रत्येक घटना पर विभाजित किया जाता है, हालांकि maxsplit पैरामीटर घटित होने वाले विभाजन की संख्या को सीमित करता है। -1 का डिफ़ॉल्ट मान का मतलब कोई सीमा नहीं है:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1)

str.rsplit ("राइट स्प्लिट") str.split ("लेफ्ट स्प्लिट") से भिन्न होता है जब maxsplit निर्दिष्ट होता है। विभाजन शुरू होने के बजाय स्ट्रिंग के अंत में शुरू होता है:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

नोट: अजगर को निर्दिष्ट विभाजन की अधिकतम संख्या, प्रदर्शन किया है, जबकि अधिकांश अन्य प्रोग्रामिंग भाषाओं बनाई सबस्ट्रिंग की अधिकतम संख्या निर्दिष्ट। कोड को पोर्ट या तुलना करते समय यह भ्रम पैदा कर सकता है।

एक प्रतिस्थापन की सभी घटनाओं को दूसरे प्रतिस्थापन के साथ बदलें

पायथन के str टाइप में एक दिए गए स्ट्रिंग में दूसरे सब-स्ट्रिंग के साथ एक सब-स्ट्रिंग की घटनाओं को बदलने के लिए एक विधि भी है। अधिक मांग वाले मामलों के लिए, कोई re.sub उपयोग कर सकता है।

str.replace(old, new[, count]) :

str.replace दो तर्कों को old और new लेता है जिसमें old उप-स्ट्रिंग होती है जिसे new उप-स्ट्रिंग द्वारा प्रतिस्थापित किया जाना है। वैकल्पिक तर्क count किए जाने वाले प्रतिस्थापन की संख्या निर्दिष्ट की गई है:

उदाहरण के लिए, निम्नलिखित स्ट्रिंग में 'foo' को 'spam' से बदलने के लिए, हम str.replace को old = 'foo' और new = 'spam' साथ कॉल कर सकते हैं:

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

यदि दिए गए स्ट्रिंग में कई उदाहरण हैं जो old तर्क से मेल खाते हैं, तो सभी घटनाएं new में दिए गए मूल्य से बदल दी जाती हैं:

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

जब तक, निश्चित रूप से, हम count लिए एक मूल्य प्रदान करते हैं। इस मामले में count घटित होने वाली है:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format और f-strings: एक स्ट्रिंग में मानों को प्रारूपित करें

अजगर के माध्यम से स्ट्रिंग प्रक्षेप और स्वरूपण सुविधा प्रदान करता है str.format समारोह, संस्करण 2.6 और च-तार संस्करण 3.6 में पेश में पेश किया।

निम्नलिखित चर को देखते हुए:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

निम्नलिखित कथन सभी समतुल्य हैं

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

संदर्भ के लिए, पायथन स्ट्रिंग प्रारूपण के लिए सी-स्टाइल क्वालिफायर का भी समर्थन करता है। नीचे दिए गए उदाहरण ऊपर के लोगों के बराबर हैं, लेकिन str.format संस्करणों को लचीलेपन में लाभ, संकेतन की स्थिरता और व्यापकता के कारण पसंद किया जाता है:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

str.format में प्रक्षेप के लिए ब्रेसिज़ का उपयोग स्ट्रिंग्स को स्वरूपित करते समय दोहराव को कम करने के लिए भी किया जा सकता है। उदाहरण के लिए, निम्नलिखित समतुल्य हैं:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

जबकि आधिकारिक अजगर प्रलेखन, हमेशा की तरह, पर्याप्त रूप से पर्याप्त है, pyformat.info में विस्तृत स्पष्टीकरण के साथ उदाहरणों का एक बड़ा सेट है।

इसके अतिरिक्त, { और } अक्षर डबल ब्रैकेट का उपयोग करके बच सकते हैं:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

अतिरिक्त जानकारी के लिए स्ट्रिंग स्वरूपण देखें। str.format() 3101 में str.format() प्रस्तावित था और PEP 498 में एफ-स्ट्रिंग्स।

एक स्ट्रिंग में एक सबरिंग की संख्या की गणना कई बार होती है

उप-स्ट्रिंग की घटनाओं की संख्या को एक और स्ट्रिंग, str.count में गिनने के लिए एक विधि उपलब्ध है।

str.count(sub[, start[, end]])

str.count एक अन्य स्ट्रिंग में उप-स्ट्रिंग sub की गैर-अतिव्यापी घटनाओं की संख्या को इंगित करने वाला एक int देता है। वैकल्पिक तर्क start और end उस शुरुआत और end इंगित करते हैं जिसमें खोज होगी। डिफ़ॉल्ट रूप से start = 0 और end = len(str) अर्थ है कि पूरी स्ट्रिंग खोजी जाएगी:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

start लिए एक अलग मान निर्दिष्ट करके, end हम अधिक स्थानीय खोज और गणना प्राप्त कर सकते हैं, उदाहरण के लिए, यदि start 13 के कॉल के बराबर है:

>>> s.count("sea", start)
1

के बराबर है:

>>> t = s[start:]
>>> t.count("sea")
1

एक स्ट्रिंग के शुरुआती और अंत पात्रों का परीक्षण करें

पायथन में दिए गए स्ट्रिंग की शुरुआत और अंत का परीक्षण करने के लिए, व्यक्ति str.startswith() और str.endswith() विधियों का उपयोग कर सकता है।

str.startswith(prefix[, start[, end]])

जैसा कि नाम से ही str.startswith है, str.startswith का उपयोग यह str.startswith लिए किया जाता है कि क्या एक दी गई स्ट्रिंग prefix में दिए गए वर्णों से शुरू होती है।

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

वैकल्पिक तर्क start और end में शुरू और अंत बिंदु निर्दिष्ट करते हैं जिनसे परीक्षण शुरू और खत्म होगा। निम्नलिखित उदाहरण में, 2 का प्रारंभ मान निर्दिष्ट करके हमारी स्ट्रिंग को स्थिति 2 और उसके बाद से खोजा जाएगा:

>>> s.startswith("is", 2)
True

यह पैदावार True क्योंकि s[2] == 'i' और s[3] == 's' ।

यह जाँचने के लिए कि क्या यह किसी तार के साथ शुरू होता है, आप एक tuple का उपयोग भी कर सकते हैं

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]])

str.endswith बिल्कुल के समान है str.startswith फर्क सिर्फ इतना किया जा रहा है कि यह वर्ण समाप्त होने और वर्ण से शुरू नहीं की खोज करता है। उदाहरण के लिए, यह जांचने के लिए कि क्या एक स्ट्रिंग पूर्ण विराम में समाप्त होती है, कोई लिख सकता है:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

startswith साथ एक से अधिक पात्रों का उपयोग अंतिम अनुक्रम के रूप में किया जा सकता है:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

यह जाँचने के लिए कि क्या यह तार के किसी सेट के साथ समाप्त होता है, आप एक tuple का उपयोग भी कर सकते हैं

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

क्या एक स्ट्रिंग से बना है परीक्षण

पायथन के str प्रकार में कई तरीके भी शामिल हैं जिनका उपयोग स्ट्रिंग की सामग्री का मूल्यांकन करने के लिए किया जा सकता है। ये str.isalpha , str.isdigit , str.isalnum , str.isspace । कैपिटलाइज़ेशन को str.isupper , str.islower और str.istitle साथ परीक्षण किया जा सकता है।

str.isalpha

str.isalpha कोई तर्क नहीं लेता है और True अगर किसी दिए गए स्ट्रिंग के सभी अक्षर अक्षर हैं, उदाहरण के लिए:

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

एक किनारे के मामले के रूप में, खाली स्ट्रिंग False मूल्यांकन करती है जब "".isalpha() साथ प्रयोग किया जाता है।

str.isupper , str.islower , str.istitle

ये विधियाँ किसी दिए गए स्ट्रिंग में पूंजीकरण का परीक्षण करती हैं।

str.isupper एक ऐसी विधि है जो अगर किसी दिए गए स्ट्रिंग के सभी वर्ण अपरकेस और False हैं तो True लौटाता है।

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

इसके विपरीत, str.islower एक ऐसी विधि है जो True लौटाती है यदि किसी दिए गए स्ट्रिंग के सभी वर्ण कम और False हैं।

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle True यदि दिए गए स्ट्रिंग को शीर्षक दिया गया है; यही है, हर शब्द एक अपरकेस चरित्र के साथ शुरू होता है, जिसके बाद लोअरकेस वर्ण होते हैं।

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal देता है कि क्या स्ट्रिंग दशमलव अंकों का अनुक्रम है, जो दशमलव संख्या का प्रतिनिधित्व करने के लिए उपयुक्त है।

str.isdigit में दशमलव संख्या का प्रतिनिधित्व करने के लिए उपयुक्त रूप में अंक शामिल नहीं हैं, जैसे कि सुपरस्क्रिप्ट अंक।

str.isnumeric में कोई भी संख्या मान शामिल हैं, भले ही अंक न हों, जैसे कि 0-9 की सीमा के बाहर के मान।

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestrings ( bytes अजगर 3 में, str अजगर 2 में), केवल समर्थन isdigit जो केवल बुनियादी ASCII अंक के लिए चेक,।

str.isalpha , खाली स्ट्रिंग False मूल्यांकन करती है।

str.isalnum

यह str.isalpha और str.isnumeric का संयोजन है, विशेष रूप से यह True मूल्यांकन करता है यदि दिए गए स्ट्रिंग के सभी वर्ण अल्फ़ान्यूमेरिक हैं , str.isnumeric वे वर्णमाला या संख्यात्मक वर्णों से मिलकर होते हैं:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

यदि स्ट्रिंग में केवल व्हॉट्सएप वर्ण हैं, तो True मूल्यांकन।

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

कभी-कभी एक स्ट्रिंग "खाली" दिखती है, लेकिन हम नहीं जानते कि क्या यह है क्योंकि इसमें सिर्फ व्हाट्सएप या कोई चरित्र नहीं है

>>> "".isspace()
False

इस मामले को कवर करने के लिए हमें एक अतिरिक्त परीक्षण की आवश्यकता है

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

लेकिन यह जांचने का सबसे छोटा तरीका है कि यदि कोई स्ट्रिंग खाली है या उसमें सिर्फ व्हाट्सएप अक्षर हैं, तो strip का उपयोग करना है (बिना किसी तर्क के यह सभी प्रमुख और अनुगामी व्हाट्सएप पात्रों को हटा देता है)

>>> not my_str.strip()
True

str.translate: स्ट्रिंग में वर्णों का अनुवाद करना

पायथन str प्रकार पर एक translate विधि का समर्थन करता है जो आपको अनुवाद तालिका (प्रतिस्थापन के लिए प्रयुक्त) और साथ ही किसी भी वर्ण को हटाने की अनुमति देता है जिसे प्रक्रिया में हटा दिया जाना चाहिए।

str.translate(table[, deletechars])

maketrans विधि ( str.maketrans अजगर 3 में और string.maketrans अजगर 2 में) आप एक अनुवाद तालिका उत्पन्न करने के लिए अनुमति देता है।

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

translate विधि एक स्ट्रिंग लौटाती है जो मूल स्ट्रिंग की अनुवादित प्रति है।

आप सेट कर सकते हैं table करने के लिए तर्क None अगर आप केवल वर्णों को हटाने की जरूरत है।

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

एक स्ट्रिंग से अवांछित प्रमुख / अनुगामी वर्णों को अलग करना

तीन तरीके प्रदान किए जाते हैं जो एक स्ट्रिंग से अग्रणी और अनुगामी पात्रों को स्ट्रिप करने की क्षमता प्रदान करते हैं: str.strip , str.rstrip और str.lstrip । सभी तीन विधियों में एक ही हस्ताक्षर है और सभी तीनों को हटाए गए अवांछित पात्रों के साथ एक नई स्ट्रिंग ऑब्जेक्ट लौटाते हैं।

str.strip([chars])

str.strip एक दिया स्ट्रिंग और हटा देगा (स्ट्रिप्स) उसके आगे या पीछे तर्क में निहित पात्रों पर कार्य करता है chars ; यदि chars की आपूर्ति नहीं की गई है या None , तो सभी सफेद स्थान वर्ण डिफ़ॉल्ट रूप से हटा दिए जाते हैं। उदाहरण के लिए:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

यदि chars को आपूर्ति की जाती है, तो इसमें निहित सभी वर्ण स्ट्रिंग से हटा दिए जाते हैं, जो वापस आ जाता है। उदाहरण के लिए:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) और str.lstrip([chars])

इन विधियों के समान शब्दार्थ और तर्क हैं। str.strip() , उनका अंतर उस दिशा में निहित है जहां से वे शुरू करते हैं। str.rstrip() स्ट्रिंग के अंत से शुरू होता है जबकि str.lstrip() स्ट्रिंग की शुरुआत से विभाजित होता है।

उदाहरण के लिए, str.rstrip का उपयोग कर:

>>> "     spacious string      ".rstrip()
'     spacious string'

जबकि, str.lstrip का उपयोग कर:

>>> "     spacious string      ".rstrip()
'spacious string      '

केस असंवेदनशील स्ट्रिंग तुलना

किसी मामले में असंवेदनशील तरीके से स्ट्रिंग की तुलना करना कुछ ऐसा लगता है जो तुच्छ है, लेकिन ऐसा नहीं है। यह खंड केवल यूनिकोड स्ट्रिंग्स (पायथन 3 में डिफ़ॉल्ट) पर विचार करता है। ध्यान दें कि पायथन 2 में पायथन 3 के सापेक्ष सूक्ष्म कमजोरियां हो सकती हैं - बाद के यूनिकोड से निपटने में बहुत अधिक है।

ध्यान देने वाली पहली बात यह है कि यूनिकोड में केस हटाने वाले रूपांतरण तुच्छ नहीं हैं। पाठ है जिसके लिए text.lower() != text.upper().lower() , जैसे "ß" : "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

लेकिन "Buße" लें कि आप "Buße" "BUSSE" और "Buße" तुलना करना चाहते हैं। हेक, आप शायद "BUSSE" और "BUẞE" समान की तुलना करना चाहते हैं - यह नया पूंजी रूप है। अनुशंसित तरीका casefold का उपयोग casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

केवल lower उपयोग न करें। यदि casefold उपलब्ध नहीं है, तो .upper().lower() मदद करता है (लेकिन केवल कुछ हद तक)।

फिर आपको लहजे पर विचार करना चाहिए। यदि आपका फॉन्ट रेंडरर अच्छा है, तो आप शायद "ê" == "ê" सोचते हैं - लेकिन यह नहीं है:

>>> "ê" == "ê"
False

ऐसा इसलिए है क्योंकि वे वास्तव में हैं

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

इससे निपटने का सबसे सरल तरीका unicodedata.normalize । unicodedata.normalize । आप शायद NFKD सामान्यीकरण का उपयोग करना चाहते हैं, लेकिन प्रलेखन की जांच करने के लिए स्वतंत्र महसूस करें। फिर एक करता है

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

समाप्त करने के लिए, यहाँ यह कार्य में व्यक्त किया गया है:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

एक तार में तार की एक सूची में शामिल हों

तार join() स्ट्रिंग join() सूची में शामिल होने के लिए एक स्ट्रिंग को एक विभाजक के रूप में शामिल किया जा सकता है। उदाहरण के लिए आप एक स्ट्रिंग बना सकते हैं जहाँ सूची में प्रत्येक तत्व को एक स्थान से अलग किया जाता है।

>>> " ".join(["once","upon","a","time"])
"once upon a time"

निम्नलिखित उदाहरण स्ट्रिंग तत्वों को तीन हाइफ़न के साथ अलग करता है।

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

स्ट्रिंग मॉड्यूल के उपयोगी स्थिरांक

पायथन का string मॉड्यूल स्ट्रिंग संबंधित कार्यों के लिए स्थिरांक प्रदान करता है। उनका उपयोग करने के लिए, string मॉड्यूल आयात करें:

>>> import string

string.ascii_letters :

ascii_lowercase और ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

सभी कम मामले ASCII वर्ण शामिल हैं:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

सभी ऊपरी मामले में ASCII वर्ण शामिल हैं:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

सभी दशमलव अंक वर्ण शामिल हैं:

>>> string.digits
'0123456789'

string.hexdigits :

सभी हेक्स अंक वर्ण शामिल हैं:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

सभी अष्टाधारी अंक वर्ण शामिल हैं:

>>> string.octaldigits
'01234567'

string.punctuation :

सभी वर्णों को समाहित किया गया C जिन्हें C स्थान में विराम चिह्न माना जाता C :

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

जिसमें सभी ASCII वर्ण व्हॉट्सएप माने गए हैं:

>>> string.whitespace
' \t\n\r\x0b\x0c'

स्क्रिप्ट मोड में, print(string.whitespace) वास्तविक वर्णों को प्रिंट करेगा, स्ट्रिंग को ऊपर वापस लाने के लिए str का उपयोग करेगा।

string.printable :

सभी वर्णों को शामिल करता है जिन्हें मुद्रण योग्य माना जाता है; string.digits , string.ascii_letters , string.punctuation , और string.whitespace ।

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

एक स्ट्रिंग उलट

अंतर्निहित स्ट्रिंग reversed() फ़ंक्शन का उपयोग करके एक स्ट्रिंग को उलटा किया जा सकता है, जो एक स्ट्रिंग लेता है और रिवर्स क्रम में एक पुनरावृत्त लौटाता है।

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() को ''.join() से एक तार में ''.join() से स्ट्रिंग बनाने के लिए किया जा सकता है।

>>> ''.join(reversed('hello'))
'olleh'

reversed() का उपयोग करते हुए, बिना पढ़े हुए पायथन उपयोगकर्ताओं के लिए अधिक पठनीय हो सकता है, -1 एक चरण के साथ विस्तारित स्लाइसिंग का उपयोग तेज और अधिक संक्षिप्त है। यहाँ, इसे फंक्शन के रूप में लागू करने का प्रयास करें:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

तार को औचित्य दें

पायथन स्ट्रिंग्स को सही ठहराने के लिए कार्य प्रदान करता है, जिससे टेक्स्ट पैडिंग को विभिन्न स्ट्रिंग्स को संरेखित करने में बहुत आसान हो जाता है।

नीचे str.ljust और str.rjust का एक उदाहरण है:

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust और rjust बहुत समान हैं। दोनों में एक width पैरामीटर और एक वैकल्पिक fillchar पैरामीटर है। इन फ़ंक्शन द्वारा बनाई गई कोई भी स्ट्रिंग कम से कम तब तक होती है जब तक कि width पैरामीटर फ़ंक्शन में पारित नहीं हो जाती। यदि स्ट्रिंग width से अधिक लंबी है, तो इसे छोटा नहीं किया जाता है। fillchar तर्क, जो अंतरिक्ष के चरित्र को fillchar करता है ' ' एक एकल वर्ण होना चाहिए, न कि मल्टीचैकर स्ट्रिंग।

ljust फ़ंक्शन स्ट्रिंग के अंत को पैड करता है इसे fillchar साथ कहा जाता है जब तक कि यह width वर्ण लंबा न हो। rjust फ़ंक्शन एक समान फैशन में स्ट्रिंग की शुरुआत को पैड करता है। इसलिए, इन फ़ंक्शंस के नामों में l और r उस पक्ष को संदर्भित करते हैं जो मूल स्ट्रिंग, fillchar नहीं , आउटपुट स्ट्रिंग में स्थित है।

Str या बाइट्स डेटा और यूनिकोड वर्णों के बीच रूपांतरण

फ़ाइलों और नेटवर्क संदेशों की सामग्री एन्कोडेड वर्णों का प्रतिनिधित्व कर सकती है। उन्हें अक्सर उचित प्रदर्शन के लिए यूनिकोड में परिवर्तित करने की आवश्यकता होती है।

पायथन 2 में, आपको स्ट्रि डेटा को यूनिकोड वर्णों में बदलने की आवश्यकता हो सकती है। डिफ़ॉल्ट ( '' , "" , आदि) एक ASCII स्ट्रिंग है, जिसमें ASCII रेंज के बाहर किसी भी मान को एस्केप वैल्यू के रूप में प्रदर्शित किया गया है। यूनिकोड के तार u'' (या u"" , आदि) हैं।

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

पायथन 3 में आपको यूनिकोड वर्णों के तारों को बाइट्स ('बाइट शाब्दिक' के रूप में संदर्भित) में परिवर्तित करने की आवश्यकता हो सकती है। डिफ़ॉल्ट अब एक यूनिकोड स्ट्रिंग है, और bytestring शाब्दिक अब के रूप में दर्ज किया जाना चाहिए b'' , b"" , आदि एक बाइट शाब्दिक वापस आ जाएगी True करने के लिए isinstance(some_val, byte) , यह मानते हुए some_val एक स्ट्रिंग है इनकोडिंग जा सकता है होना करने के लिए बाइट्स के रूप में।

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

स्ट्रिंग युक्त होते हैं

पायथन यह जांचने के लिए बेहद सहज बनाता है कि क्या किसी स्ट्रिंग में दिए गए सबस्ट्रिंग हैं। बस ऑपरेटर in उपयोग करें:

>>> "foo" in "foo.baz.bar"
True

ध्यान दें: एक खाली स्ट्रिंग का परीक्षण हमेशा True :

>>> "" in "test"
True