Python uses regular matching to determine that strings contain certain specific substrings and regular expressions. Detailed explanation of the string

1. Determine whether the string contains a string

1. in，not in

There are many ways to determine whether there are certain keywords in the string.
For example, after word segmentation, word vectors and keywords are used to perform word segmentation==Match, but the accuracy of word segmentation since this method is not recommended;
Secondly, use member operatorsin,not inIt is possible to better judge whether a string contains a certain keyword, that is, a specific string

a = 'This summer vacation I read Dream of Red Mansions and Romance of the Three Kingdoms'
b= ['Romance of the Three Kingdoms','Water Margin','Journey to the West','Dream of Red Mansions']
n = 0
for i in b:
    if i in a:
        n += 1
print(f'Read the four great classics during the summer vacation{n}Book')

Although this traversal algorithm can successfully obtain the desired results, when the data volume is large, the program execution efficiency will be very low. As a professional search tool, regular matching can greatly improve work efficiency in judging that strings contain specific strings.

2. Regular Match

import re
def is_in(fullstr,substr):
    if (substr,fullstr):
        return 1
    else:
        return 0
a = 'This summer vacation I read Dream of Red Mansions and Romance of the Three Kingdoms'
b= ['Romance of the Three Kingdoms','Water Margin','Journey to the West','Dream of Red Mansions']
n = 0
for i in b:
    n = is_in(a,i)
    n += 1
print(f'Read the four great classics during the summer vacation{n}Book')

findall: Return all strings in string that match pattern, return form as an array

(pattern, string, flags=0)

Examples are as follows:

line = []
n = 0
for i in b:
    num = is_in(a,i)
    n += num
    res = (i,a)
    line = line + res 
print(f'Read the four great classics during the summer vacation{n}Book')
print(f'They are{line}')
'''
res = (i,a)      The return value is a list
out:
Read the four great classics during the summer vacation2Book
They are['Romance of the Three Kingdoms', 'Dream of Red Mansions']
'''

The functions of regularity are very powerful, and the above uses only one of the small functions. Let's continue to learn the powerful functions of the regular

2. Regular expressions

(I) Basic content

1. Regular expression modifier—optional flag

Regular expressions can contain some optional flag modifiers to control the matching pattern. The modifier is specified as an optional flag. Multiple flags can be specified by bitwise OR(|) them. As | is set to I and M logos

2. Regular expression pattern

Pattern strings use special syntax to represent a regular expression:
(1) Letters and numbers represent themselves. A regular expression pattern matches the same string.
(2) When adding a backslash to a multiple number and a number, it has different meanings, for example\n Indicates a new line.
(3) Punctuation marks only match themselves when they are escaped, otherwise they represent special meanings.
(4) The backslash itself requires backslash escape.
(5) Since regular expressions usually contain backslashes, it is best to use raw strings to represent them. Pattern elements (such asr'\t', equivalent to'\\t') matches the corresponding special characters.

The following table lists special elements in the regular expression pattern syntax. If an optional flag parameter is provided while using the pattern, the meaning of some pattern elements will change.

(II) Common expression functions

Regular expressions are a special character sequence that can easily check whether a string matches a certain pattern. Python comes withreModules allow Python language to have all regular expression functions
Commonly used regular expression functions in python are as follows:

1.

Try to match a pattern from the start position of the string. If the start position is not successful, match() will return none

(pattern, string, flags=0)

Match successfully The method returns a matching object, otherwise it returns None
Availablegroup(num)orgroups() Match object function to get matching expressions

0: Represents a string that meets the criteria in a regular expression.
1: Represents the string in the first() of the string that meets the criteria in the regular expression.
2: Represents the string in the second() of the string that meets the criteria in the regular expression.
And so on…

import re
fullstr = 'name:alice,result:89'
result = ('name:(\w+),result:(\d+)', fullstr)
print(result)
print((0))
print((1))
print((2))
print(())

result:

out1: < object; span=(0, 20), match=‘name:alice,result:89’>
out2: name:alice,result:89
out3: alice
out4: 89
out5: name:alice,result:89

From the results, we can see that the () method returns a matching object, not the matching content. The matching result can be obtained by calling span(). If no match is successful from the start position, even if the other part contains content that needs to be matched, () will return None
Availablegroup()To extract the strings matched to each group.
group() returns a tuple containing all group strings, from 0 to the group number contained in

Notice: If no element is matched during the process of using regular expressions to match, and then group() is called, an error will be reported:AttributeError: 'NoneType' object has no attribute 'group'
If such an error occurs, you can change the match to search() to avoid this kind of problem. The search function first scans all code blocks and then extracts them.

2.

Will match the entire string and return the first successful match. If the match fails, return None

(pattern, string, flags=0)

The same parameters

Example:

import re
fullstr = 'class: Class 1, name:alice, result:89'
result = ('name:(\w+),result:(\d+)', fullstr)
print(result)
print((0))

out1: None
out2: AttributeError: ‘NoneType’ object has no attribute ‘group’
Reason: match match at the start position. If the match is not successful in the start position, match() will return none

trysearch

import re
fullstr = 'class: Class 1, name:alice, result:89'
result = ('name:(\w+),result:(\d+)', fullstr)
print(result)
print((0))
print((1))
print((2))
print(())

out１：　< object; span=(9, 29), match=‘name:alice,result:89’>
out２：　name:alice,result:89
out３：　alice
out４：　89
out５：　name:alice,result:89

3.

This function is mainly used to replace matches in strings

(pattern, repl, string, count=0, flags=0)

Examples are as follows:

#Modify the scorefullstr = 'name:alice,result:89'
res1 = (r'\d+','90',fullstr)
print(res1)

out： name:alice,result:90

replCan be a function. as follows:

#Modify the scoredef change(matched):
    value = int(('value'))
    return str(value + 1)
fullstr = 'name:alice,result:89'
res1 = ('(?P<value>\d+)',change,fullstr)
print(res1)

out： name:alice,result:90

4.

The compile function is used to compile regular expressions and generate a regular expression ( Pattern ) object for use by match() and search() functions.
The general steps for using the re module are:

1. Use the compile function to compile the string form of a regular expression into a Pattern object
2. Use a series of methods provided by the Pattern object to match and find the matching result (a Match object)
3. Finally, use the properties and methods provided by the Match object to obtain information, and perform other operations as needed.

(pattern, flags)

compileThe returned is a matching object. It has no meaning when used alone. It needs to be used with findall(), search(), and match().

5.

Find all substrings that the regular expression matches in the string and return a list, if there are multiple matching patterns, return a list of tuples, and return an empty list if no matching is found
Note： match and search are matched once findall matches all

6.

(pattern, string[, maxsplit=0, flags=0])

This is the article about python using regular matching to determine whether strings contain certain substrings and regular expressions in detailed explanations. For more related python regular expressions to determine whether string content is contained in strings, please search for my previous articles or continue browsing the following related articles. I hope everyone will support me in the future!