it-swarm.com.de

Anzahl der Vorkommen einer bestimmten Teilzeichenfolge in einer Zeichenfolge zählen

Wie kann ich zählen, wie oft ein bestimmter Teilstring in einem String in Python vorhanden ist?

Zum Beispiel:

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

string.count(substring), wie in:

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

update: Wie in den Kommentaren darauf hingewiesen, ist dies der Weg für nicht überlappende Vorkommen. Wenn Sie überlappende Vorkommnisse zählen müssen, überprüfen Sie die Antworten unter: " Python-Regex finden alle überlappenden Übereinstimmungen? ", oder überprüfen Sie einfach meine andere Antwort.

271
jsbueno

Je nachdem, was Sie wirklich meinen, schlage ich folgende Lösungen vor:

1) Sie meinen eine Liste von durch Leerzeichen getrennten Unterzeichenfolgen und möchten wissen, welche Positionsnummer für die Unterzeichenfolge unter allen Unterzeichenfolgen steht:

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

2) Sie meinen die Zeichenposition der Unterzeichenfolge in der Zeichenfolge:

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

3) Sie meinen die (nicht überlappenden) Zählungen des Auftretens eines Su-Strings:

s.count('sub2')
>>> 1
s.count('sub')
>>> 3
17
Don Question
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
15

Sie können die Häufigkeit auf zwei Arten zählen:

  1. Mit der count() in str:

    a.count(b)

  2. Oder Sie können verwenden:

    len(a.split(b))-1

Dabei ist a die Zeichenfolge und b die Teilzeichenfolge, deren Häufigkeit berechnet werden soll.

10
Anuj Gupta

Um nach überlappenden Vorkommen eines Teilstrings in einem String in Python 3 zu suchen, führt dieser Algorithmus Folgendes aus:

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  

Ich habe diesen Algorithmus selbst überprüft und es hat funktioniert.

9
Bharath Kumar R

Um überlappende Unterzeichenfolgen in einer bestimmten Zeichenfolge zu finden, können Sie am besten den regulären Python-Ausdruck verwenden, da alle überlappenden Übereinstimmungen mithilfe der Bibliothek für reguläre Ausdrücke gefunden werden. Wie Sie es tun, ist der Teilstring, und rechts geben Sie den passenden String an

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

Die aktuell beste Antwort mit der Methode count zählt nicht wirklich für überlappende Vorkommen und kümmert sich auch nicht um leere Teilzeichenfolgen . Zum Beispiel:

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

Die erste Antwort sollte 2 und nicht 1 sein, wenn wir die überlappenden Teilzeichenfolgen berücksichtigen . Für die zweite Antwort ist es besser, wenn eine leere Teilzeichenfolge 0 als Antwort zurückgibt.

Der folgende Code kümmert sich um diese Dinge.

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

Wenn wir es jetzt ausführen:

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

Die Frage ist nicht sehr klar, aber ich beantworte, was Sie oberflächlich fragen und fragen.

Eine Zeichenfolge S, die L Zeichen lang ist und wobei S [1] das erste Zeichen der Zeichenfolge ist und S [L] das letzte Zeichen ist, hat die folgenden Teilzeichenfolgen:

  • Die Nullzeichenfolge ''. Es gibt eine davon. 
  • Für jeden Wert A von 1 bis L, für jeden Wert B von A bis L die Zeichenfolge S [A] .. S [B] (Inklusive). Es gibt L + L-1 + L-2 + ... 1 dieser Saiten für eine Gesamtmenge von 0,5 * L * (L + 1). 
  • Beachten Sie, dass das zweite Element S [1] .. S [L], .__ umfasst. die gesamte ursprüngliche Saite S.

Es gibt also 0,5 * L * (L + 1) + 1 Teilzeichenfolgen in einer Zeichenfolge der Länge L. Rendern Sie diesen Ausdruck in Python, und Sie haben die Anzahl der Teilzeichenfolgen in der Zeichenfolge. 

4
Jim DeLaHunt

Eine Möglichkeit ist die Verwendung von re.subn . Um beispielsweise die Anzahl der Vorkommen von 'hello' in einer beliebigen Kombination von Fällen zu zählen, können Sie Folgendes tun:

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

