पायथन में मुझे स्ट्रिंग का एक विकल्प कैसे मिलता है?

Question

क्या पायथन में एक स्ट्रिंग को प्रतिस्थापित करने का एक तरीका है, तीसरे चरित्र से स्ट्रिंग के अंत तक एक नया स्ट्रिंग प्राप्त करने के लिए?

शायद पसंद है myString[2:end]?

यदि दूसरे भाग को छोड़ने का अर्थ है 'अंत तक', और यदि आप पहले भाग को छोड़ते हैं, तो क्या यह शुरू से शुरू होता है?

Comments

यह एक स्पष्ट व्याख्या pythoncentral.io/cutting-and-slicing-strings-in-python

— mario ruiz

Answer 1

>>> x = "Hello World!"
>>> x[2:]
'llo World!'
>>> x[:2]
'He'
>>> x[:-2]
'Hello Worl'
>>> x[-2:]
'd!'
>>> x[2:-2]
'llo Worl'

पायथन इस अवधारणा को "स्लाइसिंग" कहता है और यह केवल तार से अधिक पर काम करता है। व्यापक परिचय के लिए यहां एक नज़र डालें ।

Answer 2

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

some_string[::-1]

या वैकल्पिक वर्णों का चयन करना होगा:

"H-e-l-l-o- -W-o-r-l-d"[::2] # outputs "Hello World"

स्ट्रिंग के माध्यम से आगे और पीछे की ओर कदम रखने की क्षमता शुरू या अंत से सरणी टुकड़ा करने में सक्षम होने के साथ स्थिरता बनाए रखती है।

Comments

@mtahmed बिल्कुल सवाल से संबंधित है। क्या होगा यदि आप स्ट्रिंग से वैकल्पिक वर्णों का चयन करके प्रतिस्थापित करना चाहते हैं? यह my_string [:: 2] होगा

— Endophage

मुझे लगता है कि यह अधिक संभावना है कि आप स्लाइस के तीसरे पैरामीटर का उल्लेख करना चाहते हैं। एक स्ट्रिंग से हर दूसरे चरित्र को प्राप्त करने की आवश्यकता कहीं न कहीं एक महत्वपूर्ण उपयोग मामला हो सकता है, लेकिन मुझे ऐसा कभी नहीं करना पड़ा। ऐसा नहीं है कि आप जो कुछ भी जानते हैं उसे दिखाना चाहते हैं - अगर आप ऐसा नहीं कर सकते हैं तो चीजों को जानने की क्या बात है। :) लेकिन सवाल की प्रासंगिकता के लिए मामला अतिरंजित है।

— जॉन लॉकवुड

निश्चित रूप से, वैकल्पिक वर्णों का चयन करने का विशिष्ट उदाहरण प्रश्न के लिए प्रासंगिक नहीं हो सकता है, लेकिन यह समझना कि स्लाइसिंग के लिए एक 3 पैरामीटर बहुत प्रासंगिक है और सरल उदाहरण यह वर्णन करने के लिए कार्य करते हैं कि यह कैसे काम करता है। पायथन समुदाय में भी नए सदस्यों को एक मैत्रीपूर्ण तरीके से शिक्षित करने का एक बड़ा इतिहास है :-)

— एंडोफेगे

Answer 3

Substr () सामान्य रूप से (यानी PHP और पर्ल) इस तरह से काम करता है:

s = Substr(s, beginning, LENGTH)

तो पैरामीटर हैं beginningऔर LENGTH।

लेकिन पायथन का व्यवहार अलग है; यह शुरुआत और एक के बाद END (!) की अपेक्षा करता है। शुरुआती लोगों द्वारा इसे देखना मुश्किल है। तो Substr (s, शुरुआत, LENGTH) के लिए सही प्रतिस्थापन है

s = s[ beginning : beginning + LENGTH]

Comments

शुरुआती लोगों को अजगर के बारे में सीखना चाहिए, जब वह अजगर के पास जाता है, तो अन्य भाषा की आदतों से नहीं चिपकता

