python正则表达式,分组匹配

1.  c1.py

import re
# 正则表达式
# 正则表达式是一个特殊的字符序列，一个字符串是否与我们设定的这样的字符序列匹配；
# 快速检索文本，实现一些替换文本的操作

a = 'Java|node|Javascript|C++|node'

# print(a.index('node'))
# print('node' in a)

result = re.findall('nodj',a)

print(len(result))

if len(result) > 0:
    print('字符在查找的字符串中')
else:
    print('no')

2.  c2.py

import re

a = 'java2node9C++0python3C#88'

b = re.findall('\\d',a)
print(b)
print(re.findall('\\D',a))

3.  c3.py

import re

a = 'abc, acc, afc, adc, aec'

# c或者f
print(re.findall('a[cf]c',a))
# 不是c也不是f
print(re.findall('a[^cf]c',a))
# c到f
print(re.findall('a[c-f]c',a))

4. 概括字符集   c4.py

import re
# 概括字符集
a = '____abcd3e5f6j7p9w0&@#￥%* \n\r\t'
# \d:纯数字(和[0-9]含义相同)  \D:非数字(和[^0-9]含义相同)
print(re.findall('\\d',a))
print(re.findall('[0-9]',a))
print(re.findall('\\D',a))
print(re.findall('[^0-9]',a))

# \w :匹配数字和字母和下划线(和[A-Za-z0-9_]含义相同)  这里不包括特殊字符：例如：&等
# \W :匹配非单词字符集(和[^A-Za-z0-9_]含义相同) 包括但不限于：&,@,#,￥,%,*,空格，\n(换行)，\r(反斜线),\t(制表符)
# \s :空白字符 空格，\n(换行)，\r(反斜线),\t(制表符)  它不包含&,@,#,￥,%,*等
# \S :非空白字符
# .  :匹配除换行符\n之外其他所有字符
print(re.findall('\\w',a))
print(re.findall('[A-Za-z0-9_]',a))
print(re.findall('\\W',a))
print(re.findall('[^A-Za-z0-9_]',a))
print(re.findall('\\s',a))
print(re.findall('\\S',a)) 
print(re.findall('.',a))

5. 数量词  c5.py

import re
# 数量词
# (1)花括号{}
    # 花括号内只有一个数字：表示几个值
    # 花括号内两个值并且值与值间用逗号隔开：几位到几位
# (2)* :表示*前边的那个字母匹配0次或者无线多次  (0或多)
# (3)+ :表示+前边的那个字母匹配1次或者无线多次  (1或多)
# (4)? :表示?前边的那个字母匹配0次或者1次       (0或1)

# 注意
# 非贪婪的 ? 和 匹配0或1次 的 ? 不同，非贪婪的?前边是范围；匹配0或1次的?前边是字符

# print('~~~~~~~~~~~花括号~~~~~~~~~~~~')
# a = 'python 11java6node0php8'
# print(re.findall('[a-z][a-z]',a))
# print(re.findall('[a-z][a-z][a-z]',a))
# print(re.findall('[a-z]{3}',a))
# print(re.findall('[a-z]{3,6}',a))

# 贪婪   ：匹配到最大(例如：{3,6}这里的3-6即会从三开始一直匹配到不能匹配为止 （php为3,python为6都能匹配到） )
# 非贪婪 ：按照最小的来匹配,当一满足就返回不再继续匹配 (例如：{3,6}?)
# print('~~贪婪~~非贪婪~~')
# print(re.findall('[a-z]{3,6}',a))
# print(re.findall('[a-z]{3,6}?',a))

# print('~~~~~~~~~~~ * ~~~~~~~~~~~~')
# b = 'pytho0python1pythonn2'
# print(re.findall('python*',b))

# print('~~~~~~~~~~~ + ~~~~~~~~~~~~')
# c = 'pytho0python1pythonn2'
# print(re.findall('python+',c))

