Regular expressions: characters (2)

Regular expressions are made up of ordinary characters （ Such as character a To z） And the text mode composed of special characters . Special characters here are also called metacharacters , For different metacharacters , The meanings expressed in regular expressions are also different .

The components of a regular expression can be a single character 、 Character set 、 character in range 、 Choice between characters or any combination of all these components .

Ordinary character

Normal characters include all printable and nonprintable characters that are not explicitly specified as metacharacters . This includes all uppercase and lowercase letters 、 All figures 、 All punctuation and some other symbols .

Printable characters

character	describe
a-z A-Z	Match lowercase a-z A-Z
0-9	Match the Numbers 0-9
, . ; ’ !	Match punctuation , . ; ’ ! etc.

#  Matches a single character in a string a
>>> pattern = r"a"
>>> string = "this is a line!"
>>> re.search(pattern, string)
<re.Match object; span=(8, 9), match='a'>
#  Match a single number in a string 1
>>> pattern = r"1"
>>> string = "1+2=3"
>>> re.search(pattern, string)
<re.Match object; span=(0, 1), match='1'>
#  Match the exclamation point in the string !
>>> pattern = r"!"
>>> string = "this is a line!"
>>> re.search(pattern, string)
<re.Match object; span=(14, 15), match='!'>

Nonprinting characters

character	describe
\f	Match a page break . Equivalent to \x0c and \cL.
\n	Match a line break . Equivalent to \x0a and \cJ.
\r	Match a carriage return . Equivalent to \x0d and \cM.
\t	Match a tab . Equivalent to \x09 and \cI.
\v	Match a vertical tab . Equivalent to \x0b and \cK.

#  Match a line break 
>>> pattern = r"\n"
>>>> string = "I like python.\nI like python too."
>>> re.search(pattern, string)
<re.Match object; span=(14, 15), match='\n'>

Special characters

Special characters have special meanings in regular expressions , If you need to match these special characters , You need to add a backslash to the front \. such as ,\\ Two backslashes match special characters \,\ * Match special character *.

character	describe
\	Mark the next character as a special character 、 Or an original character 、 Or a Backward reference 、 Or an octal escape character .
.	Match any character , Except for line breaks .
\b	Matches a word boundary , That is, the position between the word and the space .
\B	Match non word boundaries .
\cx	Match by x Control characters indicated .
\d	Matches a numeric character . Equivalent to [0-9].
\D	Matches a non-numeric character . Equivalent to [^0-9].
\s	Matches any whitespace characters , Including Spaces 、 tabs 、 Page breaks and so on . Equivalent to [ \f\n\r\t\v].
\S	Matches any non-whitespace characters . Equivalent to [^ \f\n\r\t\v].
\w	Match the letter 、 Numbers 、 Underline . Equivalent to ’[A-Za-z0-9_]'.
\W	Match nonletter 、 Numbers 、 Underline . Equivalent to ‘[^A-Za-z0-9_]’.
^	Matches the start of the input string .
$	Matches the end of the input string .
a|b	matching a or b.
( )	Match the expression in brackets , It also means a group .
\1…\9	Matching first n Grouped content .
[xyz]	Character set . Matches any of the contained characters .
[^xyz]	Negative character set . Match any character not included .
[a-z]	character in range . Matches any character in the specified range .
[^a-z]	Negative character range . Matches any character that is not in the specified range .
*	Match previous subexpression zero or more times .
+	Match previous subexpression one or more times .
?	Match previous subexpression zero or once .
{n}	n Is a non negative integer . Matched definite n Time .
{n,}	n Is a non negative integer . Match at least n Time .
{n,m}	m and n All non negative integers , among n <= m. Least match n Times and at most m Time .

#  Match all the numbers 
>>> string = "123abc456def"
>>> pattern = r"\d+"
>>> re.findall(pattern, string)
['123', '456']

#  Match group ab A string that appears more than twice 
>>> pattern = r"(ab){2,}"
>>> string = "abcabcababab"
>>> re.search(pattern, string)
<re.Match object; span=(6, 12), match='ababab'>

#  Match in set a, b, c String that appears more than once 
>>> pattern = r"[abc]{1,}"
>>> string = "bcdfghijkl"
>>> re.search(pattern, string)
<re.Match object; span=(0, 2), match='bc'>
>>> pattern = r"[abc]+"
#  use + Instead of {1,}, The result is equivalent 
>>> re.search(pattern, string)
>>> string = "bcdfghijkl"
<re.Match object; span=(0, 2), match='bc'>

Let's take a look at an example of mailbox matching ：

#  Mailbox number matching 
>>> pattern = r"\b[\w.%+-][email protected][\w.-]+\.[a-zA-Z]{2,6}\b"
>>> string = "[email protected]"
>>> re.search(pattern, string)
<re.Match object; span=(0, 14), match='[email protected]'>