Ich werde meine akzeptierte Antwort als "einfache und offensichtliche Möglichkeit, dies zu tun" beibehalten - dies gilt jedoch nicht für überlappende Ereignisse. Das herauszufinden, kann auf naive Weise erfolgen, indem die Scheiben mehrfach geprüft werden - wie in: sum ("GCAAAAAGH" [i:]. startswith ("AAA") für i im Bereich (len ("GCAAAAAGH")))

(was 3 ergibt) - Dies kann durch Verwendung von regulären Ausdrücken gemacht werden, wie unter Python-Regex alle überlappenden Übereinstimmungen finden kann? - und es kann auch für feines Code-Golfing -.__ sorgen. Dies ist meine "handgemachte" Zählung für überlappende Muster von Mustern in einer Zeichenfolge, die nicht extrem naiv zu sein versucht (zumindest erstellt sie keine neuen Zeichenkettenobjekte bei jedem Interaktion):

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))
2
jsbueno

Für überlappende Zähler können wir verwenden:

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

Für nicht überschneidende Fälle können wir die Funktion count () verwenden:

string.count(sub_string)
2
Dhiraj Dwivedi

Überlappende Ereignisse:

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')

Ergebnisse:

my maaather lies over the oceaaan
6
4
2
2
fyngyrz

Wie wäre es mit einem Einzeiler mit Listenverständnis? Technisch sind es 93 Zeichen lang und ersparen mir den PEP-8-Purismus. Die Antwort zu regex.findall ist am besten lesbar, wenn es sich um einen Code auf hoher Ebene handelt. Wenn Sie ein niedriges Niveau aufbauen und keine Abhängigkeiten wünschen, ist dieses ziemlich schlank und gemein. Ich gebe die überlappende Antwort. Verwenden Sie einfach count als höchste Antwort, wenn es keine Überlappung gibt.

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

Szenario 1: Vorkommen eines Wortes in einem Satz . ZB: str1 = "This is an example and is easy". Das Vorkommen des Wortes "ist". lässt str2 = "is"

count = str1.count(str2)

Szenario 2: Muster in einem Satz.

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

Vielen Dank!

1
Amith V V

Wenn Sie die Anzahl der Teilzeichenfolge in einer beliebigen Zeichenfolge ermitteln möchten. Bitte verwenden Sie den folgenden Code ..__ Der Code ist einfach zu verstehen, deshalb habe ich die Kommentare übersprungen. :)

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
1
Hemant
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))
0
pawan kumar

Hier ist die Lösung in Python 3 und ohne Berücksichtigung der Groß- und Kleinschreibung:

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)
0
attachPost

Wenn Sie alle Unterzeichenfolgen (einschließlich überlappender Zeichenfolgen) zählen möchten, verwenden Sie diese Methode.

import re
def count_substring(string, sub_string):
    regex = '(?='+sub_string+')'
    # print(regex)
    return len(re.findall(regex,string))
0
Rahul Verma
import re
d = [m.start() for m in re.finditer(seaching, string)] 
print (d)

Dadurch wird ermittelt, wie oft die untergeordnete Zeichenfolge gefunden wurde und der Index angezeigt wird.

0
Bhaskar Reddi K
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)
0

Die folgende Logik funktioniert für alle Zeichenfolgen und Sonderzeichen

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"))
0
skay
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
0
vengat
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)
0
kamran shaik
#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)
0
pawan kumar

Für eine einfache Zeichenfolge mit Leerzeichenbegrenzung ist die Verwendung von Dict recht schnell. Beachten Sie den folgenden Code

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')
0
Amit Gowda

Sie können die Funktion startwith verwenden

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

informationen zu startswith () finden Sie hier https://www.tutorialspoint.com/python/string_startswith.htm

0
Trevor Maseleme

Ich bin mir nicht sicher, ob das schon etwas ist, aber ich dachte an eine Lösung für ein Wort, das "wegwerfbar" ist:

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

print count

Wo Wort ist das Wort, in dem Sie suchen und Begriff ist der Begriff, nach dem Sie suchen

0
Alan Vinton

Einen Downvote riskieren, weil 2+ andere bereits diese Lösung bereitgestellt haben. Ich habe sogar einen von ihnen angehoben. Aber meiner ist für Neulinge wahrscheinlich am einfachsten zu verstehen.

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
0
BabarBaig