Python基础知识学习-第11天

23_3.Python正则模块之RegexObject

实例：

import re
text = 'Tom is 9 years old. Peter is 20 years old.'
# \d表示匹配数字，+表示1次或多次
pattern = re.compile('\d+')
ans = pattern.findall(text)
print('匹配结果是：{}'.format(ans))
>>>匹配结果是：['9', '20']

也可以不进行编译：

import re
text = 'Tom is 9 years old. Peter is 20 years old.'
# \d表示匹配数字，+表示1次或多次
print('匹配结果是：{}'.format(re.findall('\d+', text)))
>>>匹配结果是：['9', '20']

进行正则表达式时，应注意转义符，如执行下例时：

import re
text = '\\author:Tom'
pattern = re.compile('\\author')
ans = pattern.findall(text)
print('匹配结果是：{}'.format(ans))
>>>匹配结果是：[]

返回一个空列表。此时可以：

import re
text = '\\author:Tom'
# 多加两个斜杠分别对原来的两个斜杠转义
pattern = re.compile('\\\\author')
ans = pattern.findall(text)
print('匹配结果是：{}'.format(ans))
>>>匹配结果是：['\\author']

也可以：

import re
text = '\\author:Tom'
# r表示原生字符，不考虑转义
pattern = re.compile(r'\\author')
ans = pattern.findall(text)
print('匹配结果是：{}'.format(ans))
>>>匹配结果是：['\\author']

import re
text = 'Tom is 8 years old. Mike is 20 years old. Peter is 87 years old.'
p_1 = re.compile(r'\d+')
ans_1 = p_1.findall(text)
print('匹配结果是：{}'.format(ans_1))
# [A-Z]表示一个大写的英文字母，\w表示一个字母数字下划线，+表示1或多个
p_2 = re.compile(r'[A-Z]\w+')
ans_2 = p_2.findall(text)
print('匹配结果是：{}'.format(ans_2))

输出：

匹配结果是：['8', '20', '87']
匹配结果是：['Tom', 'Mike', 'Peter']

.match()方法，仅从开始位置匹配，返回MatchObject对象：

import re
text = '<html><head></head><body></body></html>'
pattern = re.compile(r'<html>')
print(pattern.match(text))
>>><re.Match object; span=(0, 6), match='<html>'>

import re
text = '<html><head></head><body></body></html>'
# text2最前面有一个空格，而match方法是从最开始匹配，所以匹配不到
text2 = ' <html><head></head><body></body></html>'
pattern = re.compile(r'<html>')
print(pattern.match(text2))
>>>None

import re
text = '<html><head></head><body></body></html>'
# text2最前面有一个空格，而match方法是从最开始匹配，所以匹配不到
text2 = ' <html><head></head><body></body></html>'
pattern = re.compile(r'<html>')
# 1表示开始匹配的位置
print(pattern.match(text2, 1))
>>><re.Match object; span=(1, 7), match='<html>'>

.search()方法从任意位置开始匹配，返回MatchObject对象：

import re
text = '<html><head></head><body></body></html>'
# text2最前面有一个空格，而match方法是从最开始匹配，所以匹配不到
text2 = ' <html><head></head><body></body></html>'
pattern = re.compile(r'<html>')
# 1表示开始匹配的位置
# print(pattern.match(text2, 1))
# search从任意位置开始匹配，所以可以匹配到
print(pattern.search(text2))
>>><re.Match object; span=(1, 7), match='<html>'>

.finditer()方法，查找所有匹配项，返回一个迭代器：

import re
text = 'Tom is 8 years old. Mike is 20 years old.'
p1 = re.compile(r'\d+')
ans = p1.finditer(text)
print('ans的类型是：{}'.format(type(ans)))
for i in ans:
    print(i)

输出：

ans的类型是：<class 'callable_iterator'>
<re.Match object; span=(7, 8), match='8'>
<re.Match object; span=(28, 30), match='20'>

23_4.Python正则模块之MatchObject

实例：

import re
text = 'Tom is 8 years old. Mike is 20 years old.'
# ()表示分组，.表示除\n外的所有字符，*表示0或多次，？表示非贪婪匹配
pattern = re.compile(r'(\d+).*?(\d+)')
m = pattern.search(text)
print(m)
# .group()参数为0或空返回整个匹配
print(m.group())
print(m.group(0))
# 返回特定分组匹配细节
print(m.group(1))
print(m.group(2))
# 返回第一个分组的起始索引
print(m.start(1))
# 返回第二个分组的终止索引
print(m.end(2))

输出：

<re.Match object; span=(7, 30), match='8 years old. Mike is 20'>
8 years old. Mike is 20
8 years old. Mike is 20
8
20
7
30

23_5.Group编组

实例：

import re
# 把ab括起来，表示当作一个整体出现1次或多次，这样才能匹配到ababc
print(re.search(r'(ab)+c', 'ababc'))
# 限制备选项的范围，匹配center或centre
print(re.search(r'cent(er|re)', 'centre'))
# 如果不加括号，则匹配center或re
print(re.search(r'center|re', 'centre'))
# 重用正则模式中提取的内容。\1表示此位置重复前面第一个分组
print(re.search(r'(\w+) \1', 'hello hello, world'))
# \1表示匹配内容和前面一致，因为给定字符串中没有以空格连接的相同字符，所以返回None
print(re.search(r'(\w+) \1', 'hello world'))

输出：

<re.Match object; span=(0, 5), match='ababc'>
<re.Match object; span=(0, 6), match='centre'>
<re.Match object; span=(4, 6), match='re'>
<re.Match object; span=(0, 11), match='hello hello'>
None

给模式命名：

