非结构化数据和结构化数据提取
页面解析和数据提取
一般来讲对我们而言,需要抓取的是某个网站或者某个应用的内容,提取有用的价值。内容一般分为两部分,非结构化的数据 和 结构化的数据。
- 非结构化数据:先有数据,再有结构,
- 结构化数据:先有结构、再有数据
- 不同类型的数据,我们需要采用不同的方式来处理。
非结构化的数据处理
文本、电话号码、邮箱地址
- 正则表达式
HTML 文件
- 正则表达式
- XPath
- CSS选择器
结构化的数据处理
JSON 文件
- JSON Path
- 转化成Python类型进行操作(json类)
XML 文件
- 转化成Python类型(xmltodict)
- XPath
- CSS选择器
- 正则表达式
为什么要学正则表达式
实际上爬虫一共就四个主要步骤:
- 明确目标 (要知道你准备在哪个范围或者网站去搜索)
- 爬 (将所有的网站的内容全部爬下来)
- 取 (去掉对我们没用处的数据)
- 处理数据(按照我们想要的方式存储和使用)
我们在昨天的案例里实际上省略了第3步,也就是"取"的步骤。因为我们down下了的数据是全部的网页,这些数据很庞大并且很混乱,大部分的东西使我们不关心的,因此我们需要将之按我们的需要过滤和匹配出来。
那么对于文本的过滤或者规则的匹配,最强大的就是正则表达式,是Python爬虫世界里必不可少的神兵利器。
什么是正则表达式
正则表达式,又称规则表达式,通常被用来检索、替换那些符合某个模式(规则)的文本。
正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。
给定一个正则表达式和另一个字符串,我们可以达到如下的目的:
- 给定的字符串是否符合正则表达式的过滤逻辑(“匹配”);
- 通过正则表达式,从文本字符串中获取我们想要的特定部分(“过滤”)。
正则表达式匹配规则
Python 的 re 模块
在 Python 中,我们可以使用内置的 re 模块来使用正则表达式。
有一点需要特别注意的是,正则表达式使用 对特殊字符进行转义,所以如果我们要使用原始字符串,只需加一个 r 前缀,示例:
r'chuanzhiboke\t\.\tpython'
re 模块的一般使用步骤如下:
使用
compile()
函数将正则表达式的字符串形式编译为一个Pattern
对象通过
Pattern
对象提供的一系列方法对文本进行匹配查找,获得匹配结果,一个 Match 对象。- 最后使用
Match
对象提供的属性和方法获得信息,根据需要进行其他的操作
compile 函数
compile 函数用于编译正则表达式,生成一个 Pattern 对象,它的一般使用形式如下:
import re# 将正则表达式编译成 Pattern 对象 pattern = re.compile(r'\d+')
在上面,我们已将一个正则表达式编译成 Pattern 对象,接下来,我们就可以利用 pattern 的一系列方法对文本进行匹配查找了。
Pattern 对象的一些常用方法主要有:
- match 方法:从起始位置开始查找,一次匹配
- search 方法:从任何位置开始查找,一次匹配
- findall 方法:全部匹配,返回列表
- finditer 方法:全部匹配,返回迭代器
- split 方法:分割字符串,返回列表
- sub 方法:替换
match 方法
match 方法用于查找字符串的头部(也可以指定起始位置),它是一次匹配,只要找到了一个匹配的结果就返回,而不是查找所有匹配的结果。它的一般使用形式如下:
match(string[, pos[, endpos]])
其中,string 是待匹配的字符串,pos 和 endpos 是可选参数,指定字符串的起始和终点位置,默认值分别是 0 和 len (字符串长度)。因此,当你不指定 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 at 0x10a42aac0>
>>> m.group(0) # 可省略 0
'12'
>>> m.start(0) # 可省略 0
3
>>> m.end(0) # 可省略 0
5
>>> m.span(0) # 可省略 0
(3, 5)
在上面,当匹配成功时返回一个 Match 对象,其中:
group([group1, …]) 方法用于获得一个或多个分组匹配的字符串,当要获得整个匹配的子串时,可直接使用 group() 或 group(0);
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置(子串第一个字符的索引),参数默认值为 0;
- end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置(子串最后一个字符的索引+1),参数默认值为 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 at 0x10bea83e8>
>>> m.group(0) # 返回匹配成功的整个子串
'Hello World'
>>> m.span(0) # 返回匹配成功的整个子串的索引
(0, 11)
>>> m.group(1) # 返回第一个分组匹配成功的子串
'Hello'
>>> m.span(1) # 返回第一个分组匹配成功的子串的索引
(0, 5)
>>> m.group(2) # 返回第二个分组匹配成功的子串
'World'
>>> m.span(2) # 返回第二个分组匹配成功的子串
(6, 11)
>>> m.groups() # 等价于 (m.group(1), m.group(2), ...)
('Hello', 'World')
>>> m.group(3) # 不存在第三个分组
Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: no such group
------------------------------------------------------------------------------------------------------
search 方法
search 方法用于查找字符串的任何位置,它也是一次匹配,只要找到了一个匹配的结果就返回,而不是查找所有匹配的结果,它的一般使用形式如下:
search(string[, pos[, endpos]])
其中,string 是待匹配的字符串,pos 和 endpos 是可选参数,指定字符串的起始和终点位置,默认值分别是 0 和 len (字符串长度)。
当匹配成功时,返回一个 Match 对象,如果没有匹配上,则返回 None。
让我们看看例子:
>>> import re >>> pattern = re.compile('\d+') >>> m = pattern.search('one12twothree34four') # 这里如果使用 match 方法则不匹配 >>> m <_sre.SRE_Match object at 0x10cc03ac0> >>> m.group() '12' >>> m = pattern.search('one12twothree34four', 10, 30) # 指定字符串区间 >>> m <_sre.SRE_Match object at 0x10cc03b28> >>> m.group() '34' >>> m.span() (13, 15)
再来看一个例子:
# -*- coding: utf-8 -*-import re # 将正则表达式编译成 Pattern 对象 pattern = re.compile(r'\d+') # 使用 search() 查找匹配的子串,不存在匹配的子串时将返回 None # 这里使用 match() 无法成功匹配 m = pattern.search('hello 123456 789') if m:# 使用 Match 获得分组信息print 'matching string:',m.group()# 起始位置和结束位置print 'position:',m.span()
执行结果:
matching string: 123456 position: (6, 12)
------------------------------------------------------------------------------------------------------
findall 方法
上面的 match 和 search 方法都是一次匹配,只要找到了一个匹配的结果就返回。然而,在大多数时候,我们需要搜索整个字符串,获得所有匹配的结果。
findall 方法的使用形式如下:
findall(string[, pos[, endpos]])
其中,string 是待匹配的字符串,pos 和 endpos 是可选参数,指定字符串的起始和终点位置,默认值分别是 0 和 len (字符串长度)。
findall 以列表形式返回全部能匹配的子串,如果没有匹配,则返回一个空列表。
看看例子:
import re pattern = re.compile(r'\d+') # 查找数字result1 = pattern.findall('hello 123456 789') result2 = pattern.findall('one1two2three3four4', 0, 10)print result1 print result2
执行结果:
['123456', '789'] ['1', '2']
再先看一个栗子:
# re_test.pyimport re#re模块提供一个方法叫compile模块,提供我们输入一个匹配的规则 #然后返回一个pattern实例,我们根据这个规则去匹配字符串 pattern = re.compile(r'\d+\.\d*')#通过partten.findall()方法就能够全部匹配到我们得到的字符串 result = pattern.findall("123.141593, 'bigcat', 232312, 3.15")#findall 以 列表形式 返回全部能匹配的子串给result for item in result:print item
运行结果:
123.141593 3.15
------------------------------------------------------------------------------------------------------
finditer 方法
finditer 方法的行为跟 findall 的行为类似,也是搜索整个字符串,获得所有匹配的结果。但它返回一个顺序访问每一个匹配结果(Match 对象)的迭代器。
看看例子:
# -*- coding: utf-8 -*-import re pattern = re.compile(r'\d+')result_iter1 = pattern.finditer('hello 123456 789') result_iter2 = pattern.finditer('one1two2three3four4', 0, 10)print type(result_iter1) print type(result_iter2)print 'result1...' for m1 in result_iter1: # m1 是 Match 对象print 'matching string: {}, position: {}'.format(m1.group(), m1.span())print 'result2...' for m2 in result_iter2:print 'matching string: {}, position: {}'.format(m2.group(), m2.span())
执行结果:
<type 'callable-iterator'> <type 'callable-iterator'> result1... matching string: 123456, position: (6, 12) matching string: 789, position: (13, 16) result2... matching string: 1, position: (3, 4) matching string: 2, position: (7, 8)
------------------------------------------------------------------------------------------------------
split 方法
split 方法按照能够匹配的子串将字符串分割后返回列表,它的使用形式如下:
split(string[, maxsplit])
其中,maxsplit 用于指定最大分割次数,不指定将全部分割。
看看例子:
import re p = re.compile(r'[\s\,\;]+') print p.split('a,b;; c d')
执行结果:
['a', 'b', 'c', 'd']
------------------------------------------------------------------------------------------------------
sub 方法
sub 方法用于替换。它的使用形式如下:
sub(repl, string[, count])
其中,repl 可以是字符串也可以是一个函数:
如果 repl 是字符串,则会使用 repl 去替换字符串每一个匹配的子串,并返回替换后的字符串,另外,repl 还可以使用 id 的形式来引用分组,但不能使用编号 0;
如果 repl 是函数,这个方法应当只接受一个参数(Match 对象),并返回一个字符串用于替换(返回的字符串中不能再引用分组)。
- count 用于指定最多替换次数,不指定时全部替换。
看看例子:
import re p = re.compile(r'(\w+) (\w+)') # \w = [A-Za-z0-9] s = 'hello 123, hello 456'print p.sub(r'hello world', s) # 使用 'hello world' 替换 'hello 123' 和 'hello 456' print p.sub(r'\2 \1', s) # 引用分组def func(m):return 'hi' + ' ' + m.group(2)print p.sub(func, s) print p.sub(func, s, 1) # 最多替换一次
执行结果:
hello world, hello world 123 hello, 456 hello hi 123, hi 456 hi 123, hello 456
------------------------------------------------------------------------------------------------------
匹配中文
在某些情况下,我们想匹配文本中的汉字,有一点需要注意的是,中文的 unicode 编码范围 主要在 [u4e00-u9fa5],这里说主要是因为这个范围并不完整,比如没有包括全角(中文)标点,不过,在大部分情况下,应该是够用的。
假设现在想把字符串 title = u'你好,hello,世界' 中的中文提取出来,可以这么做:
import retitle = u'你好,hello,世界' pattern = re.compile(ur'[\u4e00-\u9fa5]+') result = pattern.findall(title)print result
注意到,我们在正则表达式前面加上了两个前缀 ur,其中 r 表示使用原始字符串,u 表示是 unicode 字符串。
执行结果:
[u'\u4f60\u597d', u'\u4e16\u754c']
注意:贪婪模式与非贪婪模式
- 贪婪模式:在整个表达式匹配成功的前提下,尽可能多的匹配 ( * );
- 非贪婪模式:在整个表达式匹配成功的前提下,尽可能少的匹配 ( ? );
- Python里数量词默认是贪婪的。
示例一 : 源字符串:abbbc
- 使用贪婪的数量词的正则表达式
ab*
,匹配结果: abbb。*
决定了尽可能多匹配 b,所以a后面所有的 b 都出现了。
- 使用非贪婪的数量词的正则表达式
ab*?
,匹配结果: a。即使前面有
*
,但是?
决定了尽可能少匹配 b,所以没有 b。
示例二 : 源字符串:aa<div>test1</div>bb<div>test2</div>cc
使用贪婪的数量词的正则表达式:
<div>.*</div>
匹配结果:
<div>test1</div>bb<div>test2</div>
这里采用的是贪婪模式。在匹配到第一个“
</div>
”时已经可以使整个表达式匹配成功,但是由于采用的是贪婪模式,所以仍然要向右尝试匹配,查看是否还有更长的可以成功匹配的子串。匹配到第二个“</div>
”后,向右再没有可以成功匹配的子串,匹配结束,匹配结果为“<div>test1</div>bb<div>test2</div>
”
使用非贪婪的数量词的正则表达式:
<div>.*?</div>
匹配结果:
<div>test1</div>
正则表达式二采用的是非贪婪模式,在匹配到第一个“
</div>
”时使整个表达式匹配成功,由于采用的是非贪婪模式,所以结束匹配,不再向右尝试,匹配结果为“<div>test1</div>
”。
正则表达式测试网址
案例:使用正则表达式的爬虫
现在拥有了正则表达式这把神兵利器,我们就可以进行对爬取到的全部网页源代码进行筛选了。
下面我们一起尝试一下爬取内涵段子网站: http://www.neihan8.com/article/list_5_1.html
打开之后,不难看到里面一个一个灰常有内涵的段子,当你进行翻页的时候,注意url地址的变化:
第一页url: http: //www.neihan8.com/article/list_5_1 .html
第二页url: http: //www.neihan8.com/article/list_5_2 .html
第三页url: http: //www.neihan8.com/article/list_5_3 .html
第四页url: http: //www.neihan8.com/article/list_5_4 .html
这样我们的url规律找到了,要想爬取所有的段子,只需要修改一个参数即可。 下面我们就开始一步一步将所有的段子爬取下来吧。
第一步:获取数据
1. 按照我们之前的用法,我们需要写一个加载页面的方法。
这里我们统一定义一个类,将url请求作为一个成员方法处理。
我们创建一个文件,叫duanzi_spider.py
然后定义一个Spider类,并且添加一个加载页面的成员方法
import urllib2class Spider:"""内涵段子爬虫类"""def loadPage(self, page):"""@brief 定义一个url请求网页的方法@param page 需要请求的第几页@returns 返回的页面html"""url = "http://www.neihan8.com/article/list_5_" + str(page) + ".html"#User-Agent头user_agent = 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0'headers = {'User-Agent': user_agent}req = urllib2.Request(url, headers = headers)response = urllib2.urlopen(req)html = response.read()print html#return html
以上的loadPage的实现体想必大家应该很熟悉了,需要注意定义python类的成员方法需要额外添加一个参数self
.
那么loadPage(self, page) 中的page是我们指定去请求第几页。
最后通过 print html打印到屏幕上。
然后我们写一个main函数见到测试一个loadPage方法
2. 写main函数测试一个loadPage方法
if __name__ == '__main__':"""======================内涵段子小爬虫======================"""print '请按下回车开始'raw_input()#定义一个Spider对象mySpider = Spider()mySpider.loadpage(1)
程序正常执行的话,我们会在屏幕上打印了内涵段子第一页的全部html代码。 但是我们发现,html中的中文部分显示的可能是乱码 。
那么我们需要简单的将得到的网页源代码处理一下:
def loadPage(self, page):"""@brief 定义一个url请求网页的方法@param page 需要请求的第几页@returns 返回的页面html"""url = "http://www.neihan8.com/article/list_5_" + str(page) + ".html"#User-Agent头user_agent = 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0'headers = {'User-Agent': user_agent}req = urllib2.Request(url, headers = headers)response = urllib2.urlopen(req)html = response.read()gbk_html = html.decode('gbk').encode('utf-8')# print gbk_htmlreturn gbk_html
注意 :对于每个网站对中文的编码各自不同,所以html.decode(‘gbk’)的写法并不是通用写法,根据网站的编码而异
这样我们再次执行以下duanzi_spider.py ,会发现之前的中文乱码可以正常显示了。
第二步:筛选数据
接下来我们已经得到了整个页面的数据。 但是,很多内容我们并不关心,所以下一步我们需要进行筛选。 如何筛选,就用到了上一节讲述的正则表达式。
- 首先
import re
- 然后, 在我们得到的
gbk_html
中进行筛选匹配。
我们需要一个匹配规则:
我们可以打开内涵段子的网页,鼠标点击右键 “ 查看源代码 ” 你会惊奇的发现,我们需要的每个段子的内容都是在一个
<div>
标签中,而且每个div
都有一个属性class = "f18 mb20"
所以,我们只需要匹配到网页中所有
<div class="f18 mb20">
到</div>
的数据就可以了。
根据正则表达式,我们可以推算出一个公式是:
<div.*?class="f18 mb20">(.*?)</div>
这个表达式实际上就是匹配到所有
div
中class="f18 mb20
里面的内容(具体可以看前面正则介绍)然后将这个正则应用到代码中,我们会得到以下代码:
def loadPage(self, page):"""@brief 定义一个url请求网页的方法@param page 需要请求的第几页@returns 返回的页面html"""url = "http://www.neihan8.com/article/list_5_" + str(page) + ".html"#User-Agent头user_agent = 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT
6.1; Trident/5.0'headers = {'User-Agent': user_agent}req = urllib2.Request(url, headers = headers)response = urllib2.urlopen(req)html = response.read()gbk_html = html.decode('gbk').encode('utf-8')#找到所有的段子内容<div class = "f18 mb20"></div>#re.S 如果没有re.S 则是只匹配一行有没有符合规则的字符串,如果没有则下一行重新匹配# 如果加上re.S 则是将所有的字符串将一个整体进行匹配pattern = re.compile(r'<div.*?class="f18 mb20">(.*?)</di v>', re.S)item_list = pattern.findall(gbk_html)return item_listdef printOnePage(self, item_list, page):"""@brief 处理得到的段子列表@param item_list 得到的段子列表@param page 处理第几页"""print "******* 第 %d 页 爬取完毕...*******" %pagefor item in item_list:print "================"print ite
这里需要注意一个是
re.S
是正则表达式中匹配的一个参数。如果 没有re.S 则是 只匹配一行 有没有符合规则的字符串,如果没有则下一行重新匹配。
- 如果 加上re.S 则是将 所有的字符串 将一个整体进行匹配,findall 将所有匹配到的结果封装到一个list中。
- 然后我们写了一个遍历
item_list
的一个方法printOnePage()
。 ok程序写到这,我们再一次执行一下。
Power@PowerMac ~$ python duanzi_spider.py
我们第一页的全部段子,不包含其他信息全部的打印了出来。
- 你会发现段子中有很多
<p>
,</p>
很是不舒服,实际上这个是html的一种段落的标签。 在浏览器上看不出来,但是如果按照文本打印会有
<p>
出现,那么我们只需要把我们不希望的内容去掉即可了。我们可以如下简单修改一下 printOnePage().
def printOnePage(self, item_list, page):"""@brief 处理得到的段子列表@param item_list 得到的段子列表@param page 处理第几页"""print "******* 第 %d 页 爬取完毕...*******" %pagefor item in item_list:print "================"item = item.replace("<p>", "").replace("</p>", "").repl ace("<br />", "")print item
第三步:保存数据
- 我们可以将所有的段子存放在文件中。比如,我们可以将得到的每个item不是打印出来,而是存放在一个叫 duanzi.txt 的文件中也可以。
def writeToFile(self, text): '''@brief 将数据追加写进文件中@param text 文件内容 '''myFile = open("./duanzi.txt", 'a') #追加形式打开文件myFile.write(text)myFile.write("--------------------------------------------- --------")myFile.close()
- 然后我们将print的语句 改成
writeToFile()
,当前页面的所有段子就存在了本地的MyStory.txt文件中。
def printOnePage(self, item_list, page): '''@brief 处理得到的段子列表@param item_list 得到的段子列表@param page 处理第几页 '''print "******* 第 %d 页 爬取完毕...*******" %pagefor item in item_list:# print "================"item = item.replace("<p>", "").replace("</p>", "").repl ace("<br />", "")# print itemself.writeToFile(item)
第四步:显示数据
接下来我们就通过参数的传递对page进行叠加来遍历 内涵段子吧的全部段子内容。
只需要在外层加一些逻辑处理即可。
def doWork(self): '''让爬虫开始工作 '''while self.enable:try:item_list = self.loadPage(self.page)except urllib2.URLError, e:print e.reasoncontinue#对得到的段子item_list处理self.printOnePage(item_list, self.page)self.page += 1 #此页处理完毕,处理下一页print "按回车继续..."print "输入 quit 退出"command = raw_input()if (command == "quit"):self.enable = Falsebreak
- 最后,我们执行我们的代码,完成后查看当前路径下的duanzi.txt文件,里面已经有了我们要的内涵段子。
以上便是一个非常精简使用的小爬虫程序,使用起来很是方便,如果想要爬取其他网站的信息,只需要修改其中某些参数和一些细节就行了。
有同学说,我正则用的不好,处理HTML文档很累,有没有其他的方法?
有!那就是XPath,我们可以先将 HTML文件 转换成 XML文档,然后用 XPath 查找 HTML 节点或元素。
什么是XML
- XML 指可扩展标记语言(EXtensible Markup Language)
- XML 是一种标记语言,很类似 HTML
- XML 的设计宗旨是传输数据,而非显示数据
- XML 的标签需要我们自行定义。
- XML 被设计为具有自我描述性。
- XML 是 W3C 的推荐标准
W3School官方文档:http://www.w3school.com.cn/xml/index.asp
XML 和 HTML 的区别
数据格式 | 描述 | 设计目标 |
---|---|---|
XML |
Extensible Markup Language (可扩展标记语言)
|
被设计为传输和存储数据,其焦点是数据的内容。 |
HTML |
HyperText Markup Language (超文本标记语言)
|
显示数据以及如何更好显示数据。 |
HTML DOM |
Document Object Model for HTML (文档对象模型)
|
通过 HTML DOM,可以访问所有的 HTML 元素,连同它们所包含的文本和属性。可以对其中的内容进行修改和删除,同时也可以创建新的元素。 |
XML文档示例
<?xml version="1.0" encoding="utf-8"?><bookstore> <book category="cooking"> <title lang="en">Everyday Italian</title> <author>Giada De Laurentiis</author> <year>2005</year> <price>30.00</price> </book> <book category="children"> <title lang="en">Harry Potter</title> <author>J K. Rowling</author> <year>2005</year> <price>29.99</price> </book> <book category="web"> <title lang="en">XQuery Kick Start</title> <author>James McGovern</author> <author>Per Bothner</author> <author>Kurt Cagle</author> <author>James Linn</author> <author>Vaidyanathan Nagarajan</author> <year>2003</year> <price>49.99</price> </book> <book category="web" cover="paperback"> <title lang="en">Learning XML</title> <author>Erik T. Ray</author> <year>2003</year> <price>39.95</price> </book> </bookstore>
HTML DOM 模型示例
HTML DOM 定义了访问和操作 HTML 文档的标准方法,以树结构方式表达 HTML 文档。
XML的节点关系
1. 父(Parent)
每个元素以及属性都有一个父。
下面是一个简单的XML例子中,book 元素是 title、author、year 以及 price 元素的父:
<?xml version="1.0" encoding="utf-8"?><book><title>Harry Potter</title><author>J K. Rowling</author><year>2005</year><price>29.99</price> </book>
2. 子(Children)
元素节点可有零个、一个或多个子。
在下面的例子中,title、author、year 以及 price 元素都是 book 元素的子:
<?xml version="1.0" encoding="utf-8"?><book><title>Harry Potter</title><author>J K. Rowling</author><year>2005</year><price>29.99</price> </book>
3. 同胞(Sibling)
拥有相同的父的节点
在下面的例子中,title、author、year 以及 price 元素都是同胞:
<?xml version="1.0" encoding="utf-8"?><book><title>Harry Potter</title><author>J K. Rowling</author><year>2005</year><price>29.99</price> </book>
4. 先辈(Ancestor)
某节点的父、父的父,等等。
在下面的例子中,title 元素的先辈是 book 元素和 bookstore 元素:
<?xml version="1.0" encoding="utf-8"?><bookstore><book><title>Harry Potter</title><author>J K. Rowling</author><year>2005</year><price>29.99</price> </book></bookstore>
5. 后代(Descendant)
某个节点的子,子的子,等等。
在下面的例子中,bookstore 的后代是 book、title、author、year 以及 price 元素:
<?xml version="1.0" encoding="utf-8"?><bookstore><book><title>Harry Potter</title><author>J K. Rowling</author><year>2005</year><price>29.99</price> </book></bookstore>
什么是XPath?
XPath (XML Path Language) 是一门在 XML 文档中查找信息的语言,可用来在 XML 文档中对元素和属性进行遍历。
W3School官方文档:http://www.w3school.com.cn/xpath/index.asp
XPath 开发工具
- 开源的XPath表达式编辑工具:XMLQuire(XML格式文件可用)
- Chrome插件 XPath Helper
- Firefox插件 XPath Checker
选取节点
XPath 使用路径表达式来选取 XML 文档中的节点或者节点集。这些路径表达式和我们在常规的电脑文件系统中看到的表达式非常相似。
下面列出了最常用的路径表达式:
表达式 | 描述 |
---|---|
nodename | 选取此节点的所有子节点。 |
/ | 从根节点选取。 |
// | 从匹配选择的当前节点选择文档中的节点,而不考虑它们的位置。 |
. | 选取当前节点。 |
.. | 选取当前节点的父节点。 |
@ | 选取属性。 |
在下面的表格中,我们已列出了一些路径表达式以及表达式的结果:
路径表达式 | 结果 | |
---|---|---|
bookstore | 选取 bookstore 元素的所有子节点。 | |
/bookstore | 选取根元素 bookstore。注释:假如路径起始于正斜杠( / ),则此路径始终代表到某元素的绝对路径! | |
bookstore/book | 选取属于 bookstore 的子元素的所有 book 元素。 | |
//book | 选取所有 book 子元素,而不管它们在文档中的位置。 | |
bookstore//book | 选择属于 bookstore 元素的后代的所有 book 元素,而不管它们位于 bookstore 之下的什么位置。 | |
//@lang | 选取名为 lang 的所有属性。 |
谓语(Predicates)
谓语用来查找某个特定的节点或者包含某个指定的值的节点,被嵌在方括号中。
在下面的表格中,我们列出了带有谓语的一些路径表达式,以及表达式的结果:
路径表达式 | 结果 |
---|---|
/bookstore/book[1] | 选取属于 bookstore 子元素的第一个 book 元素。 |
/bookstore/book[last()] | 选取属于 bookstore 子元素的最后一个 book 元素。 |
/bookstore/book[last()-1] | 选取属于 bookstore 子元素的倒数第二个 book 元素。 |
/bookstore/book[position()<3] | 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。 |
//title[@lang] | 选取所有拥有名为 lang 的属性的 title 元素。 |
//title[@lang=’eng’] | 选取所有 title 元素,且这些元素拥有值为 eng 的 lang 属性。 |
/bookstore/book[price>35.00] | 选取 bookstore 元素的所有 book 元素,且其中的 price 元素的值须大于 35.00。 |
/bookstore/book[price>35.00]/title | 选取 bookstore 元素中的 book 元素的所有 title 元素,且其中的 price 元素的值须大于 35.00。 |
选取未知节点
XPath 通配符可用来选取未知的 XML 元素。
通配符 | 描述 |
---|---|
* | 匹配任何元素节点。 |
@* | 匹配任何属性节点。 |
node() | 匹配任何类型的节点。 |
在下面的表格中,我们列出了一些路径表达式,以及这些表达式的结果:
路径表达式 | 结果 |
---|---|
/bookstore/* | 选取 bookstore 元素的所有子元素。 |
//* | 选取文档中的所有元素。 |
//title[@*] | 选取所有带有属性的 title 元素。 |
选取若干路径
通过在路径表达式中使用“|”运算符,您可以选取若干个路径。
实例
在下面的表格中,我们列出了一些路径表达式,以及这些表达式的结果:
路径表达式 | 结果 |
---|---|
//book/title | //book/price | 选取 book 元素的所有 title 和 price 元素。 |
//title | //price | 选取文档中的所有 title 和 price 元素。 |
/bookstore/book/title | //price | 选取属于 bookstore 元素的 book 元素的所有 title 元素,以及文档中所有的 price 元素。 |
XPath的运算符
下面列出了可用在 XPath 表达式中的运算符:
这些就是XPath的语法内容,在运用到Python抓取时要先转换为xml。
lxml库
lxml 是 一个HTML/XML的解析器,主要的功能是如何解析和提取 HTML/XML 数据。
lxml和正则一样,也是用 C 实现的,是一款高性能的 Python HTML/XML 解析器,我们可以利用之前学习的XPath语法,来快速的定位特定元素以及节点信息。
lxml python 官方文档:http://lxml.de/index.html
需要安装C语言库,可使用 pip 安装:
pip install lxml
(或通过wheel方式安装)
初步使用
我们利用它来解析 HTML 代码,简单示例:
# lxml_test.py# 使用 lxml 的 etree 库 from lxml import etree text = ''' <div><ul><li class="item-0"><a href="link1.html">first item</a></li><li class="item-1"><a href="link2.html">second item</a></li><li class="item-inactive"><a href="link3.html">third item</a></li><li class="item-1"><a href="link4.html">fourth item</a></li><li class="item-0"><a href="link5.html">fifth item</a> # 注意,此处缺少一个 </li> 闭合标签</ul></div> '''#利用etree.HTML,将字符串解析为HTML文档 html = etree.HTML(text) # 按字符串序列化HTML文档 result = etree.tostring(html) print(result)
输出结果:
<html><body> <div><ul><li class="item-0"><a href="link1.html">first item</a></li><li class="item-1"><a href="link2.html">second item</a></li><li class="item-inactive"><a href="link3.html">third item</a></li><li class="item-1"><a href="link4.html">fourth item</a></li><li class="item-0"><a href="link5.html">fifth item</a></li> </ul></div> </body></html>
lxml 可以自动修正 html 代码,例子里不仅补全了 li 标签,还添加了 body,html 标签。
文件读取:
除了直接读取字符串,lxml还支持从文件里读取内容。我们新建一个hello.html文件:
<!-- hello.html --><div><ul><li class="item-0"><a href="link1.html">first item</a></li><li class="item-1"><a href="link2.html">second item</a></li><li class="item-inactive"><a href="link3.html"><span class="bold">third item</span></a></li><li class="item-1"><a href="link4.html">fourth item</a></li><li class="item-0"><a href="link5.html">fifth item</a></li></ul></div>
再利用 etree.parse() 方法来读取文件。
# lxml_parse.pyfrom lxml import etree# 读取外部文件 hello.html html = etree.parse('./hello.html') result = etree.tostring(html, pretty_print=True)print(result)
输出结果与之前相同:
<html><body> <div><ul><li class="item-0"><a href="link1.html">first item</a></li><li class="item-1"><a href="link2.html">second item</a></li><li class="item-inactive"><a href="link3.html">third item</a></li><li class="item-1"><a href="link4.html">fourth item</a></li><li class="item-0"><a href="link5.html">fifth item</a></li> </ul></div> </body></html>
XPath实例测试
1. 获取所有的 <li>
标签
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html') print type(html) # 显示etree.parse() 返回类型result = html.xpath('//li')print result # 打印<li>标签的元素集合 print len(result) print type(result) print type(result[0])
输出结果:
<type 'lxml.etree._ElementTree'> [<Element li at 0x1014e0e18>, <Element li at 0x1014e0ef0>, <Element li at 0x1014e0f38>, <Element li at 0x1014e0f80>, <Element li at 0x1014e0fc8>] 5 <type 'list'> <type 'lxml.etree._Element'>
2. 继续获取<li>
标签的所有 class
属性
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html') result = html.xpath('//li/@class')print result
运行结果
['item-0', 'item-1', 'item-inactive', 'item-1', 'item-0']
3. 继续获取<li>
标签下hre
为 link1.html
的 <a>
标签
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html') result = html.xpath('//li/a[@href="link1.html"]')print result
运行结果
[<Element a at 0x10ffaae18>]
4. 获取<li>
标签下的所有 <span>
标签
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html')#result = html.xpath('//li/span') #注意这么写是不对的: #因为 / 是用来获取子元素的,而 <span> 并不是 <li> 的子元素,所以,要用双斜杠result = html.xpath('//li//span')print result
运行结果
[<Element span at 0x10d698e18>]
5. 获取 <li>
标签下的<a>
标签里的所有 class
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html') result = html.xpath('//li/a//@class')print result
运行结果
['blod']
6. 获取最后一个 <li>
的 <a>
的 href
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html')result = html.xpath('//li[last()]/a/@href') # 谓语 [last()] 可以找到最后一个元素print result
运行结果
['link5.html']
7. 获取倒数第二个元素的内容
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html') result = html.xpath('//li[last()-1]/a')# text 方法可以获取元素内容 print result[0].text
运行结果
fourth item
8. 获取 class
值为 bold
的标签名
# xpath_li.pyfrom lxml import etreehtml = etree.parse('hello.html')result = html.xpath('//*[@class="bold"]')# tag方法可以获取标签名 print result[0].tag
运行结果
span
案例:使用XPath的爬虫
现在我们用XPath来做一个简单的爬虫,我们尝试爬取某个贴吧里的所有帖子,并且将该这个帖子里每个楼层发布的图片下载到本地。
# tieba_xpath.py#!/usr/bin/env python # -*- coding:utf-8 -*-import os import urllib import urllib2 from lxml import etreeclass Spider:def __init__(self):self.tiebaName = raw_input("请需要访问的贴吧:")self.beginPage = int(raw_input("请输入起始页:"))self.endPage = int(raw_input("请输入终止页:"))self.url = 'http://tieba.baidu.com/f'self.ua_header = {"User-Agent" : "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1 Trident/5.0;"}# 图片编号self.userName = 1def tiebaSpider(self):for page in range(self.beginPage, self.endPage + 1):pn = (page - 1) * 50 # page numberword = {'pn' : pn, 'kw': self.tiebaName}word = urllib.urlencode(word) #转换成url编码格式(字符串)myUrl = self.url + "?" + word# 示例:http://tieba.baidu.com/f? kw=%E7%BE%8E%E5%A5%B3 & pn=50# 调用 页面处理函数 load_Page# 并且获取页面所有帖子链接,links = self.loadPage(myUrl) # urllib2_test3.py# 读取页面内容def loadPage(self, url):req = urllib2.Request(url, headers = self.ua_header)html = urllib2.urlopen(req).read()# 解析html 为 HTML 文档selector=etree.HTML(html)#抓取当前页面的所有帖子的url的后半部分,也就是帖子编号# http://tieba.baidu.com/p/4884069807里的 “p/4884069807”links = selector.xpath('//div[@class="threadlist_lz clearfix"]/div/a/@href')# links 类型为 etreeElementString 列表# 遍历列表,并且合并成一个帖子地址,调用 图片处理函数 loadImagefor link in links:link = "http://tieba.baidu.com" + linkself.loadImages(link)# 获取图片def loadImages(self, link):req = urllib2.Request(link, headers = self.ua_header)html = urllib2.urlopen(req).read()selector = etree.HTML(html)# 获取这个帖子里所有图片的src路径imagesLinks = selector.xpath('//img[@class="BDE_Image"]/@src')# 依次取出图片路径,下载保存for imagesLink in imagesLinks:self.writeImages(imagesLink)# 保存页面内容def writeImages(self, imagesLink):'''将 images 里的二进制内容存入到 userNname 文件中'''print imagesLinkprint "正在存储文件 %d ..." % self.userName# 1. 打开文件,返回一个文件对象file = open('./images/' + str(self.userName) + '.png', 'wb')# 2. 获取图片里的内容images = urllib2.urlopen(imagesLink).read()# 3. 调用文件对象write() 方法,将page_html的内容写入到文件里file.write(images)# 4. 最后关闭文件file.close()# 计数器自增1self.userName += 1# 模拟 main 函数 if __name__ == "__main__":# 首先创建爬虫对象mySpider = Spider()# 调用爬虫对象的方法,开始工作mySpider.tiebaSpider()
CSS 选择器:BeautifulSoup4
和 lxml 一样,Beautiful Soup 也是一个HTML/XML的解析器,主要的功能也是如何解析和提取 HTML/XML 数据。
lxml 只会局部遍历,而Beautiful Soup 是基于HTML DOM的,会载入整个文档,解析整个DOM树,因此时间和内存开销都会大很多,所以性能要低于lxml。
BeautifulSoup 用来解析 HTML 比较简单,API非常人性化,支持CSS选择器、Python标准库中的HTML解析器,也支持 lxml 的 XML解析器。
Beautiful Soup 3 目前已经停止开发,推荐现在的项目使用Beautiful Soup 4。使用 pip 安装即可:
pip install beautifulsoup4
官方文档:http://beautifulsoup.readthedocs.io/zh_CN/v4.4.0
抓取工具 | 速度 | 使用难度 | 安装难度 |
---|---|---|---|
正则 | 最快 | 困难 | 无(内置) |
BeautifulSoup | 慢 | 最简单 | 简单 |
lxml | 快 | 简单 | 一般 |
示例:
首先必须要导入 bs4 库
# beautifulsoup4_test.pyfrom bs4 import html = """ <html><head><title>The Dormouse's story</title></head> <body> <p class="title" name="dromouse"><b>The Dormouse's story</b></p> <p class="story">Once upon a time there were three little sisters; and their names were <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>, <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> <p class="story">...</p> """#创建 Beautiful Soup 对象 soup = BeautifulSoup(html)#打开本地 HTML 文件的方式来创建对象 #soup = BeautifulSoup(open('index.html'))#格式化输出 soup 对象的内容 print soup.prettify()
运行结果:
<html><head><title>The Dormouse's story</title></head><body><p class="title" name="dromouse"><b>The Dormouse's story</b></p><p class="story">Once upon a time there were three little sisters; and their names were<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>,<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>and<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>; and they lived at the bottom of a well.</p><p class="story">...</p></body> </html>
如果我们在 IPython2 下执行,会看到这样一段警告:
意思是,如果我们没有显式地指定解析器,所以默认使用这个系统的最佳可用HTML解析器(“lxml”)。如果你在另一个系统中运行这段代码,或者在不同的虚拟环境中,使用不同的解析器造成行为不同。
- 但是我们可以通过
soup = BeautifulSoup(html,“lxml”)
方式指定lxml解析器。
四大对象种类
Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:
- Tag
- NavigableString
- BeautifulSoup
- Comment
1. Tag
Tag 通俗点讲就是 HTML 中的一个个标签,例如:
<head><title>The Dormouse's story</title></head> <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a> <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
上面的 title
head
a
p
等等 HTML 标签加上里面包括的内容就是 Tag,那么试着使用 Beautiful Soup 来获取 Tags:
from bs4 import BeautifulSouphtml = """ <html><head><title>The Dormouse's story</title></head> <body> <p class="title" name="dromouse"><b>The Dormouse's story</b></p> <p class="story">Once upon a time there were three little sisters; and their names were <a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>, <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> <p class="story">...</p> """#创建 Beautiful Soup 对象 soup = BeautifulSoup(html)print soup.title # <title>The Dormouse's story</title>print soup.head # <head><title>The Dormouse's story</title></head>print soup.a # <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>print soup.p # <p class="title" name="dromouse"><b>The Dormouse's story</b></p>print type(soup.p) # <class 'bs4.element.Tag'>
我们可以利用 soup 加标签名轻松地获取这些标签的内容,这些对象的类型是bs4.element.Tag
。但是注意,它查找的是在所有内容中的第一个符合要求的标签。如果要查询所有的标签,后面会进行介绍。
对于 Tag,它有两个重要的属性,是 name 和 attrs
print soup.name # [document] #soup 对象本身比较特殊,它的 name 即为 [document]print soup.head.name # head #对于其他内部标签,输出的值便为标签本身的名称print soup.p.attrs # {'class': ['title'], 'name': 'dromouse'} # 在这里,我们把 p 标签的所有属性打印输出了出来,得到的类型是一个字典。print soup.p['class'] # soup.p.get('class') # ['title'] #还可以利用get方法,传入属性的名称,二者是等价的soup.p['class'] = "newClass" print soup.p # 可以对这些属性和内容等等进行修改 # <p class="newClass" name="dromouse"><b>The Dormouse's story</b></p>del soup.p['class'] # 还可以对这个属性进行删除 print soup.p # <p name="dromouse"><b>The Dormouse's story</b></p>
2. NavigableString
既然我们已经得到了标签的内容,那么问题来了,我们要想获取标签内部的文字怎么办呢?很简单,用 .string 即可,例如
print soup.p.string # The Dormouse's storyprint type(soup.p.string) # In [13]: <class 'bs4.element.NavigableString'>
3. BeautifulSoup
BeautifulSoup 对象表示的是一个文档的内容。大部分时候,可以把它当作 Tag 对象,是一个特殊的 Tag,我们可以分别获取它的类型,名称,以及属性来感受一下
print type(soup.name) # <type 'unicode'>print soup.name # [document]print soup.attrs # 文档本身的属性为空 # {}
4. Comment
Comment 对象是一个特殊类型的 NavigableString 对象,其输出的内容不包括注释符号。
print soup.a # <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>print soup.a.string # Elsie print type(soup.a.string) # <class 'bs4.element.Comment'>
a 标签里的内容实际上是注释,但是如果我们利用 .string 来输出它的内容时,注释符号已经去掉了。
遍历文档树
1. 直接子节点 :.contents
.children
属性
.content
tag 的 .content 属性可以将tag的子节点以列表的方式输出
print soup.head.contents #[<title>The Dormouse's story</title>]
输出方式为列表,我们可以用列表索引来获取它的某一个元素
print soup.head.contents[0] #<title>The Dormouse's story</title>
.children
它返回的不是一个 list,不过我们可以通过遍历获取所有子节点。
我们打印输出 .children 看一下,可以发现它是一个 list 生成器对象
print soup.head.children #<listiterator object at 0x7f71457f5710>for child in soup.body.children:print child
结果:
<p class="title" name="dromouse"><b>The Dormouse's story</b></p><p class="story">Once upon a time there were three little sisters; and their names were <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> and <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>; and they lived at the bottom of a well.</p><p class="story">...</p>
2. 所有子孙节点: .descendants
属性
.contents 和 .children 属性仅包含tag的直接子节点,.descendants 属性可以对所有tag的子孙节点进行递归循环,和 children类似,我们也需要遍历获取其中的内容。
for child in soup.descendants:print child
运行结果:
<html><head><title>The Dormouse's story</title></head> <body> <p class="title" name="dromouse"><b>The Dormouse's story</b></p> <p class="story">Once upon a time there were three little sisters; and their names were <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> and <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> <p class="story">...</p> </body></html> <head><title>The Dormouse's story</title></head> <title>The Dormouse's story</title> The Dormouse's story<body> <p class="title" name="dromouse"><b>The Dormouse's story</b></p> <p class="story">Once upon a time there were three little sisters; and their names were <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> and <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> <p class="story">...</p> </body><p class="title" name="dromouse"><b>The Dormouse's story</b></p> <b>The Dormouse's story</b> The Dormouse's story<p class="story">Once upon a time there were three little sisters; and their names were <a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> and <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> Once upon a time there were three little sisters; and their names were<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>Elsie ,<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> Lacieand<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a> Tillie ; and they lived at the bottom of a well.<p class="story">...</p> ...
3. 节点内容: .string
属性
如果tag只有一个 NavigableString 类型子节点,那么这个tag可以使用 .string 得到子节点。如果一个tag仅有一个子节点,那么这个tag也可以使用 .string 方法,输出结果与当前唯一子节点的 .string 结果相同。
通俗点说就是:如果一个标签里面没有标签了,那么 .string 就会返回标签里面的内容。如果标签里面只有唯一的一个标签了,那么 .string 也会返回最里面的内容。例如:
print soup.head.string #The Dormouse's story print soup.title.string #The Dormouse's story
搜索文档树
1.find_all(name, attrs, recursive, text, **kwargs)
1)name 参数
name 参数可以查找所有名字为 name 的tag,字符串对象会被自动忽略掉
A.传字符串
最简单的过滤器是字符串.在搜索方法中传入一个字符串参数,Beautiful Soup会查找与字符串完整匹配的内容,下面的例子用于查找文档中所有的<b>
标签:
soup.find_all('b') # [<b>The Dormouse's story</b>]print soup.find_all('a') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
B.传正则表达式
如果传入正则表达式作为参数,Beautiful Soup会通过正则表达式的 match() 来匹配内容.下面例子中找出所有以b开头的标签,这表示<body>
和<b>
标签都应该被找到
import re for tag in soup.find_all(re.compile("^b")):print(tag.name) # body # b
C.传列表
如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回.下面代码找到文档中所有<a>
标签和<b>
标签:
soup.find_all(["a", "b"]) # [<b>The Dormouse's story</b>, # <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>, # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
2)keyword 参数
soup.find_all(id='link2') # [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
3)text 参数
通过 text 参数可以搜搜文档中的字符串内容,与 name 参数的可选值一样, text 参数接受 字符串 , 正则表达式 , 列表
soup.find_all(text="Elsie") # [u'Elsie']soup.find_all(text=["Tillie", "Elsie", "Lacie"]) # [u'Elsie', u'Lacie', u'Tillie']soup.find_all(text=re.compile("Dormouse")) [u"The Dormouse's story", u"The Dormouse's story"]
CSS选择器
这就是另一种与 find_all 方法有异曲同工之妙的查找方法.
写 CSS 时,标签名不加任何修饰,类名前加
.
,id名前加#
在这里我们也可以利用类似的方法来筛选元素,用到的方法是
soup.select()
,返回类型是list
(1)通过标签名查找
print soup.select('title') #[<title>The Dormouse's story</title>]print soup.select('a') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]print soup.select('b') #[<b>The Dormouse's story</b>]
(2)通过类名查找
print soup.select('.sister') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
(3)通过 id 名查找
print soup.select('#link1') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]
(4)组合查找
组合查找即和写 class 文件时,标签名与类名、id名进行的组合原理是一样的,例如查找 p 标签中,id 等于 link1的内容,二者需要用空格分开
print soup.select('p #link1') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]
直接子标签查找,则使用 >
分隔
print soup.select("head > title") #[<title>The Dormouse's story</title>]
(5)属性查找
查找时还可以加入属性元素,属性需要用中括号括起来,注意属性和标签属于同一节点,所以中间不能加空格,否则会无法匹配到。
print soup.select('a[class="sister"]') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]print soup.select('a[href="http://example.com/elsie"]') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]
同样,属性仍然可以与上述查找方式组合,不在同一节点的空格隔开,同一节点的不加空格
print soup.select('p a[href="http://example.com/elsie"]') #[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]
(6) 获取内容
以上的 select 方法返回的结果都是列表形式,可以遍历形式输出,然后用 get_text() 方法来获取它的内容。
soup = BeautifulSoup(html, 'lxml') print type(soup.select('title')) print soup.select('title')[0].get_text()for title in soup.select('title'):
案例:使用BeautifuSoup4的爬虫
我们以腾讯社招页面来做演示:http://hr.tencent.com/position.php?&start=10#a
# bs4_tencent.pyfrom bs4 import BeautifulSoup import urllib2 import urllib import json # 使用了json格式存储def tencent():url = 'http://hr.tencent.com/'request = urllib2.Request(url + 'position.php?&start=10#a')response =urllib2.urlopen(request)resHtml = response.read()output =open('tencent.json','w')html = BeautifulSoup(resHtml,'lxml')# 创建CSS选择器result = html.select('tr[class="even"]')result2 = html.select('tr[class="odd"]')result += result2items = []for site in result:item = {}name = site.select('td a')[0].get_text()detailLink = site.select('td a')[0].attrs['href']catalog = site.select('td')[1].get_text()recruitNumber = site.select('td')[2].get_text()workLocation = site.select('td')[3].get_text()publishTime = site.select('td')[4].get_text()item['name'] = nameitem['detailLink'] = url + detailLinkitem['catalog'] = catalogitem['recruitNumber'] = recruitNumberitem['publishTime'] = publishTimeitems.append(item)# 禁用ascii编码,按utf-8编码line = json.dumps(items,ensure_ascii=False)output.write(line.encode('utf-8'))output.close()if __name__ == "__main__":tencent()
数据提取之JSON与JsonPATH
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,它使得人们很容易的进行阅读和编写。同时也方便了机器进行解析和生成。适用于进行数据交互的场景,比如网站前台与后台之间的数据交互。
JSON和XML的比较可谓不相上下。
Python 2.7中自带了JSON模块,直接import json
就可以使用了。
官方文档:http://docs.python.org/library/json.html
Json在线解析网站:http://www.json.cn/#
JSON
json简单说就是javascript中的对象和数组,所以这两种结构就是对象和数组两种结构,通过这两种结构可以表示各种复杂的结构
对象:对象在js中表示为
{ }
括起来的内容,数据结构为{ key:value, key:value, ... }
的键值对的结构,在面向对象的语言中,key为对象的属性,value为对应的属性值,所以很容易理解,取值方法为 对象.key 获取属性值,这个属性值的类型可以是数字、字符串、数组、对象这几种。数组:数组在js中是中括号
[ ]
括起来的内容,数据结构为["Python", "javascript", "C++", ...]
,取值方式和所有语言中一样,使用索引获取,字段值的类型可以是 数字、字符串、数组、对象几种。
import json
json模块提供了四个功能:dumps
、dump
、loads
、load
,用于字符串 和 python数据类型间进行转换。
1. json.loads()
把Json格式字符串解码转换成Python对象 从json到python的类型转化对照如下:
# json_loads.pyimport jsonstrList = '[1, 2, 3, 4]'strDict = '{"city": "北京", "name": "大猫"}'json.loads(strList) # [1, 2, 3, 4]json.loads(strDict) # json数据自动按Unicode存储 # {u'city': u'\u5317\u4eac', u'name': u'\u5927\u732b'}
2. json.dumps()
实现python类型转化为json字符串,返回一个str对象 把一个Python对象编码转换成Json字符串
从python原始类型向json类型的转化对照如下:
# json_dumps.pyimport json import chardetlistStr = [1, 2, 3, 4] tupleStr = (1, 2, 3, 4) dictStr = {"city": "北京", "name": "大猫"}json.dumps(listStr) # '[1, 2, 3, 4]' json.dumps(tupleStr) # '[1, 2, 3, 4]'# 注意:json.dumps() 序列化时默认使用的ascii编码 # 添加参数 ensure_ascii=False 禁用ascii编码,按utf-8编码 # chardet.detect()返回字典, 其中confidence是检测精确度 json.dumps(dictStr) # '{"city": "\\u5317\\u4eac", "name": "\\u5927\\u5218"}' chardet.detect(json.dumps(dictStr)) # {'confidence': 1.0, 'encoding': 'ascii'}print json.dumps(dictStr, ensure_ascii=False) # {"city": "北京", "name": "大刘"} chardet.detect(json.dumps(dictStr, ensure_ascii=False)) # {'confidence': 0.99, 'encoding': 'utf-8'}
chardet是一个非常优秀的编码识别模块,可通过pip安装
3. json.dump()
将Python内置类型序列化为json对象后写入文件
# json_dump.pyimport jsonlistStr = [{"city": "北京"}, {"name": "大刘"}] json.dump(listStr, open("listStr.json","w"), ensure_ascii=False)dictStr = {"city": "北京", "name": "大刘"} json.dump(dictStr, open("dictStr.json","w"), ensure_ascii=False)
4. json.load()
读取文件中json形式的字符串元素 转化成python类型
# json_load.pyimport jsonstrList = json.load(open("listStr.json")) print strList# [{u'city': u'\u5317\u4eac'}, {u'name': u'\u5927\u5218'}] strDict = json.load(open("dictStr.json")) print strDict # {u'city': u'\u5317\u4eac', u'name': u'\u5927\u5218'}
JsonPath
JsonPath 是一种信息抽取类库,是从JSON文档中抽取指定信息的工具,提供多种语言实现版本,包括:Javascript, Python, PHP 和 Java。
JsonPath 对于 JSON 来说,相当于 XPATH 对于 XML。
下载地址:https://pypi.python.org/pypi/jsonpath
安装方法:点击
Download URL
链接下载jsonpath,解压之后执行python setup.py install
官方文档:http://goessner.net/articles/JsonPath
JsonPath与XPath语法对比:
Json结构清晰,可读性高,复杂度低,非常容易匹配,下表中对应了XPath的用法。
XPath | JSONPath | 描述 |
---|---|---|
/
|
$
|
根节点 |
.
|
@
|
现行节点 |
/
|
. or[]
|
取子节点 |
..
|
n/a | 取父节点,Jsonpath未支持 |
//
|
..
|
就是不管位置,选择所有符合条件的条件 |
*
|
*
|
匹配所有元素节点 |
@
|
n/a | 根据属性访问,Json不支持,因为Json是个Key-value递归结构,不需要。 |
[]
|
[]
|
迭代器标示(可以在里边做简单的迭代操作,如数组下标,根据内容选值等) |
| |
[,]
|
支持迭代器中做多选。 |
[]
|
?()
|
支持过滤操作. |
n/a |
()
|
支持表达式计算 |
()
|
n/a | 分组,JsonPath不支持 |
示例:
我们以拉勾网城市JSON文件 http://www.lagou.com/lbs/getAllCitySearchLabels.json 为例,获取所有城市。
# jsonpath_lagou.pyimport urllib2 import jsonpath import json import chardeturl = 'http://www.lagou.com/lbs/getAllCitySearchLabels.json' request =urllib2.Request(url) response = urllib2.urlopen(request) html = response.read()# 把json格式字符串转换成python对象 jsonobj = json.loads(html)# 从根节点开始,匹配name节点 citylist = jsonpath.jsonpath(jsonobj,'$..name')print citylist print type(citylist) fp = open('city.json','w')content = json.dumps(citylist, ensure_ascii=False) print contentfp.write(content.encode('utf-8')) fp.close()
注意事项:
json.loads() 是把 Json格式字符串解码转换成Python对象,如果在json.loads的时候出错,要注意被解码的Json字符的编码。
如果传入的字符串的编码不是UTF-8的话,需要指定字符编码的参数 encoding
dataDict = json.loads(jsonStrGBK);
dataJsonStr是JSON字符串,假设其编码本身是非UTF-8的话而是GBK 的,那么上述代码会导致出错,改为对应的:
dataDict = json.loads(jsonStrGBK, encoding="GBK");
如果 dataJsonStr通过encoding指定了合适的编码,但是其中又包含了其他编码的字符,则需要先去将dataJsonStr转换为Unicode,然后再指定编码格式调用json.loads()
``` pythondataJsonStrUni = dataJsonStr.decode("GB2312"); dataDict = json.loads(dataJsonStrUni, encoding="GB2312");
##字符串编码转换这是中国程序员最苦逼的地方,什么乱码之类的几乎都是由汉字引起的。 其实编码问题很好搞定,只要记住一点:####任何平台的任何编码 都能和 Unicode 互相转换UTF-8 与 GBK 互相转换,那就先把UTF-8转换成Unicode,再从Unicode转换成GBK,反之同理。``` python # 这是一个 UTF-8 编码的字符串 utf8Str = "你好地球"# 1. 将 UTF-8 编码的字符串 转换成 Unicode 编码 unicodeStr = utf8Str.decode("UTF-8")# 2. 再将 Unicode 编码格式字符串 转换成 GBK 编码 gbkData = unicodeStr.encode("GBK")# 1. 再将 GBK 编码格式字符串 转化成 Unicode unicodeStr = gbkData.decode("gbk")# 2. 再将 Unicode 编码格式字符串转换成 UTF-8 utf8Str = unicodeStr.encode("UTF-8") decode的作用是将其他编码的字符串转换成 Unicode 编码encode的作用是将 Unicode 编码转换成其他编码的字符串
一句话:UTF-8是对Unicode字符集进行编码的一种编码方式
糗事百科实例:
爬取糗事百科段子,假设页面的URL是 http://www.qiushibaike.com/8hr/page/1
要求:
使用requests获取页面信息,用XPath / re 做数据提取
获取每个帖子里的
用户头像链接
、用户姓名
、段子内容
、点赞次数
和评论次数
保存到 json 文件内
参考代码
#qiushibaike.py#import urllib #import re #import chardetimport requests from lxml import etreepage = 1 url = 'http://www.qiushibaike.com/8hr/page/' + str(page) headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36','Accept-Language': 'zh-CN,zh;q=0.8'}try:response = requests.get(url, headers=headers)resHtml = response.texthtml = etree.HTML(resHtml)result = html.xpath('//div[contains(@id,"qiushi_tag")]')for site in result:item = {}imgUrl = site.xpath('./div/a/img/@src')[0].encode('utf-8')username = site.xpath('./div/a/@title')[0].encode('utf-8')#username = site.xpath('.//h2')[0].textcontent = site.xpath('.//div[@class="content"]/span')[0].text.strip().encode('utf-8')# 投票次数vote = site.xpath('.//i')[0].text#print site.xpath('.//*[@class="number"]')[0].text# 评论信息comments = site.xpath('.//i')[1].textprint imgUrl, username, content, vote, commentsexcept Exception, e:print e
演示效果
多线程糗事百科案例
案例要求参考上一个糗事百科单进程案例
Queue(队列对象)
Queue是python中的标准库,可以直接import Queue引用;队列是线程间最常用的交换数据的形式
python下多线程的思考
对于资源,加锁是个重要的环节。因为python原生的list,dict等,都是not thread safe的。而Queue,是线程安全的,因此在满足使用条件下,建议使用队列
初始化: class Queue.Queue(maxsize) FIFO 先进先出
包中的常用方法:
Queue.qsize() 返回队列的大小
Queue.empty() 如果队列为空,返回True,反之False
Queue.full() 如果队列满了,返回True,反之False
Queue.full 与 maxsize 大小对应
Queue.get([block[, timeout]])获取队列,timeout等待时间
创建一个“队列”对象
- import Queue
- myqueue = Queue.Queue(maxsize = 10)
将一个值放入队列中
- myqueue.put(10)
将一个值从队列中取出
- myqueue.get()
多线程示意图
# -*- coding:utf-8 -*- import requests from lxml import etree from Queue import Queue import threading import time import jsonclass thread_crawl(threading.Thread):'''抓取线程类'''def __init__(self, threadID, q):threading.Thread.__init__(self)self.threadID = threadIDself.q = qdef run(self):print "Starting " + self.threadIDself.qiushi_spider()print "Exiting ", self.threadIDdef qiushi_spider(self):# page = 1while True:if self.q.empty():breakelse:page = self.q.get()print 'qiushi_spider=', self.threadID, ',page=', str(page)url = 'http://www.qiushibaike.com/8hr/page/' + str(page) + '/'headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36','Accept-Language': 'zh-CN,zh;q=0.8'}# 多次尝试失败结束、防止死循环timeout = 4while timeout > 0:timeout -= 1try:content = requests.get(url, headers=headers)data_queue.put(content.text)breakexcept Exception, e:print 'qiushi_spider', eif timeout < 0:print 'timeout', urlclass Thread_Parser(threading.Thread):'''页面解析类;'''def __init__(self, threadID, queue, lock, f):threading.Thread.__init__(self)self.threadID = threadIDself.queue = queueself.lock = lockself.f = fdef run(self):print 'starting ', self.threadIDglobal total, exitFlag_Parserwhile not exitFlag_Parser:try:'''调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block,默认为True。如果队列为空且block为True,get()就使调用线程暂停,直至有项目可用。如果队列为空且block为False,队列将引发Empty异常。'''item = self.queue.get(False)if not item:passself.parse_data(item)self.queue.task_done()print 'Thread_Parser=', self.threadID, ',total=', totalexcept:passprint 'Exiting ', self.threadIDdef parse_data(self, item):'''解析网页函数:param item: 网页内容:return:'''global totaltry:html = etree.HTML(item)result = html.xpath('//div[contains(@id,"qiushi_tag")]')for site in result:try:imgUrl = site.xpath('.//img/@src')[0]title = site.xpath('.//h2')[0].textcontent = site.xpath('.//div[@class="content"]/span')[0].text.strip()vote = Nonecomments = Nonetry:vote = site.xpath('.//i')[0].textcomments = site.xpath('.//i')[1].textexcept:passresult = {'imgUrl': imgUrl,'title': title,'content': content,'vote': vote,'comments': comments,}with self.lock:# print 'write %s' % json.dumps(result)self.f.write(json.dumps(result, ensure_ascii=False).encode('utf-8') + "\n")except Exception, e:print 'site in result', eexcept Exception, e:print 'parse_data', ewith self.lock:total += 1data_queue = Queue() exitFlag_Parser = False lock = threading.Lock() total = 0def main():output = open('qiushibaike.json', 'a')#初始化网页页码page从1-10个页面pageQueue = Queue(50)for page in range(1, 11):pageQueue.put(page)#初始化采集线程crawlthreads = []crawlList = ["crawl-1", "crawl-2", "crawl-3"]for threadID in crawlList:thread = thread_crawl(threadID, pageQueue)thread.start()crawlthreads.append(thread)#初始化解析线程parserListparserthreads = []parserList = ["parser-1", "parser-2", "parser-3"]#分别启动parserListfor threadID in parserList:thread = Thread_Parser(threadID, data_queue, lock, output)thread.start()parserthreads.append(thread)# 等待队列清空while not pageQueue.empty():pass# 等待所有线程完成for t in crawlthreads:t.join()while not data_queue.empty():pass# 通知线程是时候退出global exitFlag_ParserexitFlag_Parser = Truefor t in parserthreads:t.join()print "Exiting Main Thread"with lock:output.close()if __name__ == '__main__':main()
所以,我们只需要匹配到网页中所有
<div class="f18 mb20">
到</div>
的数据就可以了。
根据正则表达式,我们可以推算出一个公式是:
<div.*?class="f18 mb20">(.*?)</div>
这个表达式实际上就是匹配到所有
div
中class="f18 mb20
里面的内容(具体可以看前面正则介绍)然后将这个正则应用到代码中,我们会得到以下代码:
def loadPage(self, page):"""@brief 定义一个url请求网页的方法@param page 需要请求的第几页@returns 返回的页面html"""url = "http://www.neihan8.com/article/list_5_" + str(page) + ".html"#User-Agent头user_agent = 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0' headers = {'User-Agent': user_agent}req = urllib2.Request(url, headers = headers)response = urllib2.urlopen(req)html = response.read()gbk_html = html.decode('gbk').encode('utf-8')#找到所有的段子内容<div class = "f18 mb20"></div>#re.S 如果没有re.S 则是只匹配一行有没有符合规则的字符串,如果没有则下一行重新匹配# 如果加上re.S 则是将所有的字符串将一个整体进行匹配pattern = re.compile(r'<div.*?class="f18 mb20">(.*?)</di v>', re.S)item_list = pattern.findall(gbk_html)return item_listdef printOnePage(self, item_list, page):"""@brief 处理得到的段子列表@param item_list 得到的段子列表@param page 处理第几页"""print "******* 第 %d 页 爬取完毕...*******" %pagefor item in item_list:print "================"print ite
这里需要注意一个是
re.S
是正则表达式中匹配的一个参数。如果 没有re.S 则是 只匹配一行 有没有符合规则的字符串,如果没有则下一行重新匹配。
- 如果 加上re.S 则是将 所有的字符串 将一个整体进行匹配,findall 将所有匹配到的结果封装到一个list中。
- 然后我们写了一个遍历
item_list
的一个方法printOnePage()
。 ok程序写到这,我们再一次执行一下。
Power@PowerMac ~$ python duanzi_spider.py
我们第一页的全部段子,不包含其他信息全部的打印了出来。
- 你会发现段子中有很多
<p>
,</p>
很是不舒服,实际上这个是html的一种段落的标签。 在浏览器上看不出来,但是如果按照文本打印会有
<p>
出现,那么我们只需要把我们不希望的内容去掉即可了。我们可以如下简单修改一下 printOnePage().
def printOnePage(self, item_list, page):"""@brief 处理得到的段子列表@param item_list 得到的段子列表@param page 处理第几页"""print "******* 第 %d 页 爬取完毕...*******" %pagefor item in item_list:print "================"item = item.replace("<p>", "").replace("</p>", "").repl ace("<br />", "")print item
第三步:保存数据
- 我们可以将所有的段子存放在文件中。比如,我们可以将得到的每个item不是打印出来,而是存放在一个叫 duanzi.txt 的文件中也可以。
def writeToFile(self, text): '''@brief 将数据追加写进文件中@param text 文件内容 '''myFile = open("./duanzi.txt", 'a') #追加形式打开文件 myFile.write(text)myFile.write("--------------------------------------------- --------")myFile.close()
- 然后我们将print的语句 改成
writeToFile()
,当前页面的所有段子就存在了本地的MyStory.txt文件中。
def printOnePage(self, item_list, page): '''@brief 处理得到的段子列表@param item_list 得到的段子列表@param page 处理第几页 '''print "******* 第 %d 页 爬取完毕...*******" %pagefor item in item_list:# print "================"item = item.replace("<p>", "").replace("</p>", "").repl ace("<br />", "")# print itemself.writeToFile(item)
第四步:显示数据
接下来我们就通过参数的传递对page进行叠加来遍历 内涵段子吧的全部段子内容。
只需要在外层加一些逻辑处理即可。
def doWork(self): '''让爬虫开始工作 '''while self.enable:try:item_list = self.loadPage(self.page)except urllib2.URLError, e:print e.reasoncontinue#对得到的段子item_list处理 self.printOnePage(item_list, self.page)self.page += 1 #此页处理完毕,处理下一页print "按回车继续..."print "输入 quit 退出"command = raw_input()if (command == "quit"):self.enable = Falsebreak
- 最后,我们执行我们的代码,完成后查看当前路径下的duanzi.txt文件,里面已经有了我们要的内涵段子。
以上便是一个非常精简使用的小爬虫程序,使用起来很是方便,如果想要爬取其他网站的信息,只需要修改其中某些参数和一些细节就行了。
转载于:https://www.cnblogs.com/alexzhang92/p/9408980.html
非结构化数据和结构化数据提取相关推荐
- Python爬虫(七)_非结构化数据与结构化数据
页面解析与数据提取 实际上爬虫一共就四个主要步骤: 定(要知道你准备在哪个范围或者网站去搜索) 爬(将所有的网站的内容全部爬下来) 取(分析数据,去掉对我们没用处的数据) 存(按照我们想要的方式存储和 ...
- 如何理解结构化、非结构化和半结构化数据?
计算机信息化系统中的数据分为结构化数据.非结构化数据和半结构化数据 1.结构化数据(Structured Data) 定义:结构化数据也称作行数据,是由二维表结构来逻辑表达和实现的数据,严格地遵循数据 ...
- 关于结构化、半结构化、非结构化数据的理解
记得在课上,老师说,结构化数据就是我们关系数据库里的表,剩下的都是半结构化和非结构化数据,好比XML文档就是半结构化数据,WORD文档就是非结构化数据,大数据就是半结构化和非结构化数据.心中一直有一个 ...
- 关于结构化,半结构化,非结构化数据的理解
记得在课上,老师说,结构化数据就是我们关系数据库里的表,剩下的都是半结构化和非结构化数据,好比XML文档就是半结构化数据,WORD文档就是非结构化数据,大数据就是半结构化和非结构化数据.心中一直有一个 ...
- 结构化、非结构化和半结构化数据
一直对结构化.非结构化和半结构化数据三个数据类型的概念有点模糊不清,今天特意花点时间网上查找了一番,继而,来此处进行一通总结. ** 结构化数据 ** 结构化数据可以使用关系型数据库来表示和存储,如M ...
- 使用爬虫爬取两种数据:结构化/非结构化文本
一.非结构化文本的爬取 微博上有一篇关于"#学校里的男生有多温柔#"的话题,点进去一看感觉评论很真实,于是想把评论给爬下来看一看,并生成词云.刚开始思路是通过网页端微博爬取,通过开 ...
- 夺权!非结构化数据制霸大数据
结构化 数据与非结构化数据之争已经见到了眉目,而我国的 大数据 产业也正处在由结构化为主到非结构化为主的过程中.那么非结构化数据为何可以取代结构化数据制霸大数据市场呢? 一朝天子一朝臣,一个时代一尊神 ...
- mysql 非结构化数据_hbase非结构化数据库与结构化数据库比较
目的:了解hbase与支持海量数据查询的特性以及实现方式 传统关系型数据库特点及局限 传统数据库事务性特别强,要求数据完整性及安全性,造成系统可用性以及伸缩性大打折扣.对于高并发的访问量,数据库性能不 ...
- 结构化、非结构化和半结构化数据 数据清洗
结构化数据 ** 结构化数据可以使用关系型数据库来表示和存储,如MySQL.Oracle.SQL Server等,表现二维形式的数据.可以通过固有键值获取相应信息.一般特点是:数据以行为单位,一行数 ...
最新文章
- 英特尔宣布McAfee成为独立的安全公司
- python存储numpy数据为文件_numpy.savetxt是否将数组保存到文件中的特定位置?
- C# Attribute
- eclipse中配置tomcat之后指定项目部署的目录
- micropython lcd_MicroPython动手做(05)——零基础学MaixPy之LCD液晶屏
- Android下检测网络连接 3G WIFI
- php 的html头部代码,HTML 列表
- Linux交叉编译+粤嵌LCD实现三色图
- 设计自己的ImageLoader图片加载框架
- vs2017环境下编译log4cpp-1.1.3
- 遥感图像深度学习标注——分布式协同标注
- C++中---结构体变量的默认值以及构造函数的应用
- 阿里云部署.NET后端
- CSS设置字间距、行间距、首行缩进
- 象棋巫师魔法学校/象棋路边摊 前1050关
- Pandas DataFrame切片器的基本操作及应用
- 九八寒露——HRBUST OJ 1269 小把戏
- 大学四年自学走来,这些私藏的实用工具/学习网站我贡献出来了
- Dynamics 365 自定义图表的颜色
- 什么证据可以证明婚内出轨?
热门文章
- php 类static引用函数吗,php中在变量和函数前加static关键字之后的区别
- SpringSecurity Filter
- vue 过滤器 filter
- redis 缓存目标
- Elasticsearch head插件
- 域控制器部署组策略,立即下发强制更新,显示“远程过程调用被取消”,错误代码 8007071a;以及RPC服务器不可用,800706ba【解决方案】
- Java多线程学习总结(4)——ThreadPoolExecutor 线程池的拒绝策略学习总结
- Docker学习总结(47)——温故Docker常用命令行
- Jenkins学习总结(1)——Jenkins详细安装与构建部署使用教程
- 在linux下编译android下的opencv,使用cmake的方法