八、正则表达式与JSON

一、正则表达式

1.匹配方式

1.1.字符集

字符集——findall方法

re.findall('Python',a)——

使用findall方法，查找字符串中是否包含Python

re.findall('\d',a)——

使用元字符，正则表达式查找数字【0-9】

re.findall('\D',a)——

使用元字符，正则表达式非数字

print('查找中间字符包含c或者f的单词：',re.findall('a[cf]c',s))

print('查找中间字符包含不是c或者f的单词：',re.findall('a[^cf]c',s))

print('查找中间字符包含c-f的单词：',re.findall('a[c-f]c',s))

import math
import re

a = 'C234|C++78|C#|Java5|Python890|Javascript'

# # 查找字符串中是否包含Python
# print(a.index('Python')> -1)
# print('Python' in a)

# 使用findall方法，查找字符串中是否包含Python
r = re.findall('Python',a)
# 使用元字符，正则表达式查找数字【0-9】
d = re.findall('\d',a)
# 使用元字符，正则表达式非数字
e = re.findall('\D',a)
print(r)
print('查找数字：',d)
print('查找非数字：',e)
if len(r) > 0:
    print('字符串中包含Python')
else:
    print('不包含Python')
    
 
s = 'aac,abc,acc,adc,aec,afc,ahc' 
print('查找中间字符包含c或者f的单词：',re.findall('a[cf]c',s))
print('查找中间字符包含不是c或者f的单词：',re.findall('a[^cf]c',s))
print('查找中间字符包含c-f的单词：',re.findall('a[c-f]c',s))

结果

['Python']
查找数字： ['2', '3', '4', '7', '8', '5', '8', '9', '0']
查找非数字： ['C', '|', 'C', '+', '+', '|', 'C', '#', '|', 'J', 'a', 'v', 'a', '|', 'P', 'y', 't', 'h', 'o', 'n', '|', 'J', 'a', 'v', 'a', 's', 'c', 'r', 'i', 'p', 't']
字符串中包含Python
查找中间字符包含c或者f的单词： ['acc', 'afc']
查找中间字符包含不是c或者f的单词： ['aac', 'abc', 'adc', 'aec', 'ahc']
查找中间字符包含c-f的单词： ['acc', 'adc', 'aec', 'afc']

1.2.概括字符集

re.findall('\w',a)——

匹配单词字符，包含0-9、A-Z、a-z、_

re.findall('\W',a)——

匹配非单词字符,包含空格、特殊字符、转义字符

re.findall('\s',a)——

匹配空白字符，转义字符、空格

re.findall('\S',a)——

匹配非空白字符

import re

a = 'python 11\t11java&678p\nh\rp'

# 匹配单词字符，包含0-9、A-Z、a-z、_
print(re.findall('\w',a))

# 匹配非单词字符,包含空格、特殊字符、转义字符
print(re.findall('\W',a))
# 匹配空白字符，转义字符、空格
print(re.findall('\s',a))
# 匹配非空白字符
print(re.findall('\S',a))

结果

['p', 'y', 't', 'h', 'o', 'n', '1', '1', '1', '1', 'j', 'a', 'v', 'a', '6', '7', '8', 'p', 'h', 'p']
[' ', '\t', '&', '\n', '\r']
[' ', '\t', '\n', '\r']
['p', 'y', 't', 'h', 'o', 'n', '1', '1', '1', '1', 'j', 'a', 'v', 'a', '&', '6', '7', '8', 'p', 'h', 'p']

1.3.数量词

贪婪取值