print('~~~~~~~~~~~ ? ~~~~~~~~~~~~')
c = 'pytho0python1pythonn2'
print(re.findall('python?',c))

6.  匹配边界  c6.py

import re
# 边界匹配 
# ^ :开始
# $ :结束

a = '100001'
b = '1000000001' #这时如果不进行边界匹配，b只会取到前8位，不是对整个字符串进行匹配
# 匹配4-8

print(re.findall('\\d{4,8}',a))
print(re.findall('\\d{4,8}',b))
# 对整个字符串进行匹配，就需要边界匹配
print(re.findall('^\\d{4,8}$',a))
print(re.findall('^\\d{4,8}$',b))

print('~~边界匹配~~')
print(re.findall('000',b)) 
print(re.findall('^000',b))
print(re.findall('000$',b))   

7.  组  c7.py

import re

# 组 :通过 () 小括号包裹，使其变为一个组
    # [] 中括号：内的字符表示  或 的关系
    # () 小括号：内的字符表示  且 的关系

# 匹配模式： findall 里有三个参数，最后一个参数表示匹配模式 
    # 模式可以接受多个，每个之间通过 '|' 竖线分隔开  ;注意：这里的竖线不会or或的关系，而是表示且的关系，必须都同时满足
    # re.I :忽略大小写
    # re.S :改变 . 点的行为
    # 这里的匹配模式不止以上两种，还有很多，如果需要可查阅资料获得，不过以上两种是最常用的

# a = 'PythonPythonPythonPythonPython'
# print(re.findall('(Python){3}',a))

b = 'PythonC#\nJavaPhp'
# print(re.findall('c#', b)) 
# print(re.findall('c#', b,re.I))
print(re.findall('c#.{1}', b ,re.I)) 
print(re.findall('c#.{1}', b ,re.I | re.S)) 

8.  常用的正则函数  c8.py

import re

# 比较常用的正则里的函数

# sub :替换
    # sub( 需要被替换掉的字符,用于替换的字符,字符串,替换的个数(0:默认，表示替换所有；其它正整数：表个数) )
    # sub 的第二个参数还可以是一个函数 (这个功能就比较强大了，好多需要替换的都是动态的，在函数中可以通过if else来处理)

# 扩展
    # 字符串有replace方法，也可实现替换，替换后原字符串不变会生成一个新的，如果要改变原来的只需要将其赋给原来的即可 (案例如下)
# a = 'C#PythonC#JavaC#PhpC#'
# aa = a.replace('C#','GO')
# print(a,aa)
    # 对于简单的替换，可以通过字符串的内置函数来实现，对于复杂的内置函数不能处理的可以通过正则来实现，正则对于简单的复杂的都能实现处理


# b = 'C#PythonC#JavaC#PhpC#'
# print(re.sub('C#','GO',b))
# print(re.sub('C#','GO',b,1))

print('~~第二个参数为函数~~')

c = 'C#PythonC#JavaC#PhpC#'

def convert(value):
    # print(value)
    matched = value.group()
    return '!!' + matched + '!!'

print(re.sub('C#',convert,c))

9.  将函数作为另一个函数的参数  c9.py

import re

# 一个函数可以将另一个函数作为参数传入，这种方式比较好，可以借鉴到其它语言的写法中

# 举一个sub的传函数的例子

# 要求：将字符串中的数字小于6的替换为0，大于6的替换为9
a = 'A5B3CC9N1M8J4L7'

def convert(value):
    matched = value.group()
    if int(matched) >= 6:
        return '9'
    else:
        return '0'

print(re.sub('\\d',convert,a))

10.  正则中的match和search方法  c10.py

import re

