检查字符串是否包含另一个字符串的一定数量的单词

Question

Say we have a string 1 ABCDEF and a string 2 BDE (The letters are just for demo, in reality they are words). Now I would like to find out if there are any n conscutive "words" from string 2 in string 1. To convert the string to "words", I'd use string.split() .

For example for n equals 2, I would like to check whether BD or DE is - in this order - in string 1. BD is not in this order in the string, but DE is.

Does anyone see a pythonic way of doing this?

I do have a solution for n equals 2 but realized that I need it for arbitrary n. Also it is not particularily beautiful:

def string_contains_words_of_string(words_str, words_to_check_str):
    words = words_str.split()
    words_to_check = words_to_check_str.split()

    found_word_index = None
    for word in words:
        start = 0 if found_word_index is None else found_word_index + 1
        for i, word_to_check in enumerate(words_to_check[start:]):
            if word_to_check == word:
                if found_word_index is not None:
                    return True
                found_word_index = i
                break
            else:
                found_word_index = None
    return False

Answer 1

This is easy with a regex:

>>> import re
>>> st1='A B C D E F'
>>> st2='B D E'
>>> n=2
>>> pat=r'(?=({}))'.format(r's+'.join(r'\w+' for i in range(n)))
>>> print [(s, s in st1) for s in re.findall(pat, st2)]
[('B D', False), ('D E', True)]

The key is to use a zero width look ahead to find overlapping matches in the string. So:

>>> re.findall('(?=(\\w+\\s+\\w+))', 'B D E')
['B D', 'D E']

Now build that for n repetitions of the word found by \\w+ with:

>>> n=2
>>> r'(?=({}))'.format(r's\+'.join(r'\w+' for i in range(n)))
'(?=(\\w+\\s+\\w+))'

Now since you have two strings, use Python's in operator to produce a tuple of the result of s from the regex matches to the target string.

---

Of course if you want a non-regex to do this, just produce substrings n words by n:

>>> li=st2.split()
>>> n=2
>>> [(s, s in st1) for s in (' '.join(li[i:i+n]) for i in range(len(li)-n+1))]
[('B D', False), ('D E', True)]

And if you want the index (either method) you can use str.find :

>>> [(s, st1.find(s)) for s in (' '.join(li[i:i+n]) for i in range(len(li)-n+1)) 
...     if s in st1]
[('D E', 6)]

---

For regex that goes word by word, make sure you use a word boundary anchor:

>>> st='wordW wordX wordY wordZ'
>>> re.findall(r'(?=(\b\w+\s\b\w+))', st)
['wordW wordX', 'wordX wordY', 'wordY wordZ']

Answer 2

you could build ngrams like so:

a = 'this is an example, whatever'.split()
b = 'this is another example, whatever'.split()

def ngrams(string, n):
    return set(zip(*[string[i:] for i in range(n)]))

def common_ngrams(string1, string2, n):
    return ngrams(string1, n) & ngrams(string2, n)

results:

print(common_ngrams(a, b, 2))
{('this', 'is'), ('example,', 'whatever')}

print(common_ngrams(a, b, 1))
{('this',), ('is',), ('example,',), ('whatever',)}

Note that the tricky bit is in the ngrams function with the zip function

zip(*[string[i:] for i in range(n)]

This is essentialy the same as

zip(string, string[1:], string[2:])

for n = 3.

Also note that we're using sets of tuples, this is the best performance wise...

Answer 3

Lets say you have two strings (this can as easily be solved for strings containing more than just one letter each)

a = 'this is a beautiful day'
b = 'this day is awful'

Then to get all the words of b that also belong to a you write

x = [x for x in b.split() if x in a.split()]

Now x contains (after one line of code)

['this', 'day', 'is']

Then you check whether the serial combinations of x (from 0 up len(x) ) belong in b

for i in range(len(x)):
    for j in range(i, len(x)+1):
        word = ' '.join(x[i:j])
        if word in b:
            print(word)

The Example prints the (order preservig) combinations of b 's words that are also present in a in the same order (it takes a small tweak in the if statement of the nested for)

Answer 4

The longest common substring algorithm will work here, if you pass in a split list instead of a plain string - with the added bonus that it will also give the longest string made from the longest run of characters if you pass in the unsplit string.

def longest_common_substring(s1, s2):
    m = [[0] * (1 + len(s2)) for i in xrange(1 + len(s1))]
    longest, x_longest = 0, 0
    for x in xrange(1, 1 + len(s1)):
        for y in xrange(1, 1 + len(s2)):
            if s1[x - 1] == s2[y - 1]:
                m[x][y] = m[x - 1][y - 1] + 1
                if m[x][y] > longest:
                    longest = m[x][y]
                    x_longest = x
            else:
                m[x][y] = 0
    return s1[x_longest - longest: x_longest]