นับจำนวนครั้งของสตริงย่อยที่กำหนดในสตริง

ฉันจะนับจำนวนครั้งที่มีซับสตริงที่ระบุอยู่ภายในสตริงใน Python ได้อย่างไร

ตัวอย่างเช่น:

>>> 'foo bar foo'.numberOfOccurrences('foo')
2

string.count(substring), ชอบใน:

>>> "abcdabcva".count("ab")
2

ปรับปรุง:

ตามที่ระบุไว้ในความคิดเห็นนี้เป็นวิธีการทำสำหรับเหตุการณ์ที่ไม่ทับซ้อนกัน หากคุณต้องการนับเหตุการณ์ที่ทับซ้อนกันคุณควรตรวจสอบคำตอบที่: " Python regex ค้นหาการจับคู่ที่ซ้อนกันทั้งหมดหรือไม่ " หรือเพียงตรวจสอบคำตอบอื่น ๆ ของฉันด้านล่าง

s = 'arunununghhjj'
sb = 'nun'
results = 0
sub_len = len(sb)
for i in range(len(s)):
    if s[i:i+sub_len] == sb:
        results += 1
print results

ฉันขอเสนอวิธีแก้ปัญหาดังต่อไปนี้:

1. คุณหมายถึงรายการของช่องว่างย่อยสตริงย่อยและต้องการที่จะรู้ว่าสิ่งที่เป็นจำนวนตำแหน่งสตริงย่อยในทุกสตริงย่อย:

   s = 'sub1 sub2 sub3'
   s.split().index('sub2')
   >>> 1

2. คุณหมายถึงตำแหน่งถ่านของสตริงย่อยในสตริง:

   s.find('sub2')
   >>> 5

3. คุณหมายถึง (ไม่ทับซ้อนกัน) นับจากลักษณะของ SU-bstring:

   s.count('sub2')
   >>> 1
   s.count('sub')
   >>> 3

วิธีที่ดีที่สุดในการค้นหาสตริงย่อยที่ทับซ้อนกันในสตริงที่กำหนดคือการใช้นิพจน์ทั่วไปของไพ ธ อนมันจะค้นหาการจับคู่ที่ทับซ้อนกันทั้งหมดโดยใช้ไลบรารีนิพจน์ทั่วไป นี่คือวิธีการทำซ้ายคือซับสตริงและในขวาคุณจะให้สตริงเพื่อให้ตรงกับ

print len(re.findall('(?=aa)','caaaab'))
3

ในการค้นหาการทับซ้อนของสตริงย่อยในสตริงใน Python 3 อัลกอริทึมนี้จะทำ:

def count_substring(string,sub_string):
    l=len(sub_string)
    count=0
    for i in range(len(string)-len(sub_string)+1):
        if(string[i:i+len(sub_string)] == sub_string ):      
            count+=1
    return count  

ฉันเองตรวจสอบอัลกอริทึมนี้และใช้งานได้

คุณสามารถนับความถี่ได้สองวิธี:

1. ใช้count()ในstr:

   a.count(b)

2. หรือคุณสามารถใช้:

   len(a.split(b))-1

aสตริงอยู่ที่ไหนและbเป็นสตริงย่อยที่ต้องคำนวณความถี่

คำตอบที่ดีที่สุดในปัจจุบันที่เกี่ยวข้องกับวิธีการcountไม่นับการทับซ้อนที่เกิดขึ้นจริง ๆ และไม่สนใจซับสตริงว่างเช่นกัน ตัวอย่างเช่น:

>>> a = 'caatatab'
>>> b = 'ata'
>>> print(a.count(b)) #overlapping
1
>>>print(a.count('')) #empty string
9

คำตอบแรกที่ควรจะ2ไม่ได้1ถ้าเราพิจารณาสตริงที่ทับซ้อนกัน สำหรับคำตอบที่สองจะดีกว่าถ้าสตริงย่อยว่างส่งคืน 0 เป็น asnwer

รหัสต่อไปนี้จะดูแลสิ่งเหล่านี้

def num_of_patterns(astr,pattern):
    astr, pattern = astr.strip(), pattern.strip()
    if pattern == '': return 0

    ind, count, start_flag = 0,0,0
    while True:
        try:
            if start_flag == 0:
                ind = astr.index(pattern)
                start_flag = 1
            else:
                ind += 1 + astr[ind+1:].index(pattern)
            count += 1
        except:
            break
    return count

