Python正则表达式

正则表达式

• 爬虫的基础掌握

  • 是一个特殊的字符序列

    检测一个字符串是否与我们设定的字符序列，相匹配

    若匹配，则可以快速检索，替换文本的操作

    场景示例1：

    检测一串数字是否是电话号码

    场景示例2：

    检测一串字符串是否符合 Email

    把一个文本中指定单词，替换成另一个单词

• 爬虫爬取html网页 找到标签，爬取标签中间的内容

• 正则表达式，主要应用在爬虫，应用数据处理与分析上

• 常用正则表达式，可使用已经完善的，可搜索到的直接使用

• 容易遗忘正则表达式，经常使用正则表达式

---

• Python 内置函数 index

  语法示例：

  A = 'C|C++|C#|Python|Java|Javascript'
  
  print(A.index('Python') > -1)
  
  True  /表示 常量A中包含str Python
  
  使用成员运算符：
  
  print('Python' in A)
  
  True  /表示 常量A中包含str Python

• 引入Python内置模块 re

  • re 中有很多方法可操作正则表达式

    语法示例：

    import re
    
    #导入内置模块
    
    A = 'C|C++|C#|Python|Java|Javascript'
    
    #把字符串赋值给常量A
    
    B = re.findall('Python', A)
    
    #常量B,接收表达式结果
    
    print(B)
    
    #返回 ['Python']

    实例：

    import re
    
    #导入内置模块
    
    A = 'C|C++|C#|Python|Java|Javascript'
    
    #把字符串赋值给常量A
    
    B = re.findall('PHP', A)
    
    #常量B,接收表达式结果
    
    if len(B) > 0:
    
      print('字符串中包含Python')
    
    else:
    
      print('字符串中无查询选项')

---

• 正则表达式在于 规则 ，而不是表达普通的常量字符串

• 组成元素

  • 普通字符

    re.findall('Python', 常量)
    
    'Python'中的字符，为普通字符

  • 元字符 （字符集，概括字符集，数量词)

    re.findall('\d', 常量)
    
    '\d'中的字符，为元字符
    
    正则表达式，就是由一系列普通字符，元字符所组成的
    
    且普通字符和元字符，可混合使用

---

• 字符集

  # 字符集
  
  import re
  
  

s = ‘abc, acc, adc, aec, afc, ahc’

z = re.findall(‘a[^cf]c’, s)

a 和 c 作为普通字符 用作定界 [cf]作为元字符进行抽象检索 匹配c or f 或关系，[^cf] 非c，非f 取反的操作

[a-f] 按顺序匹配，彼此为或关系，缩短代码长度

print(z)

```

• 概括字符集

  • 不管是字符集/概括字符集，都是匹配一个字符

    Command	Describe
    [] 中括号	括号中的字符为或关系
    \d	匹配0-9阿拉伯数字
    \D	匹配非数字
    \w	匹配单词字符(数字以及字母，下划线) [A-Z a-z 0-9 _]
    \W	匹配非单词字符 (&,*,\n, \r)
    \s	匹配空白字 符(\n , \r, \t, )
    \S	匹配非空白字符
    .	匹配除换行符外的所有字符
    |	或关系 “1|2” 一或二
    [.*]	中括号中. * 即为普通字符元素
    [^\d]	中括号中 为非关系
    \u4E00-\u9FA5	匹配中文

• 数量词

  贪婪与非贪婪使用不当 ，易导致程序bug

  • 贪婪

    #数量词
    
    import re
    
    a = 'Python 1111Java678php'
    
    b = re.findall('[A-Za-z]{3,6}', a)
    
    # 匹配大小写字母，单词数量区间为3 - 6个字符 
    
    # 为什么匹配时，没在 'Pyt' 处截断 , 一直匹配至 Python
    
    # 默认匹配方式为，贪婪 优先取设定区间最大的数量 当匹配至，不在符和条件时停下 ->跳过 ->寻找下个目标字符
    
    print(b)
    
    # ['Python', 'Java', 'php']

• 非贪婪 加入字符 ?

  import re
  
  a = 'Python 1111Java678php'
  
  b = re.findall('[A-Za-z]{3,6}?', a)
  
  # 匹配大小写字母，单词数量区间为3 - 6个字符 
  
  非贪婪 
  
  # 优先取设定区间最小数量，当匹配至，不在符和条件时停下 ->跳过 ->寻找下个目标字符
  
  print(b)
  
  # ['Pyt', 'hon', 'Jav', 'php']

• 匹配 0次 或 无限多次（去重等功能）

  import re
  
  a = 'pytho0python1pythonn2'
  
  b = re.findall('python*', a)
  
  # 匹配0次或无限多次 pytho中的 n 
  
  print(b)
  
  # ['pytho', 'python', 'pythonn']

• 匹配1次 或 无限多次

  import re
  
  a = 'pytho0python1pythonn2'
  
  b = re.findall('python+', a)
  
  # 匹配1次或无限多次 pytho中的 + 
  
  print(b)
  
  # ['python', 'pythonn']

• ? 匹配0次 或 1次

  import re
  
  a = 'pytho0python1pythonn2'
  
  b = re.findall('python?', a)
  
  # 匹配0次或 1次 pytho中的 ?
  
  print(b)
  
  # ['pytho', 'python', 'python']

• 边界匹配 ^ $

  # 边界匹配 
  
  # ^ 从字符串前面 开始匹配  仅匹配一次 结果为：有 或 空
  
  # $ 从字符串后面 开始匹配  仅匹配一次 结果为：有 或 空  看为一个占位符
  
  # ^ $ 匹配完整字符串 位数
  
  
  

import re

qq = '000000001'

# 需求：账号为4~8位之间

b = re.findall('^\d{4,9}$', qq)

# 正则匹配：贪婪 

print(b)

# ['000000001'] 从前到后，整组字符串 进行 区间 贪婪匹配

c = re.findall('00{2,3}$', qq)

print(c)

# []

d = re.findall('^00{2,3}', qq)

print(d)

# ['0000'] 仅匹配一次 0 and 匹配条件 0 {2,3}区间，默认贪婪 0 +000

e = re.findall('^100$', qq)

print(e)

# []
```