— निकु सूरुड

और सिर्फ पूर्णता के लिए, जावा पायथन की तरह है जिसमें String.substring () विधि शुरू होती है और एक-पास्ट-एंड होती है। यह मेरे लिए मुश्किल है, मैंने यह मान लिया था कि यह दुनिया के हर दूसरे विकल्प की तरह लंबा था।

— फिलिहब्स

ए (शायद) अधिक s[beginning:][:length]

— पाइथोनिक

जैसे कि कोई व्यक्ति [गंदा शब्द] के बजाय पाइथन के साथ शुरू हुआ था, जैसे PHP, मुझे लगता है कि पाइथन अपनी स्ट्रिंग [शुरुआत: अंत] के साथ अधिक सरल और सहज है। लंबाई आमतौर पर प्रासंगिक नहीं है।

— ग्लोवे

Answer 4

इसे प्राप्त करने का एक सामान्य तरीका स्ट्रिंग स्लाइसिंग है।

MyString[a:b] आपको इंडेक्स से a (b - 1) का विकल्प देता है।

Answer 5

एक उदाहरण यहां याद आ रहा है: पूर्ण (उथली) प्रति।

>>> x = "Hello World!"
>>> x
'Hello World!'
>>> x[:]
'Hello World!'
>>> x==x[:]
True
>>>

यह अनुक्रम प्रकारों की प्रतिलिपि बनाने के लिए एक सामान्य मुहावरा है (नजरबंद स्ट्रिंग्स का नहीं) [:],। उथला एक सूची की प्रतिलिपि बनाता है, बिना किसी स्पष्ट कारण के लिए उपयोग किए जाने वाले पायथन सूची स्लाइस सिंटैक्स देखें ।

Comments

यह प्रतिस्थापन के बारे में सवाल से कोई लेना देना नहीं है। स्ट्रिंग के लिए भी लागू नहीं होता है। कह रही है stringA = STRING बिलियन पर्याप्त है ...

— निकु Surdu

[:] पूर्ण प्रति एक नया कॉपी बनाता है, स्लाइस सिंटैक्स का उपयोग करता है और इसे "शुरू से अंत तक

— प्रतिस्थापन

क्या बात है क्योंकि तार अपरिवर्तनीय हैं? a=bपर्याप्त होना चाहिए।

— bfontaine

@ जीमेल: वास्तव में, [:]एक अपरिवर्तनीय प्रकार पर एक प्रतिलिपि बिल्कुल नहीं बनाई जाती है। जबकि mysequence[:]ज्यादातर हानिरहित है जब mysequenceकी तरह एक अपरिवर्तनीय प्रकार है str, tuple, bytes(Py3) या unicode(Py2), a = b[:]बराबर करने के लिए है a = b, यह सिर्फ भेजने टुकड़ा करने की क्रिया बाइट कोड के लिए थोड़ा समय बरबाद करती है जो उथले प्रति में करने के लिए यह व्यर्थ के बाद से ही वापस लौट कर करने के लिए वस्तु प्रतिक्रिया , वस्तु पहचान परीक्षणों से अलग, यह किसी के अपरिवर्तनीय स्व के लिए एक और संदर्भ वापस करने के बराबर है।

— शैडो रेंजर

इस उत्तर की अन्य आलोचनाओं को संक्षेप में प्रस्तुत करने का प्रयास: पायथन में, तार अपरिवर्तनीय हैं, इसलिए स्ट्रिंग की प्रतिलिपि बनाने का कोई कारण नहीं है - इसलिए s[:]कोई प्रतिलिपि नहीं बनाता है s = 'abc'; s0 = s[:]; assert s is s0:। हाँ यह पायथन में सूची की नकल करने के लिए मुहावरेदार तरीका था, जब तक कि सूची नहीं मिल जाती list.copy, लेकिन एक अपरिवर्तनीय प्रकार के एक पूर्ण स्लाइस के पास प्रतिलिपि बनाने का कोई कारण नहीं है क्योंकि इसे बदला नहीं जा सकता है, इसलिए हो सकता है कि स्मृति में केवल एक ही हो हमें इसे कॉपी करने में समय बर्बाद नहीं करना चाहिए। चूंकि यह उत्तर गलत है और इस प्रश्न का उत्तर भी नहीं देता है - क्या इसे हटा दिया जाना चाहिए?