import re
text = 'Tom:98'
# pattern = re.compile(r'(\w+):(\d+)')
# m = pattern.search(text)
# print(m.group())
# 给模式命名，?P<名字>模式
pattern1 = re.compile(r'(?P<name>\w+):(?P<score>\d+)')
m1 = pattern1.search(text)
print(m1.group())
print(m1.group(1))
print(m1.group('name'))
print(m1.group('score'))

输出：

Tom:98
Tom
Tom
98

23_6.综合应用

.split()方法

import re
text = 'Beautiful is better than ugly.\nExplicit is better than implicit.\nSimple is better than complex.'
pattern = re.compile(r'\n')
print(pattern.split(text))
# 也可以直接调用re.split()，而不用编译模式
print(re.split(r'\n', text))
# 1表示只匹配一个结果，剩下的作为一个整体显示不匹配
print(re.split(r'\n', text, 1))
print(re.split(r'-', 'good-morning'))
# 如果想将横杠也匹配出来，可采用分组的方式
print(re.split(r'(-)', 'good-morning'))

输出：

['Beautiful is better than ugly.', 'Explicit is better than implicit.', 'Simple is better than complex.']
['Beautiful is better than ugly.', 'Explicit is better than implicit.', 'Simple is better than complex.']
['Beautiful is better than ugly.', 'Explicit is better than implicit.\nSimple is better than complex.']
['good', 'morning']
['good', '-', 'morning']

.sub()方法

import re
ords = 'ORD000ORD001ORD002'
# 表示将ords中的数字替换成“-”
print(re.sub(r'\d+', '-', ords))
text = 'Beautiful is *better* than ugly.'
# *需转义，故在前面
print(re.sub(r'\*(.*?)\*', '<strong></strong>', text))
# 如果想保留两个*中间的内容
print(re.sub(r'\*(.*?)\*', '<strong>\g<1></strong>', text))
# 给模式取名
print(re.sub(r'\*(?P<html>.*?)\*', '<strong>\g<html></strong>', text))
# '\g<2>-\g<1>'表示将第二个分组，即数字放前面，把第一个分组即字母放后面，中间用-连接
print(re.sub(r'([A-Z]+)(\d+)', '\g<2>-\g<1>', ords))
# subn可以显示替换的次数
print(re.subn(r'([A-Z]+)(\d+)', '\g<2>-\g<1>', ords))

ORD-ORD-ORD-
Beautiful is <strong></strong> than ugly.
Beautiful is <strong>better</strong> than ugly.
Beautiful is <strong>better</strong> than ugly.
000-ORD001-ORD002-ORD
('000-ORD001-ORD002-ORD', 3)

import re
text = 'python PYTHON Python'
# re.I表示忽略大小写
print(re.findall(r'python', text, re.I))
# re.M表示匹配多行
print(re.findall(r'^<html>', '\n<html>', re.M))
# re.S指定“.”可以匹配任意字符，包括\n
print(re.findall(r'\d(.)', '12\ne', re.S))

输出：

['python', 'PYTHON', 'Python']
['<html>']
['2']

24_2.sys模块应用

import sys
import traceback
try:
    raise KeyError
except:
# sys.exc_info()获取最后一次异常细节
    print(sys.exc_info())
>>>(<class 'KeyError'>, KeyError(), <traceback object at 0x00000014248ABDC8>)

创建一个.py文件，内容如下：

import sys

def add():
    a = 5
    b = 3
    return a + b

print(add())

可在命令行窗口输入如下代码执行：

python A:\pycharm\python_workspace\第10天\02.py
>>>8

如果在02.py里加上print(sys.argv),执行时会输出：

python A:\pycharm\python_workspace\第10天\02.py
>>>8
>>>['A:\\pycharm\\python_workspace\\第10天\\02.py']

sys.argv得到命令行参数。
此时在命令行输入python A:\pycharm\python_workspace\第10天\02.py x y 1 2 3，会输出：

python A:\pycharm\python_workspace\第10天\02.py  x y 1 2 3
>>>8
>>>['A:\\pycharm\\python_workspace\\第10天\\02.py', 'x', 'y', '1', '2', '3']

改变02.py的内容如下：

import sys

def add(a, b):
    # a = 5
    # b = 3
    return a + b

if sys.argv[1]:
    a = int(sys.argv[1])

if sys.argv[2]:
    b = int(sys.argv[2])

print(add(a, b))
# print(sys.argv)

在命令行输入如下内容：

python A:\pycharm\python_workspace\第10天\02.py 10 20
>>>30

标准流：

import sys
# 相当于print('hello')
sys.stdout.write('hello')
>>>hello

import sys
# 相当于x = input('请输入信息：')
print('请输入信息：')
x = sys.stdin.readline()[:]
print(x)
>>>请输入信息：
5
>>>5

import sys
sys.stderr.write('错误信息')
>>>错误信息

24_3.os模块常用功能

import os
print('当前工作目录：{}'.format(os.getcwd()))
print('当前目录内容是：{}'.format(os.listdir()))
# 改变工作目录
os.chdir('demo')
print('当前工作目录：{}'.format(os.getcwd()))
print('当前目录内容是：{}'.format(os.listdir()))
print('当前进程为：{}'.format(os.getpid()))
print('当前父进程为：{}'.format(os.getppid()))

输出：

当前工作目录：A:\pycharm\python_workspace\demo2
当前目录内容是：['01.py', 'demo']
当前工作目录：A:\pycharm\python_workspace\demo2\demo
当前目录内容是：[]
当前进程为：9356
当前父进程为：6848

Mr_Wang0120

发布了23 篇原创文章 · 获赞 0 · 访问量 410

私信关注