---

• 组

  • () 圆括号中的字符为 且关系

    # 组 使用()中的字符
    
    import re
    
    a = 'PythonPythonPythonPythonPython'
    
    b = re.findall('(Python){6}', a)
    
    print(b)

• 模式参数 ，findall函数的第三个参数

  • re.I 无视字符大小写

    #模式参数
    
    import re
    
    lanuage = 'PythonC#PHPJava'
    
    b = re.findall('c#', lanuage, re.I)
    
    print(b)
    
    # ['C#']

• 可接受多个模式，之间需要 | 连接在一起

• re.S匹配所有字符包括换行符

  #模式参数
  
  import re
  
  lanuage = 'PythonC#\nPHPJava'
  
  b = re.findall('c#.{1}', lanuage, re.I | re.S)
  
  #匹配c# + 一个任意字符 除\n换行符 re.I 与 re.S 为且关系 
  
  print(b)
  
  # ['C#']

• 正则替换

  • 使用re模块中的re.sub

    #正则替换
    
    import re
    
    lanuage = 'PythonC#JavaPHPPython，Python'
    
    b = re.sub('(Python)', 'python', lanuage, 2)
    
    # 把组中字符，替换为python，紧接着为字符串，count参数 默认为0 = 无限替换  
    
    print(b)

• 使用Python内置函数 replace

  #正则替换
  
  import re
  
  lanuage = 'PythonC#JavaPHPPython，Python' 
  
  lanuage = lanuage.replace('P', 'p')
  
  # 内置函数 replace 替换字符串
  
  print(b)

• 传入函数进行替换

  #正则替换
  
  import re
  
  def convert(value):
  
    return '22'
  
  lanuage = 'PythonC#JavaPHPPython，Python'
  
  b = re.sub('Python', convert, lanuage, 2)
  
  # 正则匹配，若有结果，则传入convert函数中，函数返回的值将进行替换
  
  Print(b)

• 调用函数传递参数

  #调用 （目的是把业务交给函数去处理）
  
  def convert(value):
  
      print((value)) 
  
  convert 函数被调用两次 每次传入的value 为一个对象
  
  

<re.Match object; span=(0, 6), match='Python'>  

序号 = 前面0位 至 截止六位 


<re.Match object; span=(15, 21), match='Python'>

# return '2' + value + '2'

lanuage = 'PythonC#JavaPHPPython，Python'

b = re.sub('Python', convert, lanuage, 2)
```

• 接收对象，并进行判断操作（重要）

  def convert(value):  
  
  # 接收 使用group方法转换的字符串
  
    matched = value.group()
  
    a = 'Python'
  
    # 判断字符串，进行条件转换
  
    if matched == 'Python':
  
      matched = 'C++'
  
    elif matched == 'C#':
  
      matched = 'TypeScript'
  
    else:
  
      pass
  
    return '已处理' + matched
  
  lanuage = 'PythonC#JavaPHPPython，Python'
  
  b = re.sub('Py', convert, lanuage, 2)

  Python函数 / 方法中可接受 函数 （不只是str，float，int等类型）

---

• re模块中的函数

  • Findall

    传入正则表达式，字符串，模式参数

    返回list类型中加入字符串

• Sub

  传入正则表达式，替换参数，原字符串，替换次数，模式参数

• Match

  传入正则表达式，字符串，模式参数

  从字符串的第一位开始匹配，若没有则返回None

  仅匹配一次

• Search

  传入正则表达式，字符串，模式参数

  从字符串前面往后一直匹配，成功后，立马返回结果

  仅匹配一次

• Group

  转换object类型，为字符串

  分组

  可传入参数 = 组号

• 示例代码

  import re
  
  s = 'life is short,i use Python'
  
  r = re.search(' (.*) ', s)
  
  # 上述正则表达式未一个分组， 虽然未加入()，因为只有一个分组
  
  print(r.group(1))
  
  # 传入组号，默认为0 记录的是：正则表达式的完整匹配结果
  
  # 想要访问完整匹配结果，下面的分组 需填入>=1
  
  

可连续传入多个组号

print(r.group(1, 2, 3))

('life is short,i use Python, i love Python', ' is short,i use ', ', i love ') 

查询结果以tuple类型返回
```

• Groups 不需要传入组号参数

  print(r.groups()) 
  
  返回已定义分组，不会饭后整个字符串

• Span

  返回object类型的位置

---

---