ตอนนี้เมื่อเรารันมัน:

>>>num_of_patterns('caatatab', 'ata') #overlapping
2
>>>num_of_patterns('caatatab', '') #empty string
0
>>>num_of_patterns('abcdabcva','ab') #normal
2

สถานการณ์ที่ 1: การเกิดขึ้นของคำในประโยค str1 = "This is an example and is easy"เช่น: การเกิดขึ้นของคำว่า "คือ" ช่วยให้str2 = "is"

count = str1.count(str2)

สถานการณ์ที่ 2: การเกิดขึ้นของรูปแบบในประโยค

string = "ABCDCDC"
substring = "CDC"

def count_substring(string,sub_string):
    len1 = len(string)
    len2 = len(sub_string)
    j =0
    counter = 0
    while(j < len1):
        if(string[j] == sub_string[0]):
            if(string[j:j+len2] == sub_string):
                counter += 1
        j += 1

    return counter

ขอบคุณ!

คำถามไม่ชัดเจน แต่ฉันจะตอบสิ่งที่คุณถาม

สตริง S ซึ่งมีความยาวอักขระ L และที่ S [1] เป็นอักขระตัวแรกของสตริงและ S [L] เป็นอักขระตัวสุดท้ายมีสตริงย่อยดังต่อไปนี้:

• สตริง null '' มีหนึ่งในสิ่งเหล่านี้
• สำหรับทุกค่า A จาก 1 ถึง L สำหรับทุกค่า B จาก A ถึง L สตริง S [A] .. S [B] (รวม) มี L + L-1 + L-2 + ... 1 ของสตริงเหล่านี้รวม 0.5 * L * (L + 1)
• โปรดทราบว่ารายการที่สองประกอบด้วย S [1] .. S [L] คือสตริงต้นฉบับทั้งหมด S

ดังนั้นจึงมีสตริงย่อย 0.5 * L * (L + 1) + 1 ภายในสตริงที่มีความยาว L. Render นิพจน์ดังกล่าวใน Python และคุณมีจำนวนสตริงย่อยอยู่ภายในสตริง

re.subnวิธีหนึ่งคือการใช้งาน ตัวอย่างเช่นหากต้องการนับจำนวนที่เกิดขึ้น'hello'ในกรณีใด ๆ ก็ตามที่คุณสามารถทำได้

import re
_, count = re.subn(r'hello', '', astring, flags=re.I)
print('Found', count, 'occurrences of "hello"')

