. ^ $ * + ? { [ ] \ | ( )

• *         ca*t will match "ct" (0 "a"characters), "cat" (1 "a"), "caaat" (3 "a"characters), and so forth.
• +        Another repeating metacharacter is +, which matches one or more times.
• ?        The question mark character, ?, matches either one or zero times.
• |        Vertical bar | is used as or, 'y | p' would match either character y or p.
• [  ]       Square brackets give a choice of a class of characters (like or in regular expressions). Let's consider the expression a[bcd]*b. This matches the letter "a", zero or more letters from the class [bcd], and finally ends with a "b". It will try to match up the final b using the [bcd]* part, but then backtracks to let the final b match the final b in the search pattern.
• {  }       The most complicated repeated qualifier is {m,n}, where m and n are base 10 positive integers. This qualifier means there must be at least m repetitions, and at most n of the character or expression appearing before the curly brackets. For example, a/{1,3}b will match "a/b", "a//b", and "a///b" but not "a////b", and not "ab".
• \         The backslash is a metacharacter in regular expressions, and is used to escape other metacharacters. The regex \\ matches a single backslash. \d is a single token matching a digit. Python strings also use the backslash to escape characters. To avoid confusion, we'll use python's raw string option.The python language gives us the option of using a raw string. A raw string's character's are all simply characters and are not interpeted by python as anything else. This is especially useful when using the `\' character. This is usually the escape character in python, java, C++, etc. that is used for print formatting. When using raw strings in python, it and all other characters, including all meta-characres above are all simply characters. .

• Invoke the python interpreter again by typing python
• Import the python module by typing import re
• The re.match() function expects two strings as parameters. The first one contains the re with possible meta-characters, and the second string is the string to match.

   >>> print re.match(r'From\s+', 'Fromage amk')
  None
  

  We are searching the string 'Fromage amk' for the expression 'From\s+'. This pattern requires the substring 'From'followed by at least one white space character. (\s matches any whitespace character, and + indicates one or more of them).
  The result printed is None, the python object with no value....i.e. no match. Why?
• Now try these, and ask if you have any questions:

  >>> m = re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')
  <re.MatchObject instance at 80c5978>
  >>> m.group()
  'From '
  

  This time re.match() returns an object that is not None, and the group() method reveals the substring that matches the pattern.
• Here we demonstrate or, also called alternation, using '|', and the re search() method:

  >>> a = 'i|y'
  >>> b = 'Judy'
  >>> c = 'Judi'
  >>> m = re.search(a,b)
  >>> m.group()
  'y'
  >>> m = re.search(a,c)
  >>> m.group()
  'i'
  

>>> m = re.search('(ab)*', 'ab')
>>> m.group()
'ab'
>>> m.group(0)
'ab'

>>> m = re.search('(a(b)c)d', 'abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'

>>> p = r'(\b\w+)\s+\1'
>>> m = re.search(p, 'Paris in the the spring')
>>> m.group()
'the the'

• Negative lookahead provides the solution: q(?!u)
  This matches a "q" not followed by a "u", where u is a regular expression.
• Positive lookahead works just the same. q(?=u) matches a q that is followed by a u, without making the u part of the match.

Examples to Consider

emacs lab250.py

import re     # import the reg expr module functions

def main():   # define function called main
    a = "I like Red Hat Linux for development."
    m = re.search(r"(.{7})Linux", a)  # Any 7 characters then string 'Linux'
    b = m.group(1)   # The first group in parentheses
    print "<" + b + ">"
    print m.group(0)  # The whole match

jfrankli-PB1:~ jfrankli$ python
Python 2.3.5 (#1, Mar 20 2005, 20:38:20) 
[GCC 3.3 20030304 (Apple Computer, Inc. build 1809)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import lab250
>>> lab250.main()
<ed Hat >
ed Hat Linux
>>> 

jfrankli-PB1:~ jfrankli$ python
Python 2.3.5 (#1, Mar 20 2005, 20:38:20) 
[GCC 3.3 20030304 (Apple Computer, Inc. build 1809)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import re     # import the reg expr module functions
>>> a = "I like Red Hat Linux for development."
>>> m = re.search(r"(.{7})Linux", a)
>>> b = m.group(1)
>>> print "<" + b + ">"
<ed Hat >
>>> print m.group(0)
'ed Hat Linux'

>>> a = r"Valentines is 2/14/2000. Don\'t forget!"
>>> import re
>>> m = re.search(r"\D\d{1,2}/\d{1,2}/\d{2,4}\D", a)
>>> m.group(0)

>>> s = "My, how are you"
>>> m = re.search("^how are you$", s)
>>> 

import re
def simul():
    a = "11/21/1999"
    m = re.search(r"^([01]?\d)[/-]([0123]?\d)[/-](\d{2,4})", a)
    month,day,year = m.groups()
    print year, month, day

beowulf$ getcopy test.tst

def brack():
    infile = open("test.tst", "r")
    x = infile.readline()   # read one line from file
    while x != "":
        x = x[:-1]          # slice off newline char at end of string
        m = re.search(r"\[\s*(.*)\s*\]", x)  # treat bracket as just bracket char
        if m:
            print m.group(1) # just print inbside group
        x = infile.readline()
    infile.close()

Now, we will go through some of these examples together:

def email(addr):
    b = r"^[A-Z0-9._%-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$"
    m = re.search(b, addr, re.IGNORECASE)   # allow upper or lower case
    print m.group(0)

>>> a = r'<html\b[^>]*>(.*?)</html>'
>>> m = re.search(a,'<html><H1>Test Page</H1><p>This is just a test</p></html>')
>>> m
<_sre.SRE_Match object at 0x96860>
>>> m.group()
'<html><H1>Test Page</H1><p>This is just a test</p></html>'
>>> m.group(0)
'<html><H1>Test Page</H1><p>This is just a test</p></html>'
>>> m.group(1)
'<H1>Test Page</H1><p>This is just a test</p>'
>>> m.group(2)
Traceback (most recent call last):
  File "", line 1, in ?
IndexError: no such group

>>> a = r'<([A-Z][A-Z0-9]*)\b[^>]*>(.*?)</\1>'
>>> a
'<([A-Z][A-Z0-9]*)\\b[^>]*>(.*?)</\\1>'
>>> b = '<html><H1>Test Page</H1><p>This is just a test</p></html>'
>>> b
'<html><H1>Test Page</H1><p>This is just a test</p></html>'
>>> m = re.search(a,b,re.IGNORECASE)
>>> m
<_sre.SRE_Match object at 0x741d0>
>>> m.groups()
('html', '<H1>Test Page</H1><p>This is just a test</p>')
>>> 

Other Links

Don't forget to logout.