爬虫正则表明式re,正则表达式

By admin in 4858.com on 2019年5月4日

注:要调用re模块时,需在py文件早先加上 import re,整个文件加贰回就够了

爬虫——正则表明式re模块,爬虫正则表明式re

干什么要上学正则表明式

实则爬虫壹共就多个至关主要步骤:

笔者们在前面包车型地铁案例里实际都简短了第一步,也等于“取”的步骤。因为大家down下了的数码是百分百的网页,这么些数量很巨大而且很混乱,在那之中山大学部分的东西是大家不关心的,因而大家须要将之按我们的内需过滤和合营出来。

那么对于文本的过滤和者规则的合营,最强劲的就是正则表明式了。

那正是说什么样是正则表明式:

  • 正则表达式,又称规则表明式,平时被用来索求、替换那二个符合有些规则的公文。
  • 正则表明式是对字符串操作的壹种逻辑公式,便是用事先定义好的片段一定字符及这一个特定字符的组合,组成2个“规则字符串”,那些“规则字符串”用来发布对字符串的壹种过滤逻辑。

给定一个正则表达式和另一个字符串,大家落实如下的目标:

  • 加以的字符串是不是切合正则表明式的过滤逻辑(“相称”)
  • 经过正则表明式,从文本字符串中拿走大家想要的特定部分(“过滤”)

4858.com 1

正则表明式规则

4858.com 2

Python的re模块

在Python中,大家可以动用内置的re模块来选拔正则表达式。

有少数亟待尤其注意的是,正则表明式使用对特殊字符进行黑底,所以只要大家要选用原始字符串,只须求加二个r前缀:r’i
love\t\.\tpython’

re模块的貌似采纳手续如下:

compile函数

compile函数用于编写翻译正则表明式,生成3个Pattern对象,它的貌似采取格局如下:

#!/usr/bin/python3
# -*- conding:utf-8 -*-
__author__ = 'mayi'

import re

# 将正则表达式编译成Pattern对象
pattern = re.compile('\d+')

在上边,我们已将3个正则表明式编写翻译成Pattern对象,接下去,大家就能够选用pattern的1多元措施对文本相配查找了。

Pattern对象的有的常用方法首要有:

  • match()方法:从起初地方开头查找,二遍相称
  • search()方法:从其余职责开始查找,叁回相称
  • findall()方法:全体才子佳人,再次回到列表
  • finditer()方法:全体同盟,重返迭代器
  • split()方法:分割字符串,再次来到列表
  • sub()方法:替换

match()方法

match()方法用于查找字符串的头顶(也足以钦定伊始地点),它是一遍相称,只要找到了多少个格外的结果就回去,而不是探索全体相称的结果。它的一般采纳格局如下:

match(string[, pos[, endpos]])

中间,string是待相称的字符串,pos和endpos是可选参数,钦点字符串的初始和顶峰地方,暗中认可值分别是0和len(string)。因而,当您不钦点pos和endpos时,match()方法暗中认可相配字符串的头顶。

当相配成功时,再次回到三个Match对象,假如未有相配上,则赶回None。

>>> import re
>>> pattern = re.compile(r'\d+')  # 用于匹配至少一个数字

>>> m = pattern.match('one12twothree34four')  # 查找头部,没有匹配
>>> print m
None

>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配,没有匹配
>>> print(m)
None

>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配,正好匹配
>>> print(m)                                        # 返回一个 Match 对象
<_sre.SRE_Match object; span=(3, 5), match='12'>

>>> print(m.group(0))   # 可省略 0
12
>>> print(m.start(0))   # 可省略 0
3
>>> print(m.end(0))     # 可省略 0
5
>>> print(m.span(0))    # 可省略 0
(3, 5)

在下边,当相称成功时重临五个Match对象,当中:

  • group([group1,…])方法用于获取多个或多个分组相称的字符串,当要拿走任何相称的子串时,可直接运用group()或group(0)
  • start([group])方法用于获取分组相配的子串在全部字符串中的起首地方(子串第2个字符的目录),参数暗中同意值为0
  • end([group])方法用于获取分组匹配的子串在总体字符串中的甘休地点(子串最终3个字符的索引 +
    一),参数暗中同意值为0
  • span([group])方法重回(start(group), end(group))