ฉันจะเก็บคำตอบที่ยอมรับว่าเป็น "วิธีที่ง่ายและชัดเจนในการทำ" - อย่างไรก็ตามนั่นไม่ครอบคลุมถึงเหตุการณ์ที่เกิดขึ้นซ้ำซ้อน การค้นหาสิ่งเหล่านั้นสามารถทำได้อย่างไร้เดียงสาโดยมีการตรวจสอบหลายส่วน - เช่นใน: sum ("GCAAAAAGH" [i:]. startswith ("AAA") สำหรับ i ในช่วง (len ("GCAAAAAGH"))

(ซึ่งให้ผลตอบแทน 3) - สามารถทำได้โดยใช้เคล็ดลับในการใช้นิพจน์ทั่วไปอย่างที่เห็นได้จากPython regex พบการแข่งขันที่ทับซ้อนกันทั้งหมดหรือไม่ - และมันยังสามารถทำเพื่อการตีกอล์ฟแบบละเอียดได้ - นี่คือการนับ "แฮนด์เมด" ของฉันสำหรับการทับซ้อนของรูปแบบในสตริงซึ่งพยายามที่จะไม่ไร้เดียงสาอย่างมาก (อย่างน้อยก็ไม่ได้สร้างวัตถุสตริงใหม่ในการโต้ตอบแต่ละครั้ง):

def find_matches_overlapping(text, pattern):
    lpat = len(pattern) - 1
    matches = []
    text = array("u", text)
    pattern = array("u", pattern)
    indexes = {}
    for i in range(len(text) - lpat):
        if text[i] == pattern[0]:
            indexes[i] = -1
        for index, counter in list(indexes.items()):
            counter += 1
            if text[i] == pattern[counter]:
                if counter == lpat:
                    matches.append(index)
                    del indexes[index]
                else:
                    indexes[index] = counter
            else:
                del indexes[index]
    return matches

def count_matches(text, pattern):
    return len(find_matches_overlapping(text, pattern))

เหตุการณ์ที่ทับซ้อนกัน:

def olpcount(string,pattern,case_sensitive=True):
    if case_sensitive != True:
        string  = string.lower()
        pattern = pattern.lower()
    l = len(pattern)
    ct = 0
    for c in range(0,len(string)):
        if string[c:c+l] == pattern:
            ct += 1
    return ct

test = 'my maaather lies over the oceaaan'
print test
print olpcount(test,'a')
print olpcount(test,'aa')
print olpcount(test,'aaa')

ผล:

my maaather lies over the oceaaan
6
4
2

สำหรับการนับที่ทับซ้อนกันเราสามารถใช้:

def count_substring(string, sub_string):
    count=0
    beg=0
    while(string.find(sub_string,beg)!=-1) :
        count=count+1
        beg=string.find(sub_string,beg)
        beg=beg+1
    return count

สำหรับกรณีที่ไม่ทับซ้อนกันเราสามารถใช้ฟังก์ชัน count ():

string.count(sub_string)

วิธีการเกี่ยวกับหนึ่งซับกับรายการความเข้าใจ? ในทางเทคนิคแล้วมันมีความยาว 93 ตัวอักษรทำให้ฉันพิถีพิถันในการใช้ PEP-8 คำตอบ regex.findall สามารถอ่านได้มากที่สุดหากเป็นโค้ดระดับสูง หากคุณกำลังสร้างบางสิ่งบางอย่างในระดับต่ำและไม่ต้องการการพึ่งพาสิ่งนี้จะค่อนข้างเอนเอียงและหมายถึง ฉันให้คำตอบที่ทับซ้อนกัน เห็นได้ชัดว่าใช้นับเช่นคำตอบคะแนนสูงสุดหากไม่มีการทับซ้อนกัน

def count_substring(string, sub_string):
    return len([i for i in range(len(string)) if string[i:i+len(sub_string)] == sub_string])

หากคุณต้องการนับสตริงย่อยทั้งหมด (รวมถึงที่ทับซ้อนกัน) ให้ใช้วิธีนี้

import re
def count_substring(string, sub_string):
    regex = '(?='+sub_string+')'
    # print(regex)
    return len(re.findall(regex,string))

หากคุณต้องการทราบจำนวนของสตริงย่อยภายในสตริงใด ๆ กรุณาใช้รหัสด้านล่าง รหัสเข้าใจง่ายนั่นคือเหตุผลที่ฉันข้ามความคิดเห็น :)

string=raw_input()
sub_string=raw_input()
start=0
answer=0
length=len(string)
index=string.find(sub_string,start,length)
while index<>-1:
    start=index+1
    answer=answer+1
    index=string.find(sub_string,start,length)
print answer

ฉันไม่แน่ใจว่านี่เป็นสิ่งที่ดูแล้ว แต่ฉันคิดว่านี่เป็นวิธีแก้ปัญหาสำหรับคำที่ 'ใช้แล้วทิ้ง':

for i in xrange(len(word)):
if word[:len(term)] == term:
    count += 1
word = word[1:]

print count

โดยที่คำคือคำที่คุณกำลังค้นหาและคำนั้นเป็นคำที่คุณกำลังค้นหา

string="abc"
mainstr="ncnabckjdjkabcxcxccccxcxcabc"
count=0
for i in range(0,len(mainstr)):
    k=0
    while(k<len(string)):
        if(string[k]==mainstr[i+k]):
            k+=1
        else:
            break   
    if(k==len(string)):
        count+=1;   
print(count)

import re
d = [m.start() for m in re.finditer(seaching, string)] 
print (d)

พบจำนวนครั้งสตริงย่อยที่พบในสตริงและแสดงดัชนี

my_string = """Strings are amongst the most popular data types in Python. 
               We can create the strings by enclosing characters in quotes.
               Python treats single quotes the same as double quotes."""

Count = my_string.lower().strip("\n").split(" ").count("string")
Count = my_string.lower().strip("\n").split(" ").count("strings")
print("The number of occurance of word String is : " , Count)
print("The number of occurance of word Strings is : " , Count)

เสี่ยงต่อการ downvote เนื่องจากมีอีก 2 คนที่ได้ให้โซลูชันนี้แล้ว ฉันยังลงคะแนนหนึ่งในนั้น แต่ของฉันน่าจะง่ายที่สุดสำหรับมือใหม่ที่จะเข้าใจ

