(二十二) 初遇python甚是喜爱之re正则表达式学习

import re
#以下代码涉及到的正则表达式语法
#在文章后面会有具体的图片解释
#先看代码过程^  ^
#代码和注释略多
#耐心看下去
#重新认识正则表达式
#定义一个字符串
text_to_search='''
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890

Ha HaHa

python.com

123-555-4321
123.555.1234
123*555*1234
8000-123-1234
9000-234-5678

Mr. Shally
Mr Smith
Ms Lily
Mrs. Robinson
Mr. T
'''

#正常情况下转义字符\t \n等
#python会自动解析
#比如:
print('\tTab')#  Tab
#正常输出一个tab键和内容
#但是在字符串前面加上r
#python就不会对转义字符做特殊处理
#直接输出原始字符串：
print(r'\tTab')#\tTab
#正则表达式则用r前缀表示，
#反斜杠不必做任何特殊处理
#接下来开始学习正则表达式
#定义一个正则表达式对象
#匹配表达式为abc
pattern = re.compile(r'abc')
#定义一个匹配的迭代器变量
matches = pattern.finditer(text_to_search)
#finditer()方法：在string 里所有的非重复匹配
#返回为一个迭代器 iterator 保存了匹配对象列表
for match in matches:
  print(match)
#运行结果：
#<re.Match object; span=(1, 4), match='abc'>
#返回一个Match匹配对象
#span：返回匹配到的string的索引开始位置到结束位置
#match：返回匹配到的值
#相当于找到text_to_search
#索引1到3位置的值：
print(text_to_search[1:4])#abc
#这里注意并没有匹配到字符串中的大写ABC
#因为默认情况下正则表达式是区分大小写的
#接下来正则表达式改为匹配"." 
pattern = re.compile(r'.')
matches = pattern.finditer(text_to_search)
for match in matches:
  pass
  #print(match)
#运行会匹配到字符串中所有的位置
#因为“.”是正则表达式中的特殊字符
#一会具体解释
#正则表达式稍作修改：
#反斜杠代表不做特殊处理
#匹配原始字符
pattern = re.compile(r'\.')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#运行结果是匹配到所有的"."
#eg:
#<re.Match object; span=(104, 105), match='.'>
#匹配url：
pattern = re.compile(r'python\.com')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#运行结果：
#<re.Match object; span=(76, 86), match='python.com'>
#匹配数字[0-9]之间
pattern = re.compile(r'\d')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#eg：
#<re.Match object; span=(55, 56), match='1'>  
#<re.Match object; span=(56, 57), match='2'>
#匹配非数字[0-9]
pattern = re.compile(r'\D')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#eg：
#<re.Match object; span=(0, 1), match='\n'>
#<re.Match object; span=(1, 2), match='a'>
#匹配大小写字母、0-9、下划线[a-zA-Z0-9_]
pattern = re.compile(r'\w')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#eg:
#<re.Match object; span=(158, 159), match='r'>
#<re.Match object; span=(161, 162), match='T'>
#匹配非小写字母、0-9、下划线相当于[^a-zA-Z0-9_]
pattern = re.compile(r'\W')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#eg:
#<re.Match object; span=(160, 161), match=' '>
#<re.Match object; span=(162, 163), match='\n'>  
#匹配空格、新的一行、tab (space, tab, newline) [ \t\n\r\f\v] 
pattern = re.compile(r'\s')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(160, 161), match=' '>
#<re.Match object; span=(162, 163), match='\n'>
#匹配非空格、新的一行、tab [^ \t\n\r\f\v]
pattern = re.compile(r'\S')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(148, 149), match='R'>
#<re.Match object; span=(149, 150), match='o'>  
#单词边界：匹配空字符串，但只在单词开始或结尾的位置
pattern = re.compile(r'\bHa')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(67, 69), match='Ha'>
#<re.Match object; span=(70, 72), match='Ha'>
#因为Ha HaHa中
#第一个Ha是在单词的开始位置
#第二个Ha前面是空格 也是开始位置
#没有匹配到最后一个Ha因为它没有单词边界
#单词边界：匹配空字符串，但不能在词的开头或者结尾
pattern = re.compile(r'\BHa')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(72, 74), match='Ha'>
#匹配到第三个一个Ha

#定义一句话
sens = 'Start a sentence and then bring it to an end'
#匹配字符串开头为Start
pattern = re.compile(r'^Start')
matches = pattern.finditer(sens)
for match in matches:
  print(match)
#<re.Match object; span=(0, 5), match='Start'>

#匹配字符串结尾为end
pattern = re.compile(r'end$')
matches = pattern.finditer(sens)
for match in matches:
  print(match)
#<re.Match object; span=(41, 44), match='end'>
#匹配字符串结尾为a
pattern = re.compile(r'a$')
matches = pattern.finditer(sens)
for match in matches:
  print(match)
#什么都不返回，没有匹配到
#匹配text_to_search字符串中的号码
#123-555-4321
#123.555.1234
#123*555*1234
pattern = re.compile(r'\d\d\d.\d\d\d.\d\d\d\d')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(88, 100), match='123-555-4321'>
#<re.Match object; span=(101, 113), match='123.555.1234'>
#<re.Match object; span=(114, 126), match='123*555*1234'>
#表达式含义:
#\d\d\d.\d\d\d.\d\d\d\d
#匹配数字三次任意字符，在匹配数字三次任意字符，最后匹配数字四次