re.findall('[a-z]{3,6}',s——

取值a-z,位数最小为3，最大为6，贪婪取值

非贪婪取值

re.findall('[a-z]{3,6}?',s)——

取值a-z,位数最小为3，最大为6，加上？为非贪婪取值

re.findall('python*',s)——

*匹配字符前面0次或者无限次数

re.findall('python+',s)——

+匹配字符前面1次或者无限次数

re.findall('python?',s)——

?匹配字符前面0次或者1次

s = 'pytho0python 11\t11java&678p\nh\rppythonn'
# 取值a-z,位数最小为3，最大为6，贪婪取值
print(re.findall('[a-z]{3,6}',s))
# 取值a-z,位数最小为3，最大为6，加上？为非贪婪取值
print(re.findall('[a-z]{3,6}?',s))
# *匹配字符前面0次或者无限次数
print(re.findall('python*',s))
# +匹配字符前面1次或者无限次数
print(re.findall('python+',s))
# ?匹配字符前面0次或者1次
print(re.findall('python?',s))

结果

['pytho', 'python', 'java', 'ppytho']
['pyt', 'pyt', 'hon', 'jav', 'ppy', 'tho']
['pytho', 'python', 'pythonn']
['python', 'pythonn']
['pytho', 'python', 'python']

1.4.边界匹配

边界匹配——findall方法

import re
qq = '2343432444'
# 匹配最少3位、最多8位的数字，$表示从最尾部配置，结果为[43432444]
print(re.findall('\d{3,8}$',qq))
# 匹配最少3位、最多8位的数字，^表示从最前面配置，结果为[23434324]
print(re.findall('^\d{3,8}',qq))
# 匹配最少3位、最多8位的数字，前后都配置，结果为[]
print(re.findall('^\d{3,8}$',qq))

结果

['43432444']
['23434324']
[]

1.5.组

language = 'pythonpythonpythonJSJS67'
# 判断数组中，是否包含3个python
print(re.findall('(python){3}',language))
# 判断数组中，是否包含3个python，2个JS
print(re.findall('(python){3}(JS){2}',language))

结果

['python']
[('python', 'JS')]

1.6.匹配模式参数

language01 = 'PythonC#\nJavaPHP'
# 匹配c#和换行符，re.I模式代表不区分大小写，.代表配置除换行符以外左右的字符。
# re.S模式相当于将.反过来，配置换行符\n
print (re.findall('c#.{1}',language01,re.I | re.S))

结果

['C#\n']

2.正则替换

2.1.使用replace方法替换,将C#替换成GO

lanuage = 'PythonC#JavaC#PHPC#'
# replace方法替换,将C#替换成GO
print(lanuage.replace('C#','GO'))

结果

PythonGOJavaGOPHPGO

2.2.使用sub方法替换，增加替换次数

lanuage = 'PythonC#JavaC#PHPC#'
# replace方法替换,将C#替换成GO
print(lanuage.replace('C#','GO'))
# sub方法替换,将C#替换成GO,2代表替换次数，如写成0，不限制替换次数
print(re.sub('C#','GO',lanuage,2))

结果

PythonGOJavaGOPHPGO
PythonGOJavaGOPHPC#

2.3.使用sub方法，将函数作为参数，替换字符

事例1

import re
lanuage = 'PythonC#JavaC#PHPC#'
# 定义一个函数，return一个替换的字符串
# sub方法调用函数时，ab传入的是一个对象
def replace01(ab):
    print(ab)
    # 通过group方法，拿到匹配的值
    return '!!'+ab.group()+'!!'
# 将函数返回值，作为一个替换后的值
print(re.sub('C#',replace01,lanuage))

结果

<re.Match object; span=(6, 8), match='C#'>
<re.Match object; span=(12, 14), match='C#'>
<re.Match object; span=(17, 19), match='C#'>
Python!!C#!!Java!!C#!!PHP!!C#!!

事例2

s = 'A8C3721D86'
def convert(ac):
    matched = ac.group()
    if int(matched) >= 6:
        return '9'
    else:
        return '0'
r = re.sub('\d',convert,s)
print(r)

结果

A9C0900D99

3.search与match函数匹配

match、search只匹配一次，findall匹配多次

# match、search与findall最大的区别在于 
# match、search只匹配一次，findall匹配多次
s = '683C72D8E67'
# 从第一个字符匹配，如匹配到返回对象，未匹配到返回None
r = re.match('\d',s)
# 查找匹配字符下标位置
print(r.span())
# 从第一个字符匹配，继续往下匹配
rc = re.search('\d',s)
print(rc.group())

结果

(0, 1)
6

4.正则表达式，group分组

a = 'life is short,i use python'
# 使用guoup，取出所有字符串，group参数默认为0
x = re.search('life.*python',a)
print(x.group())
# 使用guoup，取出小括号中分组的字符串
x = re.search('life(.*)python',a)
print(x.group(1))

b = 'life is short,i use python,i love python'
x = re.search('life(.*)python(.*)python',b)
# 使用guoup，取出多个分组的字符串，以元组返回
print(x.group(0,1,2))
# 使用guoup，取出多个分组的字符串，不会取出全部，以元组返回
print(x.groups())

结果

ife is short,i use python
 is short,i use 
('life is short,i use python,i love python', ' is short,i use ', ',i love ')
(' is short,i use ', ',i love ')

二、JSON

1.反序列化

json_str = '[{"name":"陈大方","age":22},{"name":"刘小银","age":20}]'
student = json.loads(json_str)
print(student)

结果

[{'name': '陈大方', 'age': 22}, {'name': '刘小银', 'age': 20}]

2.序列化

student = [{'name':'陈大方','age':22},{'name':'刘小银','age':20}]
# 使用dumps方法，将字符串转换成json，返回str
json_str = json.dumps(student,indent=4,ensure_ascii=False)
print(json_str)

结果

[
    {
        "name": "陈大方",
        "age": 22
    },
    {
        "name": "刘小银",
        "age": 20
    }
]

3.json数据类型可转换为python字符类型