def count_substring(string, sub_string):
    slen  = len(string)
    sslen = len(sub_string)
    range_s = slen - sslen + 1
    count = 0
    for i in range(range_s):
        if (string[i:i+sslen] == sub_string):
            count += 1
    return count

สำหรับสตริงอย่างง่ายที่มีการเว้นวรรคการใช้ Dict ค่อนข้างเร็วโปรดดูรหัสด้านล่าง

def getStringCount(mnstr:str, sbstr:str='')->int:
    """ Assumes two inputs string giving the string and 
        substring to look for number of occurances 
        Returns the number of occurances of a given string
    """
    x = dict()
    x[sbstr] = 0
    sbstr = sbstr.strip()
    for st in mnstr.split(' '):
        if st not in [sbstr]:
            continue
        try:
            x[st]+=1
        except KeyError:
            x[st] = 1
    return x[sbstr]

s = 'foo bar foo test one two three foo bar'
getStringCount(s,'foo')

คุณสามารถใช้startswithวิธีการ:

def count_substring(string, sub_string):
    x = 0
    for i in range(len(string)):
        if string[i:].startswith(sub_string):
            x += 1
    return x

ตรรกะด้านล่างจะใช้ได้กับสตริงและอักขระพิเศษทั้งหมด

def cnt_substr(inp_str, sub_str):
    inp_join_str = ''.join(inp_str.split())
    sub_join_str = ''.join(sub_str.split())

    return inp_join_str.count(sub_join_str)

print(cnt_substr("the sky is   $blue and not greenthe sky is   $blue and not green", "the sky"))

นี่คือวิธีแก้ปัญหาใน Python 3 และตัวพิมพ์เล็กและตัวพิมพ์ใหญ่:

s = 'foo bar foo'.upper()
sb = 'foo'.upper()
results = 0
sub_len = len(sb)
for i in range(len(s)):
    if s[i:i+sub_len] == sb:
        results += 1
print(results)

j = 0
    while i < len(string):
        sub_string_out = string[i:len(sub_string)+j]
        if sub_string == sub_string_out:
            count += 1
        i += 1
        j += 1
    return count

#counting occurence of a substring in another string (overlapping/non overlapping)
s = input('enter the main string: ')# e.g. 'bobazcbobobegbobobgbobobhaklpbobawanbobobobob'
p=input('enter the substring: ')# e.g. 'bob'

counter=0
c=0

for i in range(len(s)-len(p)+1):
    for j in range(len(p)):
        if s[i+j]==p[j]:
            if c<len(p):
                c=c+1
                if c==len(p):
                    counter+=1
                    c=0
                    break
                continue
        else:
            break
print('number of occurences of the substring in the main string is: ',counter)

s = input('enter the main string: ')
p=input('enter the substring: ')
l=[]
for i in range(len(s)):
    l.append(s[i:i+len(p)])
print(l.count(p))

สิ่งนี้ทำให้รายการสิ่งที่เกิดขึ้นทั้งหมด (เช่นการทับซ้อนกัน) ในสตริงและนับมัน

def num_occ(str1, str2):
    l1, l2 = len(str1), len(str2)
    return len([str1[i:i + l2] for i in range(l1 - l2 + 1) if str1[i:i + l2] == str2])

ตัวอย่าง:

str1 ='abcabcd'
str2 = 'bc'

จะสร้างรายการนี้ แต่บันทึกเฉพาะค่าBOLD :

[ab, bc , ca, ab, bc , cd]

ที่จะกลับมา:

len([bc, bc])

ต่อไปนี้เป็นโซลูชันที่ใช้งานได้กับทั้งการเกิดที่ไม่ซ้ำซ้อนและการทับซ้อนกัน ในการชี้แจง: สตริงย่อยที่ทับซ้อนกันเป็นอักขระที่มีอักขระตัวสุดท้ายเหมือนกับอักขระตัวแรก

def substr_count(st, sub):
    # If a non-overlapping substring then just
    # use the standard string `count` method
    # to count the substring occurences
    if sub[0] != sub[-1]:
        return st.count(sub)

    # Otherwise, create a copy of the source string,
    # and starting from the index of the first occurence
    # of the substring, adjust the source string to start
    # from subsequent occurences of the substring and keep
    # keep count of these occurences
    _st = st[::]
    start = _st.index(sub)
    cnt = 0

    while start is not None:
        cnt += 1
        try:
            _st = _st[start + len(sub) - 1:]
            start = _st.index(sub)
        except (ValueError, IndexError):
            return cnt

    return cnt