re 正则匹配

我会带着你远行 2023-05-22 06:53 15阅读 0赞

### 文章目录 ###

*  0 六种方法:
 *  2 符号含义:
 *  示例1 判断字符串里面的邮箱地址是否有效
 *  示例2 提取数字
 *  示例3 提取单词
 *  示例4 匹配括号内容
 *  示例5 匹配双括号内容
 *  示例6 re.findall方法
 *  示例7 re.sub替换方法
 *  示例8 re.split分割字符串
 *  示例9 提取带换行，一段数据
 *  示例10 密码输入检测
 *  示例11 命名标准化位驼峰
 *  示例11 匹配数字
 *  示例12 匹配多个括号里面的内容
 *  示例13 去除全部的非字符和数组

# 0 六种方法: #

## re.compile 编译正则模式
    ## re.match	从头匹配, group获取
    
    ## re.search	包含匹配, 
    
    ## re.findall	多个匹配	
    
    ## re.sub		匹配并替换
    ## re.split	以匹配的字符, 当做列表分隔符

# 2 符号含义: #

^ 匹配字符串开头
    $ 匹配末尾
    . 匹配任意字符, 除了换行
    [...] 表示一组字符, 单独列出: [amk]匹配 'a', 'm', 'k'
    [^...] 不在[]中的字符, [^abc], 匹配除了'a', 'b', 'c'
    * 匹配>=0个表达式
    + 匹配>=1个表达式
    ? 
    {n} 精确匹配n个前面表达式 如o{2}能匹配"food"中的两个o
    {n,} 如o{2,} 能匹配fooood中所有的o
    {n,m} 匹配n到m前面的正则片段, 贪婪
    a|b 匹配a或b
    () 匹配括号内的表达式
    
    # \w 匹配字母数字下划线
    # \W 匹配非字母数字及下划线
    # \s 匹配任意字符空白
    # \S 匹配任意非空白字符
    # \d 匹配任意数字, 定价于[0-9]
    # \D 匹配任意非数字
    # \A 匹配字符串开始
    # \Z 匹配字符串结束,
    # \z 匹配结束

print("hello")

hello

import re

# 示例1 判断字符串里面的邮箱地址是否有效 #

email_pattern = re.compile(r'^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){0,4}@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){0,4}$')
    a = re.match(email_pattern, 'django@pyghon.org')
    print(a) # <_sre.SRE_Match object; span=(0, 17), match='django@pyghon.org'>

<_sre.SRE_Match object; span=(0, 17), match='django@pyghon.org'>

# 示例2 提取数字 #

# '\d+{4}'代表一个正整数重复4次，即四位整数
    year_pattern = re.compile(r'\d{4}$') # 四位整数，匹配年份
    string1 = '我在1998和1999年'
    match1 = re.match(year_pattern, string1)
    print(match1) # None
    
    match2 = re.search("\d{4}", string1)
    print(match2) # <_sre.SRE_Match object; span=(2, 6), match='1998'>
    print(match2.group())  # 1998

None
    <_sre.SRE_Match object; span=(2, 6), match='1998'>
    1998

# 示例3 提取单词 #

string3 = "Elephants are bigger than rats"
    match3 = re.search( r'(.*) are (.*?) .*', string3, re.M|re.I)
    print(match3)
    print(match3.group(1))
    print(match3.group(2))
    
    
    match3 = re.search( r'(.*) are (.*?) (.*)', string3, re.M|re.I)
    print(match3)
    print(match3.group(1))
    print(match3.group(2))
    print(match3.group(3))
    
    match3 = re.search( r'(.*) are (.*) (.*?)', string3, re.M|re.I)
    print(match3)
    print(match3.group(1))
    print(match3.group(2))
    print(match3.group(3))
    
    match3 = re.search( r'(.*?) are (.*?) (.*?)', string3, re.M|re.I)
    print(match3)
    print(match3.group(1))
    print(match3.group(2))
    print(match3.group(3))

<_sre.SRE_Match object; span=(0, 30), match='Elephants are bigger than rats'>
    Elephants
    bigger
    <_sre.SRE_Match object; span=(0, 30), match='Elephants are bigger than rats'>
    Elephants
    bigger
    than rats
    <_sre.SRE_Match object; span=(0, 26), match='Elephants are bigger than '>
    Elephants
    bigger than
    
    <_sre.SRE_Match object; span=(0, 21), match='Elephants are bigger '>
    Elephants
    bigger

# 示例4 匹配括号内容 #

string4 = "总共楼层(共7层)"
    pattern5 = re.compile(r'$.*$')  # 匹配括号包括括号
    match5 = re.search(pattern5, string4)
    print(match5.group())
    
    pattern6 = re.compile(r'$(.*)$') # 匹配括号里面的内容
    match6 = re.search(pattern6, string4)
    print(match6.group())
    print(match6.group(1))

(共7层)
    (共7层)
    共7层

# 示例5 匹配双括号内容 #

string10 = "总共楼层(共7层)干扰)问号"
    pattern10 = re.compile(r"$.*$") # 贪婪模式
    print(re.search(pattern10, string10).group())
    
    pattern10 = re.compile(r"$.*?$") # # 加问号?变非贪婪模式
    print(re.search(pattern10, string10).group())

