पाइथन

Question

में एक स्ट्रिंग में रेगेक्स मैचों की कितनी बार पता लगाएं कि क्या कोई तरीका है कि मैं पाइथन में स्ट्रिंग में कितने मैचों का पता लगा सकता हूं? उदाहरण के लिए, अगर मैं स्ट्रिंग "It actually happened when it acted out of turn."

है मुझे पता है कि कितनी बार "t a" स्ट्रिंग में प्रकट होता है चाहता हूँ। उस स्ट्रिंग में, "t a" दो बार प्रकट होता है। मैं चाहता हूं कि मेरा कार्य मुझे बताए कि यह दो बार दिखाई देता है। क्या यह संभव है?

Answer 1

मौजूदा समाधान के गैर-अतिव्यापी घटनाओं पर findall आधारित की संख्या लौट गैर-अतिव्यापी मैचों के लिए ठीक हैं (और शायद मैचों की भारी संख्या के अलावा कोई संदेह नहीं है इष्टतम), हालांकि sum(1 for m in re.finditer(thepattern, thestring)) जैसे विकल्प (सूची की भौतिकता को हमेशा से बचाने के लिए जब आप जिनकी परवाह है, वे भी गिनती हैं) भी काफी संभव हैं। कुछ हद तक विशेष स्वभाव का subn का उपयोग कर किया जाएगा और जिसके परिणामस्वरूप स्ट्रिंग अनदेखी ...:

def countnonoverlappingrematches(pattern, thestring): 
    return re.subn(pattern, '', thestring)[1] 

बाद इस विचार का केवल वास्तविक लाभ अगर आप केवल (मान) की गणना करने के लिए 100 मैचों अप करने के लिए परवाह आएगा; फिर, re.subn(pattern, '', thestring, 100)[1] व्यावहारिक हो सकता है (100 लौट रहा है चाहे 100 मैचों, या 1000, या यहां तक ​​कि बड़ी संख्याएं हों)।

गिनती मैचों की ओवरलैपिंग आपको अधिक कोड लिखने की आवश्यकता है, क्योंकि प्रश्न में अंतर्निहित कार्य सभी गैर-ओवरलैपिंग मैचों पर केंद्रित हैं। परिभाषा की एक समस्या भी है, उदाहरण के साथ, पैटर्न 'a+' और स्ट्रिंग 'aa' होने के साथ, क्या आप इसे केवल एक मैच, या तीन (पहले a, दूसरा, दोनों), या ... के रूप में मानेंगे?

उदाहरण है कि आप संभवतः को लेकर टकराव पैदा करना चाहते हैं स्ट्रिंग में अलग धब्बे (जो तब पिछले पैराग्राफ में उदाहरण के लिए दो मैचों देना होगा) पर शुरू मैचों के लिए मान लिया जाये:

def countoverlappingdistinct(pattern, thestring): 
    total = 0 
    start = 0 
    there = re.compile(pattern) 
    while True: 
    mo = there.search(thestring, start) 
    if mo is None: return total 
    total += 1 
    start = 1 + mo.start() 

नोट आप करते हैं कि इस मामले में पैटर्न को आरई ऑब्जेक्ट में संकलित करना होगा: फ़ंक्शन re.search तर्क (खोज के लिए प्रारंभ करने की स्थिति) को विधिsearch करता है, इसलिए आपको स्ट्रिंग को स्लाइसिंग करना होगा - अगली खोज होने की तुलना में निश्चित रूप से अधिक प्रयास अगले संभावित विशिष्ट प्रारंभ बिंदु पर टार्ट, जो मैं इस समारोह में कर रहा हूं।

Answer 2

क्या आपने यह कोशिश की है?

len(pattern.findall(source)) 

Answer 3

import re 
len(re.findall(pattern, string_to_search)) 

Answer 4

import re 
print len(re.findall(r'ab',u'ababababa')) 

Answer 5

मैं जानता हूँ कि इस regex के बारे में एक सवाल है। मैंने सोचा कि अगर भविष्य में कोई गैर-रेगेक्स समाधान चाहता है तो मैं भविष्य में संदर्भ के लिए count विधि का उल्लेख करूंगा।

>>> s = "It actually happened when it acted out of turn." 
>>> s.count('t a') 
2 

कौन-स्ट्रिंग

Answer 6

आप एक noncapturing subpattern का उपयोग करके मैचों ओवरलैपिंग पा सकते हैं:

def count_overlapping(pattern, string): 
    return len(re.findall("(?=%s)" % pattern, string)) 

Answer 7

मैचों की एक सूची बनाने के एक भी स्थानापन्न के रूप में एक प्रतिदेय साथ re.sub उपयोग कर सकते हैं से बचने के लिए। यह प्रत्येक काउंटर पर कॉल किया जाएगा, आंतरिक काउंटर में वृद्धि होगी।

class Counter(object): 
    def __init__(self): 
     self.matched = 0 
    def __call__(self, matchobj): 
     self.matched += 1 

counter = Counter() 
re.sub(some_pattern, counter, text) 

print counter.matched