Python Regular Expressions

Regular expressions are a special character sequence, it can help you to easily check whether a string matches a pattern.

Python re module increases since version 1.5, regular expression pattern that provides Perl-style.

re module allows Python language has all the features of regular expressions.

compile function to generate a regular expression object from a pattern string and optional parameter flags. This object has a set of methods for regular expression matching and substitution.

re module also provides a method consistent with these features functions that use a pattern string as their first argument.

This section introduces the common Python regular expression processing functions.

re.match function

re.match tries to match a pattern from the starting position of the string, if not the starting position matching is successful, match () returns none.

Function syntax:

re.match(pattern, string, flags=0)

Function parameters:

Successful match re.match method returns a match object, otherwise None.

We can use the group (num) or groups () function to get the matching objects match expressions.

Example 1:

#!/usr/bin/python
# -*- coding: UTF-8 -*- 

import re
print(re.match('www', 'w3big.com').span())  # 在起始位置匹配
print(re.match('com', 'w3big.com'))         # 不在起始位置匹配

Run the above example output is:

(0, 3)
None

Example 2:

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

The results of the above examples are as follows:

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

re.search method

re.search scan the whole string and returns the first successful match.

Function syntax:

re.search(pattern, string, flags=0)

Function parameters:

Successful match re.search method returns a match object, otherwise None.

We can use the group (num) or groups () function to get the matching objects match expressions.

Example 1:

#!/usr/bin/python
# -*- coding: UTF-8 -*- 

import re
print(re.search('www', 'w3big.com').span())  # 在起始位置匹配
print(re.search('com', 'w3big.com').span())         # 不在起始位置匹配

Run the above example output is:

(0, 3)
(11, 14)

Example 2:

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

The difference re.match and re.search

re.match matches only the beginning of the string, if the beginning of the string does not meet the regular expression, the match fails, the function returns None; and re.search match the entire string, until it finds a match.

Example:

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print "search --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

No match!!
search --> matchObj.group() :  dogs

Search and replace

Python's re module provides re.sub for the replacement string match.

grammar:

re.sub(pattern, repl, string, max=0)

The returned string is the string with the leftmost RE matches will not be repeated to replace. If the pattern is not found, characters will be returned unchanged.

Optional parameter count is the maximum number of times a pattern matching replacement; count must be a non-negative integer. The default value is 0 means to replace all occurrences.

Example:

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num

Phone Num :  2004-959-559
Phone Num :  2004959559

Regex modifier - optional flag

Regular expressions can contain optional flags modifiers to control the match mode. Modifier is specified as an optional flag. (|) To specify multiple flags which can be bitwise OR through. As re.I | re.M is set to I and M flags:

Regular expression pattern

Pattern string using a special syntax to denote a regular expression:

Letters and numerals themselves. A regular expression pattern of letters and numbers match the same string.

Most of the letters and numbers will have a different meaning when preceded by a backslash.

Punctuation is escaped only when the match itself, or they represent a special meaning.

Backslash itself needs to use the backslash escape.

Since regular expressions usually contain backslashes, so you'd better use the original string to represent them. Schema elements (such as r '/ t', equivalent to '// t') matches the corresponding special characters.

The following table lists the regular expression pattern syntax specific elements. If your usage patterns while providing optional flags argument, the meaning of certain elements of the pattern will change.

Examples of regular expressions

Character matches

Character Classes

Special character classes