再看一个事例:

>>> import re
>>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)  # re.I 表示忽略大小写
>>> m = pattern.match('Hello World Wide Web')

>>> print(m)     # 匹配成功,返回一个 Match 对象
<_sre.SRE_Match object; span=(0, 11), match='Hello World'>

>>> print(m.group(0))  # 返回匹配成功的整个子串
Hello World

>>> print(m.span(0))   # 返回匹配成功的整个子串的索引
(0, 11)

>>> print(m.group(1))  # 返回第一个分组匹配成功的子串
Hello

>>> print(m.span(1))   # 返回第一个分组匹配成功的子串的索引
(0, 5)

>>> print(m.group(2))  # 返回第二个分组匹配成功的子串
World

>>> print(m.span(2))   # 返回第二个分组匹配成功的子串
(6, 11)

>>> print(m.groups())  # 等价于 (m.group(1), m.group(2), ...)
('Hello', 'World')

>>> print(m.group(3))   # 不存在第三个分组
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: no such group

search()方法

search()方法用于查找字符串的此外岗位,它也是三遍相配,只要找到了3个合营的结果就重回,而不是寻觅全部相配的结果,它的一般选择格局如下:

search(string[, pos[, endpos]])

中间,string是待相称的字符串,pos和endpos是可选参数,内定字符串的胚胎和终极地点,默许值分别是0和len(string)。

当相配成功时,再次来到二个Match对象,如若未有相配上,则赶回None。

一般来讲例子:

>>> import re
>>> pattern = re.compile('\d+')
>>> m = pattern.search('one12twothree34four')
>>> print(m)
<_sre.SRE_Match object; span=(3, 5), match='12'>
>>> print(m.group())
12
>>> m = pattern.search('one12twothree34four', 10, 30)
>>> print(m)
<_sre.SRE_Match object; span=(13, 15), match='34'>
>>> print(m.group())
34
>>> print(m.span())
(13, 15)

再看1个例证:

#!/usr/bin/python3
# -*- conding:utf-8 -*-
__author__ = 'mayi'

import re

# 将正则表达式编译成Pattern对象
pattern = re.compile(r'\d+')

# 使用search() 查找匹配的子串,不存在匹配的子串时,返回None
m = pattern.search('hello 123 456 789') # 若这里使用match(),返回None

if m:
    print("matching string:", m.group())
    print("position:", m.span())

实行结果:

matching string: 123
position: (6, 9)

findall()方法

地方的match()和search()方法都以一回相称,只要找到了2个一双两好的结果就回去。不过,在多数时候,大家需求找出整个字符串,得到全体相称的结果。

findall()方法的施用形式如下:

爬虫正则表明式re,正则表达式。findall(string[, pos[, endpos]])

内部,string是待相配的字符串,pos和endpos是可选参数,内定字符串的苗子和极端地点,暗中同意值分别是0和len(string)。

findall()以列表格局再次来到全体能相称的子串,假使未有相称成功,则赶回1个空驶列车表。

如下:

>>> import re
>>> pattern = re.compile(r'\d+')  # 匹配数字
>>> res1 = pattern.findall('hello 123 456 789')
>>> res2 = pattern.findall('one1two2three3four4', 0, 16)
>>> print(res1)
['123', '456', '789']
>>> print(res2)
['1', '2', '3']

再看一个例证:

>>> import re
>>> pattern = re.compile(r'\d+\.\d+')  # 匹配小数
>>> res = pattern.findall("3.1415926, 'big', 110, 95.5")
>>> print(res)
['3.1415926', '95.5']

finditer()方法

finditer()方法的一颦一笑跟findall()的行为看似,也是寻觅整个字符串,获得全数相配的结果。但它回到一个相继访问每1个10分结果(Match对象)的迭代器。

如下:

#!/usr/bin/python3
# -*- conding:utf-8 -*-
__author__ = 'mayi'