(共7层)干扰)
    (共7层)
    
    
    
    
    
    "\n>> pattern10 = re.compile(r'\$.*\$') # 默认贪婪模式\n>>> pattern11 = re.compile(r'\$.*?\$') # 加问号?变非贪婪模式\n>>> print(re.search(pattern10, string10).group())\n(共7层)干扰)\n>>> print(re.search(pattern11, string10).group())\n(共7层)\n"

# 示例6 re.findall方法 #

# 例1 提取年份
    year_pattern = re.compile(r"\d{4}")
    string1 = "ahgk1314asg0999fa2222l"
    a  = year_pattern.findall(string1)
    print(a)
    year_pattern = re.compile(r"\d{4}$") # 注意加上$表示匹配最后
    string1 = "ahgk1314asg0999fa2222"
    year_pattern.findall(string1)

['1314', '0999', '2222']
    
    
    
    
    
    ['2222']

# 例2 
    import requests
    response = requests.get('https://www.baidu.com')
    urls = re.findall(r"<a.*>(.*)</a>", response.txt, )
    
    for url in urls:
        print(url)

---------------------------------------------------------------------------
    
    TypeError                                 Traceback (most recent call last)
    
    <ipython-input-48-c86e32ae168d> in <module>
          2 import requests
          3 response = requests.get('https://www.baidu.com')
    ----> 4 urls = re.findall(r"<a.*>(.*)</a>", response, )
          5 
          6 for url in urls:
    
    
    D:\ProgramFiles\python3.6.8\lib\re.py in findall(pattern, string, flags)
        220 
        221     Empty matches are included in the result."""
    --> 222     return _compile(pattern, flags).findall(string)
        223 
        224 def finditer(pattern, string, flags=0):
    
    
    TypeError: expected string or bytes-like object

# 示例7 re.sub替换方法 #

year_pattern = re.compile(r'\d{4}') # 四位整数，匹配年份
    string1 = '我爱1998和1999年'
    replaced_str = re.sub(year_pattern, '****', string1)
    print(replaced_str)

我爱****和****年

# 示例8 re.split分割字符串 #

string1 = "1cat2dogs3cats4"
    list1 = re.split(r'\d+', string1)
    print(list1)

['', 'cat', 'dogs', 'cats', '']

# 示例9 提取带换行，一段数据 #

import re
    src = '''define asjgkkkk haksgh hkashn keh asge aewg a hr ret void'''
    find_pattern = re.compile(r"define.*[\s\S]*.*?ret void") # [\s\S]匹配换行， .*匹配任意
    result = find_pattern.findall(src)
    print(result)

['define asjgkkkk haksgh hkashn keh \nasge\naewg\na\nhr\nret void']

import re
    src = '''__kernel int a, const __global float4* b, __globa __kernel void A(int a, const __global float4* b, __globa asge aewg a hr ret void'''
    find_pattern = re.compile(r"__kernel.*void.*A[\s\S]* .*") # [\s\S]匹配换行， .*匹配任意
    result = find_pattern.findall(src)
    print(result)

['__kernel void A(int a, const __global float4* b, __globa\nasge\naewg\na\nhr\nret void']

src = """ ms_print arguments: massif.out.3200 -------------------------------------------------------------------------------- GB 8.976^ : |::: """
    
    import re
    src = src.replace("\n"," ")
    find_pattern = re.findall(r"\d+.\d+",src)
    
    print(find_pattern)

# 示例10 密码输入检测 #

import re
    def check(mystr):
        a = re.compile(r'[0-9a-zA-Z]{6,20}') # 检测密码数字字母6到20位
        if a.fullmatch(mystr) is None:
            return '密码只能包含英文字母和数字，长度6~20'
        return '密码安全'

# 示例11 命名标准化位驼峰 #

import re
    def camel(s):
        s = re.sub(r"(\s|_|-)+", " ", s).title().replace(" ", "")
        return s[0].lower() + s[1:]
    # 批量转化
    def batch_camel(slist):
        return [camel(s) for s in slist]

# 示例11 匹配数字 #

import re
    price='25.34-34.55,hk23jk233-23sag'
    test=re.compile(r'[1-9]\d*\.\d*|0\.\d*[1-9]|[1-9]\d*|\d+-\d+').findall(price)
    print(test)
    
    test2=re.compile(r'-[1-9]\d*\.\d*|-0\.\d*[1-9]|-[1-9]\d*').findall(price)[0]
    print(test2)
    
    test3=re.compile(r'\d+-\d+|\d+|[1-9]\d*').findall(price)
    print(test3)

['25.34', '34.55', '23', '233', '23']
    -34.55
    ['25', '34-34', '55', '23', '233-23']

# 示例12 匹配多个括号里面的内容 #

import re
    s = "[[sarh,ardh][sahrd,saeee],[gdsr,57657]]"
    a = re.findall(r"\[(.*?)\]", s)
    print(a) # ['[sarh,ardh', 'sahrd,saeee', 'gdsr,57657']

# 示例13 去除全部的非字符和数组 #

import os, sys
    import re
    # 去除全部的非字符和数组
    import re
    text = "%12 = load void (%class.CompositeClass*)*, void (%class.CompositeClass*)** %11, align 8"
    r='[’!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~]+'
    # r='[’!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\n。！，]+'
    line=re.sub(r,' ',text)
    print(line)