— हारून हॉल

Answer 6

क्या पायथन में एक स्ट्रिंग को प्रतिस्थापित करने का एक तरीका है, 3 जी चरित्र से स्ट्रिंग के अंत तक एक नया स्ट्रिंग प्राप्त करने के लिए?

शायद पसंद है myString[2:end]?

हां, यह वास्तव में तब काम करता है जब आप निरंतर सिंगलटन को, असाइन या बाइंड करते हैं , नाम :endNone

>>> end = None
>>> myString = '1234567890'
>>> myString[2:end]
'34567890'

स्लाइस नोटेशन में 3 महत्वपूर्ण तर्क हैं:

• शुरू
• रुकें
• कदम

नहीं दिए जाने पर उनकी चूक None- लेकिन हम उन्हें स्पष्ट रूप से पारित कर सकते हैं:

>>> stop = step = None
>>> start = 2
>>> myString[start:stop:step]
'34567890'

यदि दूसरे भाग को छोड़ने का अर्थ है 'अंत तक', यदि आप पहले भाग को छोड़ देते हैं, तो क्या यह शुरू से शुरू होता है?

उदाहरण के लिए:

>>> start = None
>>> stop = 2
>>> myString[start:stop:step]
'12'

ध्यान दें कि हम स्लाइस में शामिल हैं, लेकिन हम केवल ऊपर जाते हैं, और शामिल नहीं हैं, बंद करो।

जब कदम है None, डिफ़ॉल्ट रूप से टुकड़ा 1कदम के लिए उपयोग करता है । यदि आप एक नकारात्मक पूर्णांक के साथ कदम रखते हैं, तो पायथन अंत से शुरुआत तक जाने के लिए पर्याप्त स्मार्ट है।

>>> myString[::-1]
'0987654321'

मैं स्लाइस नोटेशन प्रश्न को स्पष्ट करने के लिए अपने उत्तर में स्लाइस नोटेशन को बहुत विस्तार से समझाता हूं।

Answer 7

"अंत" को छोड़कर आपको वहीं मिल गया है। इसे स्लाइस नोटेशन कहा जाता है। आपका उदाहरण पढ़ना चाहिए:

new_sub_string = myString[2:]

यदि आप दूसरे पैरामीटर को छोड़ देते हैं, तो इसका तात्पर्य स्ट्रिंग का अंत है।

Answer 8

मैं चर्चा में दो बिंदु जोड़ना चाहूंगा:

1. आप None"प्रारंभ से" या "अंत तक" निर्दिष्ट करने के लिए एक खाली जगह पर उपयोग कर सकते हैं :

   'abcde'[2:None] == 'abcde'[2:] == 'cde'

   यह फ़ंक्शंस में विशेष रूप से सहायक है, जहां आप एक तर्क के रूप में एक खाली स्थान प्रदान नहीं कर सकते हैं:

   def substring(s, start, end):
       """Remove `start` characters from the beginning and `end` 
       characters from the end of string `s`.
   
       Examples
       --------
       >>> substring('abcde', 0, 3)
       'abc'
       >>> substring('abcde', 1, None)
       'bcde'
       """
       return s[start:end]

2. पायथन में स्लाइस ऑब्जेक्ट्स हैं:

   idx = slice(2, None)
   'abcde'[idx] == 'abcde'[2:] == 'cde'

Answer 9

यदि myString में एक खाता संख्या है जो ऑफसेट 6 से शुरू होती है और इसकी लंबाई 9 है, तो आप इस तरह से खाता संख्या निकाल सकते हैं acct = myString[6:][:9]:।

