第二天---正则

正则表达式

import re
# + ：一个或者多个
# ？：0个或者1个
m = '100 BROAD'
s = '100 BROAD ROAD APT. 3'
print s[:-11] + s[-11:].replace('ROAD', 'RD.')
print re.sub('ROAD$', 'RD.', m)
print re.sub('\\bROAD\\b', 'RD. ', s)
print re.sub(r'\bROAD\b', 'RD.', s) # 匹配字符串中作为整个单词出现的'ROAD'

pattern = '^M?M?M?$'       # $字符限制模式只能够在一个字符串的结尾匹配。
print re.search(pattern, 'M') # 当和模式开头的字符 ^ 结合使用时，这意味着模式必须匹配整个串

# •100 = C •200 = CC •300 = CCC •400 = CD •500 = D •600 = DC •700 = DCC •800 = DCCC •900 = CM
pattern = '^M?M?M?(CM|CD|D?C?C?C?)$' 
print re.search(pattern, 'MMMCCC')         
print re.search(pattern, 'MCMC')

pattern = '^M{0,3}$'
pattern = '^M?M?M?(CM|CD|D?C?C?C?)$'  # 百位
pattern = '^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$' # 十位
pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$' # 个位

pattern = """
    ^                   # beginning of string
    M{0,3}              # thousands - 0 to 3 M's
    (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
                        #            or 500-800 (D, followed by 0 to 3 C's)
    (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
                        #        or 50-80 (L, followed by 0 to 3 X's)
    (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
                        #        or 5-8 (V, followed by 0 to 3 I's)
    $                   # end of string
    """
print "检验松散正则表达式", re.search(pattern, 'MMMDCCCLXXXVIII', re.VERBOSE)
# •忽略空白符。空格符，制表符，回车符不匹配它们自身，它们根本不参与匹配。(如果你想在松散正则表达式中匹配一个空格符，你必须在它前面添加一个反斜线符号对它进行转义。)

phonePattern = re.compile(r'^(\d{3})\D+(\d{3})\D+(\d{4})\D+(\d+)$')# \D+ 一个或者多个不是数字的任意字符
                                                                   # \d 任意一个数字 0~9
                                                                   #{3} 精确匹配三个数
phonePattern = re.compile(r'^\D*(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') #任意位置开始，
phonePattern.search('work 1-(800) 555.1212 #1234')   # 因为\D*，不能是数字，1打破了查询的条件
phonePattern = re.compile(r'(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') # 去掉开头的#

# 最终版本 # x{n,m} 匹配 x 字符，至少 n 次，至多 m 次
# (x) 一般情况下表示一个记忆组 (remembered group)。你可以利用 re.search 函数返回对象的 groups() 函数获取它的值。
# •^ 匹配字符串的开始。 •$ 匹配字符串的结尾。 •\b 匹配一个单词的边界。 •\d 匹配任意数字。•\D 匹配任意非数字字符。
# •x? 匹配一个可选的 x 字符 (换言之，它匹配 1 次或者 0 次 x 字符)。 
# •x* 匹配0次或者多次 x 字符。 
# •x+ 匹配1次或者多次 x 字符。
phonePattern = re.compile(r'''
                # don't match beginning of string, number can start anywhere
    (\d{3})     # area code is 3 digits (e.g. '800')
    \D*         # optional separator is any number of non-digits
    (\d{3})     # trunk is 3 digits (e.g. '555')
    \D*         # optional separator
    (\d{4})     # rest of number is 4 digits (e.g. '1212')
    \D*         # optional separator
    (\d*)       # extension is optional and can be any number of digits
    $           # end of string
    ''', re.VERBOSE)
print phonePattern.search('work 1-(800) 555.1212 #1234').groups()        
('800', '555', '1212', '1234')
print phonePattern.search('800-555-1212')                                
('800', '555', '1212', '')