# 正则中的 match 和 search 方法
# 不论是match还是search获取返回结果可用group方法
    # 都有span()方法，span方法返回的是位置参数
    # match :尝试从字符串的首字母进行匹配,如果找到了匹配结果则返回，如果没有找到匹配结果则返回空None  (从首字符开始，未匹配为空，成功匹配有返回)
    # search : 搜索字符串，如果找到了匹配结果则返回，如果没找到则返回空None  (从所有查找，未匹配为空，成功匹配有返回)

# 注意
    # findall 可代替 match和search ，推荐使用findall比较方便
    # findall会查找所有，而match和search找到一个就不找了

a = 'A5B3CC9N1M8J4L7'

print(re.match('\\d',a))
print(re.search('\\d',a))
print(re.findall('\\d',a))

print('~~group方法~~span方法~~')
print(re.search('\\d',a).group())
print(re.search('CC',a).span())

11.  分组匹配  c11.py

import re

# search通过圆括号可以进行分组
    # group里可以传入参数，默认是0
    # 对中间的部分进行分组匹配后，group传入1就可匹配到中间的部分
# 这种分组也可以通过findall实现
    # 通过findall只需进行对中间部分分组即可，比较简便
# group可以传入多个值，将返回结果以元祖的形式拿到；如果进行了分组，想获取截取的中间部分，也可通过groups来获得

# a = 'life is short,i use python'
# print('~~search~~')
# print(re.search('life.*python',a).group())
# print(re.search('(life.*python)',a).group())
# print(re.search('life(.*)python',a).group())
# print(re.search('life(.*)python',a).group(1))

# print('~~findall~~')
# print(re.findall('life(.*)python',a))

# 拿到两个python之间的部分
b = 'life is short,i use python, i love python'
print(re.search('life(.*)python(.*)python',b).group(0))
print(re.search('life(.*)python(.*)python',b).group(1))
print(re.search('life(.*)python(.*)python',b).group(2))
print(re.search('life(.*)python(.*)python',b).group(0,1,2))
print(re.search('life(.*)python(.*)python',b).groups())

12.  json  c12.py

import json
# json 
    # 定义：是一种轻量级的数据交换格式
    # json 是一种数据格式
    # 字符串是json的表现形式
    # json字符串：符合json格式的字符串  例如：{'name':'qiyue'}就是；  而{'name': 就不是

# json的优势
    # 易于阅读
    # 易于解析
    # 网络传输效率高
    # 跨语言交换数据

# json 里有规定
    # 键名须加引号，键值若为非数字也须加引号 (例如下例中的json_str1没加引号，就会报错)
    # 引号必须为双引号包裹键名和键值  (例如下例中的json_str2最外层为双引号，内层都为单引号，就会报错；但json_str3和json_str2刚好相反，json_str3就没问题)

# 反序列化
    # 将json字符串变为Python数据类型(某种需要的数据结构)的过程
# 序列化
    # 将Python数据类型向json字符串转换的过程

# print('~~~~反序列化~~~~')

# json_str1 = "{name:qiyue,age:18}"
# student1 = json.loads(json_str1)
# print(student1)

# json_str2 = "{'name':'qiyue','age':18}"
# student2 = json.loads(json_str2)
# print(student2)

# json_str3 = '{"name":"qiyue","age":18}'
# student3 = json.loads(json_str3)
# 字典
# print(type(student3))
# print(student3)
# print(student3['name'])
# print(student3['age'])

# json_str4 = '[{"name":"qiyue","age":18},{"name":"qiyue","age":18}]'
# student4 = json.loads(json_str4)
# 列表
# print(type(student4))
# print(student4)

print('~~~~序列化~~~~')

student5 = [
              {"name":'shigandang',"age":18,"flag":False},
              {"name":'xixiaole',"age":18}
            ]
json_str5 = json.dumps(student5)
print(type(json_str5))
print(json_str5)

13.  c13.py

# json            python
# object          dict
# array           list
# string          str
# number          int
# number          float
# true            True
# false           False
# null            None

(备注：以上内容来自七月老师的学习笔记，仅作为学习使用)