#匹配字符串中的号码中间用中线和点连接的 不要*号连接的
#123-555-4321
#123.555.1234
#123*555*1234
#使用[-.]
pattern = re.compile(r'\d\d\d[-.]\d\d\d[-.]\d\d\d\d')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#匹配8000或者9000开头的号码：
pattern = re.compile(r'[89]000[-.]\d\d\d[-.]\d\d\d\d')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(127, 140), match='8000-123-1234'>
#<re.Match object; span=(141, 154), match='9000-234-5678'>
#匹配1到5之间的数字：
pattern = re.compile(r'[1-5]')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#匹配小写字母a到z之间的：
pattern = re.compile(r'[a-z]')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#匹配小写字母a到z大写字母A-Z之间的：
pattern = re.compile(r'[a-zA-Z]')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#匹配开头为小写字母a到z大写字母A-Z之间的：
pattern = re.compile(r'^[a-zA-Z]')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#匹配开头不是小写字母a到z大写字母A-Z之间的：
pattern = re.compile(r'[^a-zA-Z]')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)

at_str='''
cat
mat
pat
bat
bca
hat
rat
'''
#匹配at_str中开头不是b结尾是at的字符串
pattern = re.compile(r'[^b]at')
matches = pattern.finditer(at_str)
for match in matches:
  print(match)
#<re.Match object; span=(1, 4), match='cat'>
#<re.Match object; span=(5, 8), match='mat'>
#<re.Match object; span=(9, 12), match='pat'>
#<re.Match object; span=(21, 24), match='hat'>
#<re.Match object; span=(25, 28), match='rat'>
#修改上边匹配号码的正则表达式
#使用{number}匹配次数
pattern = re.compile(r'\d{3}[-.]\d{3}[-.]\d{4}')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)

#匹配Mr开头的人名
pattern = re.compile(r'Mr\.?\s[A-Z]\w*')
#表达式含义：
#匹配Mr、
#\.? 匹配点0次或者一次
#\s 空格
#[A-Z] 匹配大写字母
#\w* 匹配大小写字母、0-9、下划线0次或者多次
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(156, 166), match='Mr. Shally'>
#<re.Match object; span=(167, 175), match='Mr Smith'>
#<re.Match object; span=(198, 203), match='Mr. T'>  
#匹配Mr或Ms或Mrs开头的人名
pattern = re.compile(r'(Mr|Ms|Mrs)\.?\s[A-Z]\w*')
matches = pattern.finditer(text_to_search)
for match in matches:
  print(match)
#<re.Match object; span=(156, 166), match='Mr. Shally'>
#<re.Match object; span=(167, 175), match='Mr Smith'>
#<re.Match object; span=(176, 183), match='Ms Lily'>
#<re.Match object; span=(184, 197), match='Mrs. Robinson'>
#<re.Match object; span=(198, 203), match='Mr. T'>


###匹配电子邮件的例子
emails='''
yale@foxmail.com
yale.law123@university.com
yale-666-law@my-hobby.net
'''
pattern = re.compile(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+')
matches = pattern.finditer(emails)
for match in matches:
  print(match)

###匹配网址的例子

urls = '''
https://www.hao123.com
http://python.com
https://www.edu.gov
http://zhihu.com
'''
pattern = re.compile(r'https?://(www\.)?(\w+)(\.\w+)')
#其中每个括号代表一个组
#可以使用match.group(index)获取每个组匹配到的值
#index为0的时候 代表整个字符串
#index从1开始
matches = pattern.finditer(urls)
for match in matches:
  print(match.group(0))
#返回结果：
#https://www.hao123.com
#http://python.com
#https://www.edu.gov
#http://zhihu.com
matches = pattern.finditer(urls)
for match in matches:
  print(match.group(1))
#返回结果：
#www.
#None
#www.
#None
#还可以继续获取
#match.group(2) match.group(3)
#这里不做演示

#使用re.sub()获取制定
#正则表达式组()索引位置匹配的值
#看例子：
pattern = re.compile(r'https?://(www\.)?(\w+)(\.\w+)')
subbed_urls = pattern.sub(r'\2\3',urls)
print(subbed_urls)
#hao123.com
#python.com
#edu.gov
#zhihu.com


#使用findall()返回一个列表
pattern = re.compile(r'\d{3}[-.]\d{3}[-.]\d{4}')
matches = pattern.findall(text_to_search)
for match in matches:
  print(match)
#返回结果：
#123-555-4321
#123.555.1234
#000-123-1234
#000-234-5678

#使用match()返回一个匹配的对象
#开始位置 能够找到这个正则样式的任意个匹配，
#就返回一个相应的 匹配对象。如果不匹配，就返回 None
my_str = 'Start python,learning python,python end'
pattern = re.compile(r'Start')
matches = pattern.match(my_str)
print(matches)
#<re.Match object; span=(0, 5), match='Start'>
#匹配在 string 中的位置，使用 search()
pattern = re.compile(r'learning')
matches = pattern.search(my_str)
print(matches)
#<re.Match object; span=(13, 21), match='learning'>
#获取匹配到的值
print(matches.group())
#learning
#正则表达式忽略大小写
pattern = re.compile(r'start',re.IGNORECASE)
matches = pattern.match(my_str)
print(matches)
#<re.Match object; span=(0, 5), match='Start'>
#或者使用re.I
pattern = re.compile(r'start',re.I)
matches = pattern.match(my_str)
print(matches)
#<re.Match object; span=(0, 5), match='Start'>