स्ट्रिंग में प्रतिस्थापित करने की अंतिम घटना का पता लगाना, इसकी जगह

104

इसलिए मेरे पास एक ही प्रारूप में तार की एक लंबी सूची है, और मैं अंतिम ढूंढना चाहता हूं "।" हर एक में चरित्र, और इसे "-।" के साथ बदलें। मैंने रिफ़्ड का उपयोग करने की कोशिश की है, लेकिन मैं ऐसा करने के लिए इसे ठीक से उपयोग नहीं कर सकता।

python string parsing

— एडम मगयर
स्रोत

Rreplace

— ग्राहम

163

यह करना चाहिए

old_string = "this is going to have a full stop. some written sstuff!"
k = old_string.rfind(".")
new_string = old_string[:k] + ". - " + old_string[k+1:]

— आदित्य सिहाग
स्रोत

1

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

— एडम मग्यार

@AdamMagyar हाँ, कंटेनर [a: b] कंटेनर के b-1 इंडेक्स से स्लाइस। यदि 'a' को छोड़ दिया जाता है, तो यह 0 से चूक जाता है; अगर 'b' को छोड़ दिया जाए तो यह चूक (कंटेनर) के लिए है। प्लस ऑपरेटर सिर्फ संघटन करता है। जैसा कि आपने बताया कि रिफ़ंड फ़ंक्शन इंडेक्स देता है जिसके चारों ओर प्रतिस्थापन ऑपरेशन होना चाहिए।

— आदित्य सिहाग

26

दाईं ओर से प्रतिस्थापित करने के लिए:

def replace_right(source, target, replacement, replacements=None):
    return replacement.join(source.rsplit(target, replacements))

उपयोग में:

>>> replace_right("asd.asd.asd.", ".", ". -", 1)
'asd.asd.asd. -'

— वरिंदर सिंह
स्रोत

1

मैं निश्चित रूप से इस समाधान को पसंद करता हूं, लेकिन replacements=Noneपैरामीटर मेरे लिए एक त्रुटि की तरह लगता है क्योंकि अगर पैरामीटर को छोड़ दिया जाता है तो फ़ंक्शन एक त्रुटि देगा (पायथन 2.7 में कोशिश की गई)। मेरा सुझाव है कि या तो डिफ़ॉल्ट मान को हटा दें, इसे -1 (असीमित प्रतिस्थापन के लिए) पर सेट करें या इसे बेहतर बनाएं replacements=1(जो मुझे लगता है कि इस विशेष फ़ंक्शन के लिए डिफ़ॉल्ट व्यवहार होना चाहिए जो ओपी चाहता है)। डॉक्स के अनुसार यह पैरामीटर वैकल्पिक है, लेकिन इसे दिए जाने पर एक इंट होना चाहिए।

— टिप्पणीव

मामले में किसी को भी इस के लिए एक एक लाइनर चाहता है: ". -".join("asd.asd.asd.".rsplit(".", 1))। आप जो कर रहे हैं वह 1 घटना के लिए दाईं ओर से एक स्ट्रिंग विभाजन कर रहा है और प्रतिस्थापन का उपयोग करके फिर से स्ट्रिंग में शामिल हो रहा है।

— bsplosion

14

मैं एक regex का उपयोग करेगा:

import re
new_list = [re.sub(r"\.(?=[^.]*$)", r". - ", s) for s in old_list]

— टिम पीटरज़कर
स्रोत

2

यह एकमात्र उत्तर है जो काम करता है यदि कोई बिंदु नहीं है। : मैं एक अग्रदर्शी हालांकि प्रयोग करेंगे\.(?=[^.]*$)

— Georg

6

एक लाइनर होगा:

str=str[::-1].replace(".",".-",1)[::-1]

— mazs
स्रोत

1

ये गलत है । आप स्ट्रिंग को उल्टा कर रहे हैं, इसे बदल रहे हैं और फिर इसे वापस उलटा कर रहे हैं। आप .replaceएक उल्टे तार पर कर रहे हैं । पास किए गए दोनों तार replaceभी उलट दिए गए। अन्यथा जब आप स्ट्रिंग को दूसरी बार उलटते हैं तो आपके द्वारा डाले गए अक्षर पीछे की तरफ होंगे। आप इसका उपयोग केवल तभी कर सकते हैं जब आप एक अक्षर को एक अक्षर से बदल रहे हों, और फिर भी मैं इसे आपके कोड में नहीं डालूंगा, किसी को इसे भविष्य में बदलना होगा और यह सोचना शुरू कर देगा कि एक शब्द sdrawkcab क्यों लिखा गया है।

— बोरिस

1

आप नीचे दिए गए फ़ंक्शन का उपयोग कर सकते हैं जो सही से शब्द की पहली घटना को प्रतिस्थापित करता है।

def replace_from_right(text: str, original_text: str, new_text: str) -> str:
    """ Replace first occurrence of original_text by new_text. """
    return text[::-1].replace(original_text[::-1], new_text[::-1], 1)[::-1]

— bambuste
स्रोत

0

a = "A long string with a . in the middle ending with ."

# यदि आप किसी भी स्ट्रिंग की अंतिम घटना का सूचकांक ढूंढना चाहते हैं, तो हमारे मामले में हम # पिछले घटना का सूचकांक ढूंढते हैं

index = a.rfind("with")

# परिणाम 44 होगा, क्योंकि सूचकांक 0 से शुरू होता है।

— अर्पण सैनी
स्रोत

-1

कोई दृष्टिकोण नहीं:

a = "A long string with a . in the middle ending with ."
fchar = '.'
rchar = '. -'
a[::-1].replace(fchar, rchar[::-1], 1)[::-1]

Out[2]: 'A long string with a . in the middle ending with . -'

एक के साथ आदित्य सिहाग का जवाब rfind:

pos = a.rfind('.')
a[:pos] + '. -' + a[pos+1:]

— एलेक्स एल
स्रोत

यह प्रतिस्थापन स्ट्रिंग को भी उलट देता है। इसके अलावा, यह रूट के जवाब का दोहराव है, और, जैसा कि मैं वहां कहता हूं, बहुत अक्षम है।

— गारेथ लैटी

@ लेटवेयर का मतलब है कि यह उलट है a?

— एलेक्स एल

मेरा मतलब है कि यह '. -'आउटपुट में उलट है।

— गारेथ लैटी

बस उपयोगकर्ता द्वारा हाथ से स्ट्रिंग शाब्दिक को उलटने की उम्मीद करना एक महान विचार नहीं है - यह गलतियों और अस्पष्ट होने का खतरा है।

— गारेथ लैटी

@ लिट्टीवेयर सहमत हुए। मैंने इसे एक var बना दिया है। (मुझे एहसास हुआ कि यह एक अक्षम्य विधि है, और सभी मामलों में उपयुक्त नहीं है - आपका replace_rightबहुत अच्छा है)

— एलेक्स एल