python3.14e5表示_Python学习记录14

print("#")

import re

#

s = "哈哈2"

res = re.search("[0-9]",s)

print(res)

#查询到匹配内容所在的区间 span()

print(res.span())

#查询到的匹配的内容 group()

print(res.group())

(2, 3)

2

()

s = "哈哈3uS3k42"

#匹配两位，第一位是0-9，第二位是a-z，

#但是re.search比较偷懒，只要匹配到了一个，就不再继续向后匹配了

#因此这里使用re.search()只匹配到了3u, 没有匹配后面的3k

res = re.search("[0-9][a-z]",s)

print(res)

s = "哈哈3uS3k4k2p3e"

#re.findall()找到一个后，会继续向后面会找， 匹配整个字符串

res = re.findall("[a-z][0-9][a-z]", s)

print(res)

['k4k', 'p3e']

msg = "a32rwfa3e5tv35d44"

#在[0-9]后面有个+， 表示前面的[0-9]整个模式要匹配1次或者多次

#也就是说可以出现1个数字，也可以出现多个数字(1个及其以上)

res = re.findall("[a-z][0-9]+[a-z]", msg)

print(res)

['a32r', 'a3e', 'v35d']

#验证qq号码 在5-11位数， 开头不能为0

qq = "12332232"

#正则表达式中，^表示从开头匹配，$表示匹配到结尾

res = re.match("^[1-9][0-9]{4,10}$",qq)

print(res)

#正则表达式 起名的方式

#起名的方式 (?P正则表达式) (?P=名字)

msg = "

abc

"

#这里<>是指定的字符串， 起的名字是 (?P\w+) (?P=name1) ,

#其中\w+表示匹配任意的数字，字母，下划线，+表示匹配1次或者多次

#(.+) ， 其中小括号()表示一个整体， .在正则表达式中表示除了回车的任意字符，+表示匹配一次或多次

res = re.match(r"\w+)>\w+)>(.+)(?P=name2)>(?P=name1)>", msg)

print(res)

#正则表达式 起名的方式

#起名的方式 (?P正则表达式) (?P=名字)

msg = "

abc

"

#(.+) ， 其中小括号()表示一个整体， .在正则表达式中表示除了回车的任意字符，+表示匹配一次或多次

res = re.match(r"\w+)>\w+)>(.+)(?P=name2)>(?P=name1)>", msg)

print(res)

#一个()就是一个组， (?P正则)表示给这个()分组起了个名字，叫做name

print(res.group())

print(res.group(1))

print(res.group(2))

print(res.group(3))

abc

html

h1

abc

#分组：() ----> result.group(1)获取组中匹配的内容

msg = "

abc

"

res = re.match(r"(.+)", msg)

print(res)

print(res.group(1))

None

---------------------------------------------------------------------------

AttributeError Traceback (most recent call last)

in ()

4 res = re.match(r"(.+)", msg)

5 print(res)

----> 6 print(res.group(1))

AttributeError: 'NoneType' object has no attribute 'group'

#引用分组匹配内容：

#1. number, \number 引用第number组的数据。 例如\1,\2

msg = "

abc

"

res = re.match(r"(.+)\2>\1>$", msg)

print(res)

#2. ?P正则 ?P=name

msg = "

abc

"

res = re.match(r"(.+)\2>\1>$", msg)

print(res)

print(res.group())

print(res.group(1))

print(res.group(2))

print(res.group(3))

print(res.group(4))

abc

html

h1

abc

---------------------------------------------------------------------------

IndexError Traceback (most recent call last)

in ()

6 print(res.group(2))

7 print(res.group(3))

----> 8 print(res.group(4))

IndexError: no such group

#只要有小括号就有分组， 就可以用result.group(number)

# 正则表达式模块re

re.match() 从头开始匹配

re.search() 比较懒惰，搜索到一个就不往下继续搜索了

re.findall() 比较勤奋， 会搜寻所有匹配的正则字符

re.sub() 替换

#re.sub(正则表达式，"新内容"，要处理的string)

re.split(正则，string) 切分字符串

#re.sub(正则表达式，"新内容"，要处理的string)

# 将strings中所有的数字替换成90

res = re.sub(r"\d+","90","java:99, python:100")

print(res)

java:90, python:90

#利用正则，将查询到的数值增加1

#可以看到在re.sub()的第二个参数位置，就是替换为新的字符串的位置，

#使用了一个函数名称， re.sub()给函数func传递的参数就是匹配到的结果

def func(temp):

print(temp,type(temp))

re.sub(r"\d+",func,"java:92, python:98")