import re

pattern = re.compile(r'\d+')

res_iter1 = pattern.finditer("hello 123 456 789")
res_iter2 = pattern.finditer("one1two2three3four4", 0, 16)

print(res_iter1)
print(res_iter2)

print("res_iter1......")
for m1 in res_iter1:
    print("matching string:{}, position:{}".format(m1.group(), m1.span()))

print("res_iter2......")
for m2 in res_iter2:
    print("matching string:{}, position:{}".format(m2.group(), m2.span()))

实行结果:

<callable_iterator object at 0x00ADF7F0>
<callable_iterator object at 0x00ADF230>
res_iter1......
matching string:123, position:(6, 9)
matching string:456, position:(10, 13)
matching string:789, position:(14, 17)
res_iter2......
matching string:1, position:(3, 4)
matching string:2, position:(7, 8)
matching string:3, position:(13, 14)

split()方法

spilt()方法根据能够合作的子串将字符串分割后回来列表,它的运用格局如下:

split(string[, maxsplit])

中间,maxsplit用于钦点最大分割次数,不点大将1切分开。

如下:

 

>>> import re
>>> pattern = re.compile(r'[\s\,\;]+')
>>> print(pattern.split('a,b;; c  d'))
['a', 'b', 'c', 'd']

sub()方法

sub()方法用于替换。它的采取情势如下:

sub(repl, string[, count])

中间,repl能够是字符串也能够是一个函数:

  • 只要repl是字符串,则会使用repl去替换字符串每二个才子佳人的子串,并回到替换后的字符串,其余,repl还是可以运用id的款式来引用分组,但不能够应用编号0
  • 假使repl是函数,这些法子应该只接受三个参数(Match对象),并重临1个字符串用于替换(再次回到的字符串中不能再引用分组)
  • count用于内定最多替换次数,默许全体交流

如下:

#!/usr/bin/python3
# -*- conding:utf-8 -*-
__author__ = 'mayi'

import re

pattern = re.compile(r'(\w+) (\w+)') # \w: [A-Za-z0-9]

string = 'hello 123, hello 456'

print(pattern.sub('hello world', string))
# 我是分割线
print("*" * 30)

print(pattern.sub(r'\2 \1', string))

# 我是分割线
print("*" * 30)

def func(m):
    return 'hi ' + m.group(2)

print(pattern.sub(func, string))

# 我是分割线
print("*" * 30)

# 最多替换一次
print(pattern.sub(func, string, 1))

试行结果:

hello world, hello world
******************************
123 hello, 456 hello
******************************
hi 123, hi 456
******************************
hi 123, hello 456

相当国语

在少数意况下,大家想相配文本中的汉字,普通话的unicode编码范围注重在[u4e00-u9fa5],这里说根本是因为那一个限制并不完整,比如未有包含全角(中文)标点,但是,在大部意况下,应该是够用的。

譬如:要想把字符串s = “您好,世界。hello
world!”中的中文提抽取来,能够那样做

#!/usr/bin/python3
# -*- conding:utf-8 -*-
__author__ = 'mayi'

import re

string = "你好,世界。hello world!"

pattern = re.compile(r"[\u4e00-\u9fa5]+")

res = pattern.findall(string)

print(res)

施行结果

['你好', '世界']

 

为何要读书正则表明式 实际上爬虫1共就七个不可缺少步骤:
大家在后面包车型客车案例里其实都省…

正则表明式终归是什么样?

在一些网址注册的时候须求输入手提式有线电话机号码,当你输入一个错误的手提式有线电话机号码的时候,会提示您输入的手提式有线话机号码格式错误

那么她毕竟是哪些推断的啊?

大家用Python代码进行表示:

phone_number = input('please input your phone number : ')

于今关键难点是何等判定大家输入的号码是或不是合法,

末段根据手提式有线话机号码一共1贰个人并且是只以壹叁、14、1伍、一7、1八起来的数字那个特征,又用python写了之类代码:

while True:
    phone_number = input('please input your phone number : ')
    if len(phone_number) == 11 \
            and phone_number.isdigit()\
            and (phone_number.startswith('13') \
            or phone_number.startswith('14') \
            or phone_number.startswith('15') \
            or phone_number.startswith('17') \
            or phone_number.startswith('18')):
        print('是合法的手机号码')
    else:
        print('不是合法的手机号码')

 

那就是说有不有简要的决断方法吧?答案是迟早的,以下措施就是使用re模块的正则表达式来相配手提式无线电话机的合法性的法子

import re
phone_number = input('please input your phone number : ')
if re.match('^(13|14|15|17|18)[0-9]{9}$',phone_number):
        print('是合法的手机号码')
else:
        print('不是合法的手机号码')

 

正则表明式毕竟是如何?首先提及正则,就只和字符串相关了。

正则表明式自身和Python未有啥样关系,其自己正是相配字符串内容的壹种规则

官方概念:正则表达式是对字符串操作的1种逻辑公式,正是用事先定义好的局地一定字符、及这几个特定字符的结缘,组成3个“规则字符串”,那些“规则字符串”用来发挥对字符串的一种过滤逻辑。

部分正则表明式的实用工具:在线测试工具 

 

re模块下的常用方法

正则表达式

字符组:

在同二个义务可能现身的各类字符组成了三个字符组,在正则表明式中用 []
表示

字符分为许多类,比方数字、字母、标点等等

例如未来需求二个岗位只好出现二个数字,那么那几个职分上的字符只好是0、一、2~九那十个数之壹。

正则
待匹配字符
匹配
结果
说明
[0123456789]
8
True
在一个字符组里枚举合法的所有字符,字符组里的任意一个字符
和"待匹配字符"相同都视为可以匹配
[0123456789]
a
False
由于字符组中没有"a"字符,所以不能匹配
 

[0-9]
 

7
True
也可以用-表示范围,[0-9]就和[0123456789]是一个意思
 

[a-z]
 

s
 

True
 

同样的如果要匹配所有的小写字母,直接用[a-z]就可以表示
 

[A-Z]
 

B
 

True
 

[A-Z]就表示所有的大写字母
 

[0-9a-fA-F]
 

e
 

True
 

可以匹配数字,大小写形式的a~f,用来验证十六进制字符

 

字符:

 

元字符
 

匹配内容
匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线

\d

匹配数字
\s 匹配任意的空白符
\n 匹配一个换行符
\t 匹配一个制表符
\b 匹配一个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结尾
\W
匹配非字母或数字或下划线
\D
匹配非数字
\S
匹配非空白符
a|b
匹配字符a或字符b
()
匹配括号内的表达式,也表示一个组
[…]
匹配字符组中的字符
[^…]
非。匹配除了字符组中字符的所有字符

 

量词:

量词
用法说明
* 贪婪匹配:重复零次或更多次
+      重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

 

一丶findall

re 模块下的常用方法

findall

招来全体

 \当要从2个字符串中找到全数想要的结果时,使用
findall*

import re

ret = re.findall('e', 'evenroot')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['e', 'e']

import re

ret = re.findall('[a-z]+', 'even root yuan')
    # 返回所有满足匹配条件的结果,放在列表里
print(ret)  #结果['even', 'root', 'yuan']

 

search

找第三个

 \当只要求从贰个字符串中找到三个结出的时候,使用
search*

import re

ret = re.search('x','eeevvadfae fsdf zzzzc c')
print(ret)
print(ret.group())
#从前往后,找到一个就返回,返回的变量需要调用group才能拿到结果
#如果没有找到,那么返回None,调用group会报错 

4858.com 34858.com 4

None
Traceback (most recent call last):
  File "D:/Python Road/re模块.py", line 31, in <module>
    print(ret.group())
AttributeError: 'NoneType' object has no attribute 'group'

来得结果

* 因为 search 未有找到字符,就能回去
None。所以常用的方法,我们写成这么,防止找不到的时候的输入报错*

import re

ret = re.search('x','eeevvadfae fsdf zzzzc c')
if ret:
    print(ret.group())


