12.3. Extracting Data Using Regular Expressions¶
If we want to extract data from a string in Python we can use the
findall() method to extract all of the substrings which
match a regular expression. Let’s use the example of wanting to extract
anything that looks like an email address from any line regardless of
format. For example, we want to pull the email addresses from each of
the following lines:
From email@example.com Sat Jan 5 09:14:16 2008
Received: (from apache@localhost)
We don’t want to write code for each of the types of lines, splitting
and slicing differently for each line. This following program uses
findall() to find the lines with email addresses in them
and extract one or more addresses from each of those lines.
Use findall to find the lines with email addresses in them and print them.
findall() method searches the string in the second
argument and returns a list of all of the strings that look like email
addresses. We are using a two-character sequence that matches a
non-whitespace character (
The output of the program is:
Translating the regular expression, we are looking for substrings that
have at least one non-whitespace character, followed by an at-sign,
followed by at least one more non-whitespace character. The
\S+ matches as many non-whitespace characters as
The regular expression would match twice (firstname.lastname@example.org and email@example.com), but it would not match the string “@2PM” because there are no non-blank characters before the at-sign. We can use this regular expression in a program to read all the lines in a file and print out anything that looks like an email address as follows:
This code searches for lines that have an at-sign (@) between characters.
We read each line and then extract all the substrings that match our
regular expression. Since
findall() returns a list, we
simply check if the number of elements in our returned list is more than
zero to print only lines where we found at least one substring that
looks like an email address.
Some of our email addresses have incorrect characters like “<” or “;” at the beginning or end. Let’s declare that we are only interested in the portion of the string that starts and ends with a letter or a number.
To do this, we use another feature of regular expressions. Square
brackets are used to indicate a set of multiple acceptable characters we
are willing to consider matching. In a sense, the
asking to match the set of “non-whitespace characters”. Now we will be a
little more explicit in terms of the characters we will match.
Here is our new regular expression:
This is getting a little complicated and you can begin to see why
regular expressions are their own little language unto themselves.
Translating this regular expression, we are looking for substrings that
start with a single lowercase letter, uppercase letter,
or number “[a-zA-Z0-9]”, followed by zero or more non-blank characters
\S*), followed by an at-sign, followed by zero or more
non-blank characters (
\S*), followed by an uppercase or
lowercase letter. Note that we switched from
* to indicate
zero or more non-blank characters since
[a-zA-Z0-9] is already one
non-blank character. Remember that the
+ applies to the single
character immediately to the left of the plus or asterisk.
If we use this expression in our program, our data is much cleaner:
This code searches for lines that have an at-sign (@) between letter or number characters.
Notice that on the
firstname.lastname@example.org lines, our regular
expression eliminated two letters at the end of the string (“>;”).
This is because when we append
[a-zA-Z] to the end of our regular
expression, we are demanding that whatever string the regular expression
parser finds must end with a letter. So when it sees the “>” at the end of
“sakaiproject.org>;” it simply stops at the last “matching” letter it
found (i.e., the “g” was the last good match).
Also note that the output of the program is a Python list that has a string as the single element in the list.