正则表达式与 JSON
初识正则表达式
正则表达式是一个特殊的字符序列，可以检查一个字符串是否与我们所设定的字符序列想匹配
可以用来快速检索文本和替换文本
比如，检查一串数字是不是电话号码，检查一个字符串是不是 email，把一个文本中指定的单词替换为另外一个单词
一个例子：一个字符串是否包含另一个字符串
# 检查字符串 a 中是否包含 python
a = 'c|c++|go|python|Javascript'
# 使用 python 自带的 in 来操作
print('python' in a)
# 使用正则表达式来操作
import re
r = re.findall('python', a)
print(r)
结果
True
['python']
一个例子：提取字符串 a 中的所有数字
import re
a = 'c0c++7go8python6Javascript'
r = re.findall('\d', a)
print(r)
结果
['0', '7', '8', '6']
第一个例子中的正则表达式 python 和第二个例子中的正则表达式 \d ，分别称为普通字符和元字符。
字符集
import re
s = 'abc, acc, adc, aec, afc, ahc'
# 找出字符串 s 中，中间是 c 或 f 的单词
r = re.findall('a[cf]c', s)
print(r)
# 找出 中间不是 c 或 f 的单词
r = re.findall('a[^cf]c', s)
print(r)
# 找出 中间是 c 或 d 或 e 或 f 的单词
r = re.findall('a[c-f]c', s)
print(r)
结果
['acc', 'afc']
['abc', 'adc', 'aec', 'ahc']
['acc', 'adc', 'aec', 'afc']
概括字符集
[\d] 数字字符，是 [0-9] 的概括字符集，[\D] 是 [\d] 的取反
[\w] 单词字符，是 [A-Za-z0-9_] 的概括字符集，[\W] 是 [\w] 的取反，包括 [' ', '\t', '&', '\n', '\r']
[\s] 空白字符，匹配空白字符，包括 ' ', '\t', \n', '\r' ， [\S] 匹配非空白字符
数量词
匹配字符串中的语言名称
import re
a = 'python 1111php678go'
r = re.findall('[a-z]{2,6}', a)
print(r)
结果
['python', 'php', 'go']
贪婪与非贪婪
默认是贪婪匹配，尽可能多的匹配，比如上面的例子中 [a-z]{2,6} 就会尽可能多的匹配到 6
非贪婪匹配，使用问号 [a-z]{2,6}?
import re
a = 'python 1111php678go'
r = re.findall('[a-z]{2,6}?', a)
print(r)
结果
['py', 'th', 'on', 'ph', 'go']
匹配 0 次 1 次或者无限多次
* 对前面的一个字符，匹配 0 次或 无限多 次
import re
a = 'pytho1python2pythonn3'
r = re.findall('python*', a)
print(r)
结果
['pytho', 'python', 'pythonn']
+ 对前面的一个字符，匹配 1 次或 无限多 次
import re
a = 'pytho1python2pythonn3'
r = re.findall('python+', a)
print(r)
结果
['python', 'pythonn']
? 对前面的一个字符，匹配 0 次或 1 次
import re
a = 'pytho1python2pythonn3'
r = re.findall('python?', a)
print(r)
结果
['pytho', 'python', 'python']
边界匹配符
^ 从字符串的开头开始匹配
$ 从字符串的末尾开始匹配
匹配长度为 4~8 位的字符
import re
qq = '123456789'
r = re.findall('^\d{4,8}$', qq)
print(r)
结果
[]
组
() 组
[] 字符集，中的每个字符是或的关系，() 组，中的每个字符是且的关系
3 个 python 匹配 1 次：
import re
a = 'PythonPythonPythonPythonPythonPython'
r = re.findall('(Python){3}', a)
print(r)
结果
['Python', 'Python']
匹配模式参数
小写匹配大写
import re
lanuage = 'PYTHON'
r = re.findall('python', lanuage)
print(r)
结果，匹配不到
[]
忽略大小写
import re
lanuage = 'PYTHON'
r = re.findall('python', lanuage, re.I)
print(r)
结果
['PYTHON']
. 匹配出换行符 \n 之外其他所有字符
用 . 匹配换行符：
import re
lanuage = 'PYTHON\n'
r = re.findall('python.', lanuage, re.I)
print(r)
结果，匹配不到
[]
匹配换行符：
import re
lanuage = 'PYTHON\n'
r = re.findall('python.', lanuage, re.I | re.S)
print(r)
结果
['PYTHON\n']
re.sub 正则替换
匹配到，替换。
re.sub('要匹配的', '替换为', 字符串)
import re
lanuage = 'PythonC++JavaPHPJava'
r = re.sub('Java', 'GO', lanuage)
print(r)
结果
PythonC++GOPHPGO
只替换匹配到的第一个
import re
lanuage = 'PythonC++JavaPHPJava'
r = re.sub('Java', 'GO', lanuage, 1)
print(r)
结果
PythonC++GOPHPJava
第二个参数，可以是一个函数
import re
lanuage = 'PythonC++GOPHPGO'
def convert(value):
# value 是匹配到的对象
print(value)
matched = value.group()
# return 是替换为
return '>' + matched + '<'
r = re.sub('GO', convert, lanuage)
print(r)
结果
PythonC++>GOGO<
一个字符串，匹配其中的数字，大于 6 的替换成 9，小于 6 的替换成 0：
import re
s = 'A8C3721D86'
def convert(value):
matched = value.group()
if int(matched) >= 6:
return '9'
else:
return '0'
r = re.sub('\d', convert, s)
print(r)
结果
A9C0900D99
Search 与 match 函数
re.match() 从首字符开始匹配，如果首字符不匹配，就返回 None，匹配到就返回匹配到的对象，只匹配一次
re.search() 搜索整个字符串，返回匹配到的第一个对象
group 分组
不要首尾
import re
s = 'life is short, i use python'
r = re.search('life(.*)python', s)
print(r.group(1))
结果
is short, i use
用 findall() 不需要使用 group()
import re
s = 'life is short, i use python'
r = re.findall('life(.*)python', s)
print(r)
结果
[' is short, i use ']
多个分组
import re
s = 'life is short, i use python, i love python'
r = re.search('life(.*)python(.*)python', s)
print(r.group(0))
print(r.group(1))
print(r.group(2))
print(r.groups())
结果
life is short, i use python, i love python
is short, i use
, i love
(' is short, i use ', ', i love ')
理解 JSON
一种轻量级的数据交换格式
- 易于阅读
- 易于解析
- 网络传输效率高
- 跨语言交换数据
json 有自己的数据类型
| Json | Python |
|---|---|
| object | dict |
| array | list |
| string | str |
| number | int |
| number | float |
| true | True |
| false | False |
| null | None |
反序列化
import json
json_object = '{"name":"张三", "age":18}'
student = json.loads(json_str)
print(type(student))
print(student)
print(student['name'])
print(student['age'])
结果
{'name': '张三', 'age': 18}
张三
18
import json
json_array = '[{"name":"张三","age":18, "flag":false}, {"name":"小明", "age":18, "flag":true}]'
student = json.loads(json_array)
print(type(student))
print(student)
结果
[{'name': '张三', 'age': 18, 'flag': False}, {'name': '小明', 'age': 18, 'flag': True}]
序列化
import json
student = [{'name': 'zhangsan', 'age': 18, 'flag': False}, {'name': 'xiaoming', 'age': 19, 'flag': True}]
json_array = json.dumps(student)
print(type(json_array))
print(json_array)
结果
[{"name": "zhangsan", "age": 18, "flag": false}, {"name": "xiaoming", "age": 19, "flag": true}]
枚举和闭包
枚举其实是一个类
from enum import Enum
class VIP(Enum):
YELLOW = 1
GREEN = 2
BLACK = 3
RED = 4
print(VIP.YELLOW)
结果
VIP.YELLOW
枚举和普通类相比的优势
普通类的类变量，可修改，变量名可重复
枚举类的类变量，不可修改，变量名不可重复
修改普通类的类变量
class Common:
YELLOW = 1
Common.YELLOW = 6
print(Common.YELLOW)
结果
6
修改枚举类的类变量
from enum import Enum
class VIP(Enum):
YELLOW = 1
GREEN = 2
BLACK = 3
RED = 4
VIP.YELLOW = 6
结果
AttributeError: Cannot reassign members.
普通类的变量名可以重复
class Common:
YELLOW = 1
YELLOW = 1
print(Common.YELLOW)
结果
1
枚举类的变量名不可重复
from enum import Enum
class VIP(Enum):
YELLOW = 1
YELLOW = 2
BLACK = 3
RED = 4
print(VIP.YELLOW)
结果
TypeError: Attempted to reuse key: 'YELLOW'
枚举类型、枚举名称与枚举值
获取 枚举值 和 枚举名称
from enum import Enum
class VIP(Enum):
YELLOW = 1
GREEN = 2
BLACK = 3
RED = 4
print(VIP.YELLOW.value)
print(VIP.YELLOW.name)
结果
1
YELLOW
枚举名称和枚举类型不同
from enum import Enum
class VIP(Enum):
YELLOW = 1
GREEN = 2
BLACK = 3
RED = 4
# 枚举名称
print(VIP.YELLOW.name)
# 枚举类型
print(VIP.YELLOW)
print(type(VIP.YELLOW.name))
print(type(VIP.YELLOW))
# 通过枚举名称获取枚举类型
print(VIP['YELLOW'])
结果
YELLOW
VIP.YELLOW
VIP.YELLOW
枚举可以遍历
通过遍历枚举，获取到这个枚举下面的所有枚举类型
from enum import Enum
class VIP(Enum):
YELLOW = 1
GREEN = 2
BLACK = 3
RED = 4
for v in VIP:
print(v)
结果
VIP.YELLOW
VIP.GREEN
VIP.BLACK
VIP.RED
枚举的比较运算
枚举的注意事项
枚举类型的值可以重复，不过此时后一个可以看做是前一个的别名
from enum import Enum
class VIP(Enum):
YELLOW = 1
GREEN = 1
BLACK = 3
RED = 4
print(VIP.GREEN)
结果
VIP.YELLOW
在遍历的时候，别名不会遍历出来
...
for v in VIP:
print(v)
结果
VIP.YELLOW
VIP.BLACK
VIP.RED
如果需要遍历出来：
...
for v in VIP.__members__.items():
print(v)
结果
('YELLOW', )
('GREEN', )
('BLACK', )
('RED', )
也可以不加 items() ：
...
for v in VIP.__members__:
print(v)
结果
YELLOW
GREEN
BLACK
RED
通过枚举值获取枚举名
数据库中存枚举值，因为占用空间小，代码中使用枚举名，因为可读性高
通过枚举值获取枚举名
from enum import Enum
class VIP(Enum):
YELLOW = 1
GREEN = 1
BLACK = 3
RED = 4
a = 1
print(VIP(a))
结果
VIP.YELLOW
枚举小结
Enum 的枚举值可以是字符串，如果只有数值类型的枚举值，可以使用 IntEnum
@unique 可以防止枚举值相同
枚举类不能实例化
一切皆对象
python 中一切皆对象
函数也是对象，可以赋值给变量，可以作为另一个函数的参数，可以作为另一个函数的返回值
函数也是对象：
def a():
pass
print(type(a))
结果
什么是闭包
调用函数 curve
def a():
def b():
pass
b()
结果
NameError: name 'b' is not defined
因为函数 curve 的作用域只在函数 curve_pre 内部。
函数可以作为另一个函数的返回值，也可以赋值给变量
def a():
def b():
print('This is a function')
# 函数可以作为另一个函数的返回值
return b
# 函数可以赋值给变量
f = a()
# f() 相当于 b()
f()
结果
This is a function
传个参数
def a():
x = 1
def b(y):
return x + y
# 函数可以作为另一个函数的返回值
return b
# 函数可以赋值给变量
f = a()
# f(2) 相当于 b(2)
result = f(2)
print(result)
结果
3
闭包 = 函数 + 环境变量
在上面的代码中，return b 其实并不只是返回了函数 b ，与函数 b 一起返回的，还有它的环境变量 x = 1 ，它们是一个整体，也就是一个闭包。
获取这个环境变量的值：
...
print(f.__closure__[0].cell_contents)
结果
1
一个示例看看闭包
def f1():
a = 10
def f2():
a = 20
print(a)
print(a)
f2()
print(a)
f1()
结果
10
20
10
闭包的经典误区
如果函数对它的环境变量重新赋值，那么这个变量会变成一个普通的局部变量
def f1():
a = 10
def f2():
# 对环境变量重新赋值，a 会被 python 认为是一个局部变量
a = 20
return a
return f2
f = f1()
print(f.__closure__)
结果
None
闭包解决问题
计算步数
初始步数 x = 0 ，走 3 步 result = 3，停一停，走 5 步，result = 8，休息一下，走 3 步， result = 11
不使用闭包的实现方法
steps = 0
def go(step):
global steps
steps += step
return steps
result1 = go(3)
print(result1)
result2 = go(5)
print(result2)
result3 = go(3)
print(result3)
结果
3
8
11
使用闭包实现
steps = 0
def factory(steps):
def go(step):
# 声明 steps 不是局部变量
nonlocal steps
steps += step
return steps
return go
# 调用 factory 函数
g = factory(steps)
# 第一次调用 go 函数
result1 = g(3)
# 结果
print(result1)
# 环境变量
print(g.__closure__[0].cell_contents)
# 全局变量
print(steps)
result2 = g(5)
print(result2)
print(g.__closure__[0].cell_contents)
print(steps)
result3 = g(3)
print(result3)
print(g.__closure__[0].cell_contents)
print(steps)
结果
3
3
0
8
8
0
11
11
0
全局变量 steps = 0 始终没有被改变，这是使用闭包的好处，因为如果每个函数都修改全局变量，容易乱。