#显示结果:

 

match

从头开始找一个

 \当必须需求从最开头就能够合作上的,使用
match*

import re

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : a

# match是从头开始匹配,如果正则规则从头开始可以匹配上,就返回一个变量。
# 匹配的内容需要用group才能显示
# 如果没匹配上,就返回None,调用group会报错

* 一样的,因为 match 未有找到字符,就能够回来
None。所以常用的方法,我们写成那样,幸免找不到的时候的输入报错*

import re

ret = re.match('v','eeevvadfae fsdf zzzzc c')
if ret:
    print(ret.group())

 

split

分割

 \当需求分割三个字符串的时候,使用
split*

import re
ret = re.split('[ab]','abcd')
print(ret)
#先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割

 

sub

替换

4858.com, \当要求替换2个字符串的时候,使用
sub*

import re
ret = re.sub('\d','H','even3root4time5',1)  #将数字替换成'H',参数1表示只替换一个
print(ret)

#显示结果:evenHroot4time5

 

subn

轮换,次数,并重返元组

import re
ret = re.subn('\d','H','even3root4time5')   #将数字替换成'H',返回元组(替换的结果,替换了多少次)
print(ret)

#显示结果:('evenHrootHtimeH', 3)

 

compile

编译

 \当一条正则规则供给反复使用,且该正则规则长度相当短的时候使用
compile*

import re

obj = re.compile('\d{3}')
#将正则表达式编译成为一个正则表达式对象,规则是匹配三个数字

ret = obj.search('abc123root')    #正则表达式调用search
print(ret.group())
ret = obj.search('456abc123')
print(ret.group())

#显示结果:
#123
#456    

 

finditer

迭代

 \节约内存,当须求找的东西越来越多,又力不从心整体放进内部存款和储蓄器的时候,使用
finditer*

import re

ret = re.finditer('\d','ds3sy7895a')    #finditer返回一个存放匹配结果的迭代器,返回的变量需要调用group才能拿到结果
print(ret)
print(next(ret).group())    #查看第一个结果
print(next(ret).group())    #查看第二个结果
print([i.group()for i in ret])  #查看剩余的结果

 

  相称全体,每1项都以列表的3个因素

group 分组 和 分组优先机制

正则分组:去已经提取到的数量中再领取数据

group 是 Python 的 group 机制

分组正是把正则式已经万分到的结果,再去做3遍相配

 

在 search 中的示例:

4858.com 54858.com 6

import re

ret = re.search('^[1-9](\d{14})(\d{2}[0-9xX])?$','50010119990111000X')
print(ret.group())
print(ret.group(1))
print(ret.group(2))

#显示结果:
#50010119990111000X
#00101199901110
#00X

search钟的group分组机制示例

 

在 findall
当中的吊销分组优先机制,?:

4858.com 74858.com 8

import re

ret = re.findall('www.(baidu|even).com','www.even.com')      #因为findall会优先把匹配结果组里的内容返回,如果想要匹配结果,就要进行取消分组优先
print(ret)        

ret = re.findall('www.(?:baidu|even).com','www.even.com')    #取消分组优先之后
print(ret)

#显示结果:
#['even']
#['www.even.com']

finadall中的打消分组优先机制?:

 

在 split 中的示例:

4858.com 94858.com 10

import re

ret = re.split("\d+",'even3root4hello')
print(ret)

ret = re.split("(\d+)",'even3root4hello')    #在匹配部分加上()之后切割出的结果是不一样的
print(ret) 

#即没有()的不保留所匹配的项,有()的能够保留匹配的项
#因为某些情况下需要保留匹配项

#显示结果:
#['even', 'root', 'hello']
#['even', '3', 'root', '4', 'hello']

split中的分组示例

 

  findall(正则表达式,待相称的字符串)将满足相配原则的结果放到列表里

import re
s = "kuci花13买了一瓶82年的矿泉水"
ret = re.findall("\d+",s)
ret1 = re.findall("[0-9A-Za-z]+",s)
print(ret)
print(ret1)