यदि ओपी स्वीकार करता है कि, वे एक प्रयोगात्मक शैली में कोशिश करना चाहते हैं,

myString[2:][:999999]

यह काम करता है - कोई त्रुटि नहीं उठाई जाती है, और कोई डिफ़ॉल्ट 'स्ट्रिंग पैडिंग' नहीं होती है।

Comments

मुझे लगता है कि आप इस विधि का उपयोग करना चाहते हैं myString[offset:][:length]ओपी तुम सिर्फ उपयोग कर सकते हैं के मामले मेंmyString[offset:][:]

— victortv

@VictorVal उत्तर उन (मेरे जैसे) के लिए है जिन्होंने पायथन को एक 2 (3, 4, ...) प्रोग्रामिंग भाषा के रूप में सीखा है और भाषा से संपर्क करने के लिए कुछ परिचित 'सिंटैक्स हुक' चाहते हैं। भाषा में कोई भी विशेषज्ञ मेरे जवाब को थोड़ा मूर्खतापूर्ण रूप से देखेगा।

— कॉपीपेस्ट इट

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

— सेबी

Answer 10

शायद मैं इसे याद कर रहा हूं, लेकिन मुझे इस पृष्ठ पर मूल प्रश्न का पूरा उत्तर नहीं मिला क्योंकि चर यहां और अधिक चर्चा में नहीं हैं। इसलिए मुझे खोजते हुए जाना पड़ा।

चूंकि मुझे अभी तक टिप्पणी करने की अनुमति नहीं है, इसलिए मैं अपना निष्कर्ष यहां जोड़ दूं। मुझे यकीन है कि इस पृष्ठ तक पहुँचने के दौरान मुझे इसमें कोई दिलचस्पी नहीं थी:

 >>>myString = 'Hello World'
 >>>end = 5

 >>>myString[2:end]
 'llo'

यदि आप पहले भाग को छोड़ देते हैं, तो आप प्राप्त करते हैं

 >>>myString[:end]
 'Hello' 

और अगर आपने छोड़ दिया: बीच में भी आपको सबसे सरल विकल्प मिल गया, जो 5 वां वर्ण होगा (गणना 0 से शुरू हो रही है, इसलिए यह इस मामले में रिक्त है):

 >>>myString[end]
 ' '

Answer 11

ठीक है, मुझे एक ऐसी स्थिति मिली जहां मुझे पीएचपी स्क्रिप्ट को पायथन में अनुवाद करने की आवश्यकता थी, और इसके कई उपयोग थे substr(string, beginning, LENGTH)।
अगर मैंने पायथन का चयन किया, तो मुझे बहुत सारे इंडेक्स की string[beginning:end]गणना करनी होगी , इसलिए आसान तरीका उपयोग करना था , इससे मुझे बहुत परेशानी हुई।string[beginning:][:length]

Answer 12

हार्डकोडेड इंडेक्स का उपयोग करना अपने आप में एक गड़बड़ हो सकता है।

इससे बचने के लिए, पायथन एक अंतर्निहित वस्तु प्रदान करता है slice()।

string = "my company has 1000$ on profit, but I lost 500$ gambling."

अगर हम जानना चाहते हैं कि मेरे पास कितने पैसे बचे हैं।

सामान्य समाधान:

final = int(string[15:19]) - int(string[43:46])
print(final)
>>>500

स्लाइस का उपयोग करना:

EARNINGS = slice(15, 19)
LOSSES = slice(43, 46)
final = int(string[EARNINGS]) - int(string[LOSSES])
print(final)
>>>500

स्लाइस का उपयोग करके आप पठनीयता प्राप्त करते हैं।

Comments

हो सकता है कि यह सबसे अच्छा उदाहरण न हो, क्योंकि हार्डकोड इंडेक्स बना रहता है और पठनीयता मध्यवर्ती चर से आती है, जिसे आप पहले उदाहरण में इस्तेमाल कर सकते थे।

— अज़लज़ार