'java:, python:'

#利用正则，将查询到的数值增加1

def func(temp):

#print(temp,type(temp))

print(temp.group())

num = temp.group()

num = int(num)+1

#返回的时候需要以字符串的形式返回

return str(num)

#这里的第二个参数位置是用函数名， 表示匹配到str中的数字后把数字+1

re.sub(r"\d+",func,"java:92, python:98")

92

98

'java:93, python:99'

#正则表达式切割字符串， re.split(正则， string)

#遇到逗号或者冒号，就分割一下， 再把分割的结果保存到res的列表中

res = re.split(r"[,:]","java:99,python:98")

print(res, type(res), len(res))

['java', '99', 'python', '98'] 4

#正则匹配不是 4,7结尾的手机号码， 一共11位

phone = "15054510441"

res = re.match("1\d{9}[0-35-689]",phone)

print(res)

#匹配座机号码， 类似010-10541414 ， -前面有3或者4位，-后面有8位

phone = "010-45404104"

#res = re.match("(\d{3,4})-(\d{8})", phone)

# (|) 分组中的|表示或者的关系，表示这个分组中更可以有两个选择

res = re.match("(\d{3}|\d{4})-(\d{8})", phone)

print(res)

#匹配座机号码， 类似010-10541414 ， -前面有3或者4位，-后面有8位

phone = "010-45404104"

# (|) 分组中的|表示或者的关系，表示这个分组中更可以有两个选择

res = re.match("(\d{3}|\d{4})-(\d{8})", phone)

print(res)

print(res.group())

#一个括号就表示一组， 一共有两个括号，所以有两组

#group(1)表示第一组中的内容

#group(2)表示第二组中的内容

print(res.group(1))

print(res.group(2))

010-45404104

010

45404104

msg = "abd"

#正则中，.表示匹配处理\n之外的任何字符

#正则中， 在""里面， ^表示从头开始匹配，$表示匹配到结尾

res = re.match(r"(.+)\w+>$", msg)

print(res)

print(res.group())

print(res.group(1))

abd

abd

msg = "abd"

#\1表示引用第一个括号中的内容， 结合数字达到前后的引用

res = re.match(r"(.+)(\1>)$", msg)

print(res)

#总结

正则表达式

re模块

import re

re.match(pattern, str) #从头开始匹配

re.search(pattern, str) #比较懒惰，只要匹配到了第一个，后面就不在搜索了

re.findall(pattern, str) #查询所有匹配到的字符

re.sub(pattern,"新的内容，也可以是函数", str) #替换

re.split(pattern , str) #---->[] 表示返回一个列表

#正则表达式的基础

. 任意字符，除了\n

[] 范围

| 或者

() 一组

量词：

* >= 0

+ >= 1

? 0或1

{m} 匹配m次

{m,n} 匹配m到n次，>=m , <=n

{m,} 匹配大于等于m次， >=m

#正则中的预定义转义字符

\s space

\S not space

\d digit

\D not digit

\w word

\W not word

#https://www.cnblogs.com/beiyi888/p/10281141.html

\b 边界

\B not 边界

分组：

() ---> group(1)

number:

(\w+)(\d*) ----> group(1) group(2)

引用：

(\w+)(\d*) \1 \2 表示引用前面的内容

name:

(?P正则) (?P=name1)

#python中的量词默认是贪婪的

量词就是 * + ?

在量词* + ? {m,n}后面添加?，使贪婪变成非贪婪

非贪婪模式 *? +? ??

#贪婪模式：能继续匹配就继续往后匹配，直至无法匹配

#非贪婪模式： 只要匹配到了一个，就立马停止，不再继续往后匹配了

#贪婪模式举例：

msg = "avc123adbv"

res = re.match(r"avc(\d+)", msg)

print(res)

#非贪婪模式举例：

msg = "avc123adbv"

res = re.match(r"avc(\d+?)", msg)

print(res)

#非贪婪模式举例：

msg = "avc123adbv"

res = re.match(r"avc(\d+?)", msg)

print(res)

path = '"'

#正则匹配， 非贪婪模式

res = re.match(r'', path)

print(res)

img_path = res.group(1)

print(img_path)

import requests

response = requests.get(img_path)

print(response.text) #是文本字符串文件

print("_------------")

print(response.content) #是非文本的二进制文件

# “wb”是write binary， 以二进制模式创建文件，

#将返回的二进制文件，以“wb”的形式写入本地， 就是一张图片

with open("aa.jpg", "wb") as f_w:

f_w.write(response.content)