4858.com 11

 

group()  groups()  和  groupdict()

group()        #获取匹配到的所有结果
groups()      #获取模型中匹配到的分组结果
groupdict()  #获取模型中匹配到的分组结果(自定义key名称)

import re
origin = "has abcedroot2003"
r = re.match("h\w+",origin)

print(r.group())
print(r.groups())
print(r.groupdict())

#输出结果
#has
#()
#{}

import re
origin = "has abcedroot2003"
r = re.match("h(\w+)",origin)

print(r.group())
print(r.groups())
print(r.groupdict())

#输出结果
#has
#('as',)
#{}

import re
origin = "has abcedroot2003"
r = re.match("h(?P<name>\w+)",origin)    #自定义key名称,匹配得到字典

print(r.group())
print(r.groups())
print(r.groupdict())

#输出结果
#has
#('as',)
#{'name': 'as'}

 

二丶search

爬虫示例

4858.com 124858.com 13

import re
import json
from urllib.request import urlopen

def getPage(url):
    response = urlopen(url)
    return response.read().decode('utf-8')

def parsePage(s):
    com = re.compile(
        '<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?(?P<title>.*?)'
        '.*?(?P<rating_num>.*?).*?(?P<comment_num>.*?)评价', re.S)

    ret = com.finditer(s)
    for i in ret:
        yield {
            "id": i.group("id"),
            "title": i.group("title"),
            "rating_num": i.group("rating_num"),
            "comment_num": i.group("comment_num"),
        }


def main(num):
    url = 'https://movie.douban.com/top250?start=%s&filter=' % num
    response_html = getPage(url)
    ret = parsePage(response_html)
    print(ret)
    f = open("move_info7", "a", encoding="utf8")

    for obj in ret:
        print(obj)
        data = str(obj)
        f.write(data + "\n")

count = 0
for i in range(10):
    main(count)
    count += 25

行使正则原理的爬虫示例

  只10分从左到右的首先个,获得的不是从来的结果,而是1个变量,通过这几个变量的group方法来取得结果

s = "kuci花13买了一瓶82年的矿泉水"
ret = re.search("\d+",s)
print(ret)      #返回的是变量   <_sre.SRE_Match object; span=(5, 7), match='13'>
print(ret.group())      #返回结果  13

 

  假设未有相称到,则会回来None,使用group会报错

s = "kuci花13买了一瓶82年的矿泉水"
ret = re.search("\b+",s)
print(ret)
print(ret.group())

4858.com 14

 

三丶match

  从头发轫相配,相当于search中的表明式加上贰个^,结果是千篇一律的

ret = re.match("[A-Za-z]+","kuqi的导弹zong是到处乱飞")
print(ret)      #<_sre.SRE_Match object; span=(0, 4), match='kuqi'>
print(ret.group())      #kuqi

ret2 = re.search("^[A-Za-z]+","kuqi的导弹zong是到处乱飞")
print(ret2)     #<_sre.SRE_Match object; span=(0, 4), match='kuqi'>
print(ret2.group())     #kuqi

 

 

4丶字符串管理的扩充:替换丶切割

  split:

# split
s = "哪吒|金吒|木吒|"
print(s.split("|"))     #['哪吒', '金吒', '木吒', '']
s = "衣服82鞋子42裤子49"
ret = re.split("\d+",s) #['衣服', '鞋子', '裤子', '']
print(ret)

 

  sub/subn:

# sub
#sub (所要替换的内容,替换成的内容,所要替换的字符串,替换的次数(默认为全部))
ret = re.sub("\d","A","99dasdasdml6346vasd")
ret1 = re.sub("\d","A","99dasdasdml6346vasd",2)
print(ret)      #AAdasdasdmlAAAAvasd
print(ret1)     #AAdasdasdml6346vasd

#subn
#返回一个元组,返回结果的第二个元素是替换的次数
ret2 = re.subn("\d","A","99dasdasdml6346vasd")
print(ret2)     #('AAdasdasdmlAAAAvasd', 6)

 

 

5丶re模块的进阶:时间/空间

  compile:

    节省你利用正则说明式化解难点的时日

    将正则表达式编写翻译成字节码,在频仍用到的经过中,不会反复编写翻译

ret = re.compile("\d+")  #已经完成编译了
print(ret)      #re.compile('\\d+')
res = ret.findall("kuqi花13买了一瓶82年的矿泉水")
print(res)      #['13', '82']
res = ret.search('kuqi花13买了一瓶82年的矿泉水')
print(res.group())      #13

  finditer:

    节省你接纳正则表明式消除难点的空中/内部存款和储蓄器

ret = re.finditer("\d+","diaf646afaf464afa6264yy42g424u")#返回一个迭代器
print(ret)          #<callable_iterator object at 0x00000220CCDAA978>
print(next(ret).group())    #查看第一个结果  646
print(next(ret).group())    #查看第二个结果  464
print([i.group() for i in ret])     #查看剩余所有结果  ['6264', '42', '424']

 

 

 陆丶分组在re模块中的使用

  对李碧华则表明式来讲,有个别时候大家必要张开分组,来完全约束y壹组字符出现的次数

import re
s = '<a>wahaha</a>'  # 标签语言 html 网页
ret = re.search('<(\w+)>(\w+)</(\w+)>',s)
print(ret.group())  # 所有的结果
print(ret.group(1)) # 数字参数代表的是取对应分组中的内容  a
print(ret.group(2)) #wahaha
print(ret.group(3)) #a

# 为了findall也可以顺利取到分组中的内容,有一个特殊的语法,就是优先显示分组中的内容
ret = re.findall('(\w+)',s)
print(ret)      #['a', 'wahaha', 'a']
ret = re.findall('>(\w+)<',s)
print(ret)      #['wahaha']

# 取消分组优先(?:正则表达式)
ret = re.findall('\d+(?:\.\d+)?','1.234*4') #['1.234', '4']
ret1 = re.findall('\d+(\.\d+)?','1.234*4')  #['.234', '']
print(ret)
print(ret1)

# 分组命名 (?P<这个组的名字>正则表达式)
s = '<a>wahaha</a>'
ret = re.search('>(?P<con>\w+)<',s)
print(ret.group(1))
print(ret.group('con'))
# 使用前面的分组 要求使用这个名字的分组和前面同名分组中的内容匹配的必须一致
pattern = '<(?P<tab>\w+)>(\w+)</(?P=tab)>'
ret = re.search(pattern,s)
print(ret)

# 精准的取到整数 过滤掉小数
ret=re.findall(r"\d+\.\d+|\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret)
#['1', '2', '60', '40.35', '5', '4', '3']
ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")
ret.remove('') #将""删掉
print(ret)
#['1', '2', '60', '5', '4', '3']

 

7丶爬虫实例

4858.com 154858.com 16

import re
from urllib.request import urlopen

def getPage(url):   # 获取网页的字符串
    response = urlopen(url)
    return response.read().decode('utf-8')

def parsePage(s):
    ret = com.finditer(s)  # 从s这个网页源码中 找到所有符合com正则表达式规则的内容 并且以迭代器的形式返回
    for i in ret:
        yield {
            "id": i.group("id"),
            "title": i.group("title"),
            "rating_num": i.group("rating_num"),
            "comment_num": i.group("comment_num"),
        }

def main(num):  # 0  25 50  # 这个函数执行10次,每次爬取一页的内容
    url = 'https://movie.douban.com/top250?start=%s&filter=' % num
    response_html = getPage(url)   # response_html就是这个url对应的html代码 就是 str
    ret = parsePage(response_html) # ret是一个生成器
    print(ret)
    f = open("move_info7", "a", encoding="utf8")
    for obj in ret:
        print(obj)
        data = str(obj)
        f.write(data + "\n")
    f.close()

com = re.compile(
        '<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?(?P<title>.*?)'
        '.*?(?P<rating_num>.*?).*?(?P<comment_num>.*?)评价', re.S)

count = 0
for i in range(10):
    main(count)
    count += 25

爬虫实例

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有