最全Python爬虫总结(转载)

[html] view plain copy

1. 最近总是要爬取一些东西，索性就把Python爬虫的相关内容都总结起来了，自己多动手还是好。

（1）普通的内容爬取
（2）保存爬取的图片/视频和文件和网页
（3）普通模拟登录
（4）处理验证码登录
（5）爬取js网站
（6）全网爬虫
（7）某个网站的站内所有目录爬虫
（8）多线程 
（9）爬虫框架Scrapy

一，普通的内容爬取

1. #coding=utf-8
2. import urllib
3. import urllib2
4. url = 'http://www.dataanswer.top'
5. headers = {
6. 'Host':'www.dataanswer.top',
7. 'User-Agent':'Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:31.0) Gecko/20100101 Firefox/31.0',
8. #'Accept':'application/json, text/javascript, */*; q=0.01',
9. #'Accept-Language':'zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3',
10. #'Accept-Encoding':'gzip,deflate',
11. #'Referer':'http://www.dataanswer.top'
12. }
13. request = urllib2.Request(url,headers=headers)
14. response = urllib2.urlopen(request)
15. page = response.read()
16. print page

二，保存爬取的图片/视频和文件和网页
#图片/视频和文件和网页的地址抓取下来后，利用模块urllib里的urlretrieve()方法下载下来：

1. #coding=utf-8
2. import urllib
3. import urllib2
4. import os
5. def getPage(url):
6. request = urllib2.Request(url)
7. response = urllib2.urlopen(request)
8. return response.read()
9. url='http://www.dataanswer.top/'
10. result=getPage(url)
11. file_name='test.doc'
12. file_path='doc'
13. if os.path.exists(file_path) == False:
14. os.makedirs(file_path)
15. local=os.path.join(file_path,file_name)
16. f = open(local,"w+")
17. f.write(result)
18. f.close()
19. #coding=utf-8
20. import urllib
21. import urllib2
22. import os
23. def getPage(url):
24. request = urllib2.Request(url)
25. response = urllib2.urlopen(request)
26. return response.read()
27. url='http://www.dataanswer.top/'  #把该地址改成图片/文件/视频/网页的地址即可
28. result=getPage(url)
29. file_name='test.doc'
30. file_path='doc'
31. if os.path.exists(file_path) == False:
32. os.makedirs(file_path)
33. local=os.path.join(file_path,file_name)
34. urllib.urlretrieve(url,local)

三,普通模拟登录

1. import urllib
2. import urllib2
3. import cookielib
4. filename = 'cookie.txt'
5. #声明一个MozillaCookieJar对象实例来保存cookie，之后写入文件
6. cookie = cookielib.MozillaCookieJar(filename)
7. opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
8. postdata = urllib.urlencode({
9. 'name':'春天里',
10. 'pwd':'1222222'
11. })
12. #登录的URL
13. loginUrl = 'http://www.dataanswer.top/LoginService?action=tologin'
14. #模拟登录，并把cookie保存到变量
15. result = opener.open(loginUrl,postdata)
16. #保存cookie到cookie.txt中
17. cookie.save(ignore_discard=True, ignore_expires=True)
18. #利用cookie请求访问另一个网址
19. gradeUrl = 'http://www.dataanswer.top/LoginService?action=myHome'
20. #请求访问
21. result = opener.open(gradeUrl)
22. print result.read()

四，处理验证码登录
#先把验证码图片下载下来保存，再人工读入

1. #coding=utf-8
2. import sys, time, os, re
3. import urllib, urllib2, cookielib
4. loginurl = 'https://www.douban.com/accounts/login'
5. cookie = cookielib.CookieJar()
6. opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
7. params = {
8. "form_email":"13161055481",
9. "form_password":"wwwwwww",
10. "source":"index_nav" #没有的话登录不成功
11. }
12. #从首页提交登录
13. response=opener.open(loginurl)
14. #验证成功跳转至登录页
15. print(response.geturl())
16. if response.geturl() == "https://www.douban.com/accounts/login":
17. html=response.read()
18. print(html)
19. #验证码图片地址--图片地址加密怎么办？？？
20. imgurl=re.search('<img id="captcha_image" src="(.+?)" alt="captcha" class="captcha_image"/>', html)
21. print(imgurl)
22. if imgurl:
23. url=imgurl.group(1)
24. #将图片保存至同目录下
25. res=urllib.urlretrieve(url,'v.jpg')
26. #获取captcha-id参数
27. captcha=re.search('<input type="hidden" name="captcha-id" value="(.+?)"/>',html)
28. if captcha:
29. vcode=raw_input('请输入图片上的验证码：')
30. params["captcha-solution"]=vcode
31. params["captcha-id"]=captcha.group(1)
32. params["user_login"]="登录"
33. #提交验证码验证
34. response=opener.open(loginurl, urllib.urlencode(params))
35. ''' 登录成功跳转至首页 '''
36. if response.geturl() == "https://www.douban.com/":
37. print 'login success ! '
38. print '准备进行发帖'
39. addtopicurl="http://www.douban.com/group/python/new_topic"
40. res=opener.open(addtopicurl)
41. html=res.read()
42. else:
43. print("Fail3")
44. else:
45. print("Fail2")
46. else:
47. print("Fail1")
48. else:
49. print("Fail0")

五，爬取js网站
#利用selenium模拟浏览器，结合html的解析

1. #coding=utf-8
2. #1、安装 python-pip
3. #sudo apt-get install python-pip
4. #2、安装selenium
5. #sudo pip install -U selenium
6. from selenium import webdriver
7. driver = webdriver.Firefox()
8. driver.get('http://www.newsmth.net/nForum/#!article/Intern/206790')
9. html=driver.page_source.encode('utf-8','ignore') #这个函数获取页面的html
10. print(html)
11. driver.close()

六，全网爬虫
#广度优先，模拟爬取队列

1. #coding=utf-8
2. """
3. 全网爬取所有链接，包括外链--广度优先
4. """
5. import urllib2
6. import re
7. from bs4 import BeautifulSoup
8. import time
9. #爬虫开始的时间
10. t=time.time()
11. #设置的暂停爬取条数
12. N_STOP=10
13. #存放已经爬取过的url
14. CHECKED_URL=[]
15. #存放待爬取的url
16. CHECKING_URL=[]
17. #存放连接失败的url
18. FAIL_URL=[]
19. #存放不能连接的url
20. ERROR_URL=[]
21. #失败后允许连接的次数
22. RETRY=3
23. #连接超时时间
24. TIMEOUT=20
25. class url_node:
26. def __init__(self,url):
27. """
28. url节点初始化
29. ：param url:String 当前url
30. """
31. self.url=url
32. self.content=''
33. def __is_connectable(self):
34. """
35. 检验url是否可以连接
36. """
37. #在允许连接次数下连接
38. for i in range(RETRY):
39. try:
40. #打开url没有报错，则表示可连接
41. response=urllib2.urlopen(self.url,timeout=TIMEOUT)
42. return True
43. except:
44. #如果在尝试允许连接次数下报错，则不可连接
45. if i==RETRY-1:
46. return False
47. def get_next(self):
48. """
49. 获取爬取该页中包含的其他所有的url
50. """
51. soup=BeautifulSoup(self.content)
52. #******************在此处可以从网页中解析你想要的内容************************************
53. next_urls=soup.findAll('a')
54. if len(next_urls)!=0:
55. for link in next_urls:
56. tmp_url=link.get('href')
57. #如果url不在爬取过的列表中也不在待爬取列表中则把其放到待爬列表中（没有确保该url有效）
58. if tmp_url not in CHECKED_URL and tmp_url not in CHECKING_URL:
59. CHECKING_URL.append(tmp_url)
60. def run(self):
61. if self.url:
62. if self.__is_connectable():
63. try:
64. #获取爬取页面的所有内容
65. self.content=urllib2.urlopen(self.url,timeout=TIMEOUT).read()
66. #从该页面中获取url
67. self.get_next()
68. except:
69. #把连接失败的存放起来
70. FAIL_URL.append(self.url)
71. print('[!]Connect Failed')
72. else:
73. #把不能连接的存放起来
74. ERROR_URL.append(self.url)
75. else:
76. print("所给的初始url有问题！")
77. if __name__=='__main__':
78. #把初始的url放到待爬的列表中
79. CHECKING_URL.append('http://www.36dsj.com/')
80. #不断的从待爬的列表中获取url进行爬取
81. ff=open("Mytest.txt",'w')
82. i=0
83. for url in CHECKING_URL:
84. #对该url进行爬取
85. url_node(url).run()
86. #存放已经爬取过的url
87. CHECKED_URL.append(url)
88. #删除CHECKING_URL中已经爬取过的url
89. CHECKING_URL.remove(url)
90. i+=1
91. if i==N_STOP:
92. #打出停止时的url，下次可以把该url作为初始继续
93. print url
94. print("爬取过的列表长度：%d") % len(CHECKED_URL)
95. print("待爬取的列表长度：%d") % len(CHECKING_URL)
96. print("连接失败的列表长度：%d") % len(FAIL_URL)
97. print("不能连接的列表长度：%d") % len(ERROR_URL)
98. break
99. ff.close()
100. print("time:%d s") % (time.time()-t)

七，某个网站的站内所有目录爬虫
#把缩写的站内网址还原

1. #coding=utf-8
2. """
3. 爬取同一个网站所有的url,不包括外链
4. """
5. import urllib2
6. import re
7. from bs4 import BeautifulSoup
8. import time
9. t=time.time()
10. HOST=''
11. CHECKED_URL=[]
12. CHECKING_URL=[]
13. RESULT=[]
14. RETRY=3
15. TIMEOUT=20
16. class url_node:
17. def __init__(self,url):
18. """
19. url节点初始化
20. ：param url:String 当前url
21. """
22. self.url=self.handle_url(url,is_next_url=False)
23. self.next_url=[]
24. self.content=''
25. def handle_url(self,url,is_next_url=True):
26. """
27. 将所有的url处理成标准形式
28. """
29. global CHECKED_URL
30. global CHECKING_URL
31. #去掉尾部的‘/’
32. url=url[0:len(url)-1] if url.endswith('/') else url
33. if url.find(HOST)==-1:
34. if not url.startswith('http'):
35. url='http://'+HOST+url if url.startswith('/') else 'http://'+HOST+'/'+url
36. else:
37. #如果含有http说明是外链，url的host不是当前的host，返回空
38. return
39. else:
40. if not url.startswith('http'):
41. url='http://'+url
42. if is_next_url:
43. #下一层url放入待检测列表
44. if url not in CHECKING_URL:
45. CHECKING_URL.append(url)
46. else:
47. #对于当前需要检测的url将参数都替换为1，然后加入规则表
48. #参数相同类型不同的url只检测一次
49. rule=re.compile(r'=.*?\&|=.*?$')
50. result=re.sub(rule,'=1&',url)
51. if result in CHECKED_URL:
52. return '[!] Url has checked!'
53. else:
54. CHECKED_URL.append(result)
55. RESULT.append(url)
56. return url
57. def __is_connectable(self):
58. print("进入__is_connectable()函数")
59. #检验是否可以连接
60. retry=3
61. timeout=2
62. for i in range(RETRY):
63. try:
64. #print("进入_..............函数")
65. response=urllib2.urlopen(self.url,timeout=TIMEOUT)
66. return True
67. except:
68. if i==retry-1:
69. return False
70. def get_next(self):
71. #获取当前所有的url
72. #print("进入get_next()函数")
73. soup=BeautifulSoup(self.content)
74. next_urls=soup.findAll('a')
75. if len(next_urls)!=0:
76. for link in next_urls:
77. self.handle_url(link.get('href'))
78. #print(link.text)
79. def run(self):
80. #print("进入run()函数")
81. if self.url:
82. #print self.url
83. if self.__is_connectable():
84. try:
85. self.content=urllib2.urlopen(self.url,timeout=TIMEOUT).read()
86. self.get_next()
87. except:
88. print('[!]Connect Failed')
89. #处理https开头的url的类和方法
90. class Poc:
91. def run(self,url):
92. global HOST
93. global CHECKING_URL
94. url=check_url(url)
95. if not url.find('https'):
96. HOST=url[:8]
97. else:
98. HOST=url[7:]
99. for url in CHECKING_URL:
100. print(url)
101. url_node(url).run()
102. def check_url(url):
103. url='http://'+url if not url.startswith('http') else url
104. url=url[0:len(url)-1] if url.endswith('/') else url
105. for i in range(RETRY):
106. try:
107. response=urllib2.urlopen(url,timeout=TIMEOUT)
108. return url
109. except:
110. raise Exception("Connect error")
111. if __name__=='__main__':
112. HOST='www.dataanswer.com'
113. CHECKING_URL.append('http://www.dataanswer.com/')
114. f=open('36大数据','w')
115. for url in CHECKING_URL:
116. f.write(url+'\n')
117. print(url)
118. url_node(url).run()
119. print RESULT
120. print "URL num:"+str(len(RESULT))
121. print("time:%d s") % (time.time()-t)

八，多线程
#对列和线程的结合

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. """
4. 一个简单的Python爬虫, 使用了多线程,
5. 爬取豆瓣Top前250的所有电影
6. """
7. import urllib2, re, string
8. import threading, Queue, time
9. import sys
10. reload(sys)
11. sys.setdefaultencoding('utf8')
12. _DATA = []
13. FILE_LOCK = threading.Lock()
14. SHARE_Q = Queue.Queue()  #构造一个不限制大小的的队列
15. _WORKER_THREAD_NUM = 3  #设置线程的个数
16. class MyThread(threading.Thread) :
17. def __init__(self, func) :
18. super(MyThread, self).__init__()  #调用父类的构造函数
19. self.func = func  #传入线程函数逻辑
20. def run(self) :
21. self.func()
22. def worker() :
23. global SHARE_Q
24. while not SHARE_Q.empty():
25. url = SHARE_Q.get() #获得任务
26. my_page = get_page(url)
27. find_title(my_page)  #获得当前页面的电影名
28. #write_into_file(temp_data)
29. time.sleep(1)
30. SHARE_Q.task_done()
31. def get_page(url) :
32. """
33. 根据所给的url爬取网页HTML
34. Args:
35. url: 表示当前要爬取页面的url
36. Returns:
37. 返回抓取到整个页面的HTML(unicode编码)
38. Raises:
39. URLError:url引发的异常
40. """
41. try :
42. my_page = urllib2.urlopen(url).read().decode("utf-8")
43. except urllib2.URLError, e :
44. if hasattr(e, "code"):
45. print "The server couldn't fulfill the request."
46. print "Error code: %s" % e.code
47. elif hasattr(e, "reason"):
48. print "We failed to reach a server. Please check your url and read the Reason"
49. print "Reason: %s" % e.reason
50. return my_page
51. def find_title(my_page) :
52. """
53. 通过返回的整个网页HTML, 正则匹配前100的电影名称
54. Args:
55. my_page: 传入页面的HTML文本用于正则匹配
56. """
57. temp_data = []
58. movie_items = re.findall(r'<span.*?class="title">(.*?)</span>', my_page, re.S)
59. for index, item in enumerate(movie_items) :
60. if item.find(" ") == -1 :
61. #print item,
62. temp_data.append(item)
63. _DATA.append(temp_data)
64. def main() :
65. global SHARE_Q
66. threads = []
67. douban_url = "http://movie.douban.com/top250?start={page}&filter=&type="
68. #向队列中放入任务, 真正使用时, 应该设置为可持续的放入任务
69. for index in xrange(10) :
70. SHARE_Q.put(douban_url.format(page = index * 25))
71. for i in xrange(_WORKER_THREAD_NUM) :
72. thread = MyThread(worker)
73. thread.start()  #线程开始处理任务
74. print("第%s个线程开始工作") % i
75. threads.append(thread)
76. for thread in threads :
77. thread.join()
78. SHARE_Q.join()
79. with open("movie.txt", "w+") as my_file :
80. for page in _DATA :
81. for movie_name in page:
82. my_file.write(movie_name + "\n")
83. print "Spider Successful!!!"
84. if __name__ == '__main__':
85. main()

九,爬虫框架Scrapy

items.py：用来定义需要保存的变量，其中的变量用Field来定义，有点像python的字典
pipelines.py：用来将提取出来的Item进行处理，处理过程按自己需要进行定义
spiders：定义自己的爬虫

爬虫的类型也有好几种：
　　1）spider:最基本的爬虫，其他的爬虫一般是继承了该最基本的爬虫类，提供访问url，返回response的功能，会默认调用parse方法
　　2）CrawlSpider：继承spider的爬虫，实际使用比较多，设定rule规则进行网页的跟进与处理， 注意点：编写爬虫的规则的时候避免使用parse名，因为这会覆盖继承的spider的的方法parse造成错误。   其中比较重要的是对Rule的规则的编写，要对具体的网页的情况进行分析。
　　3）XMLFeedSpider 与 CSVFeedSpider

(1)打开命令行，执行：scrapy startproject tutorial（项目名称）
(2)scrapy.cfg是项目的配置文件,用户自己写的spider要放在spiders目录下面
(3)解析：name属性很重要，不同spider不能使用相同的name
start_urls是spider抓取网页的起始点，可以包括多个url
parse方法是spider抓到一个网页以后默认调用的callback，避免使用这个名字来定义自己的方法。
当spider拿到url的内容以后，会调用parse方法，并且传递一个response参数给它，response包含了抓到的网页的内容，在parse方法里，你可以从抓到的网页里面解析数据。
(3)开始抓取，进入生成的项目根目录tutorial/，执行 scrapy crawl dmoz， dmoz是spider的name。
(4)保存对象：在items.py中添加一些类，这些类用来描述我们要保存的数据

from scrapy.item import Item, Field
class DmozItem(Item):
    title = Field()
    link = Field()
    desc = Field()
（5）执行scrapy crawl dmoz --set FEED_URI=items.json --set FEED_FORMAT=json后得到保存的文件
（6）让scrapy自动抓取网页上的所有链接

在parse方法里面提取我们需要的链接，然后构造一些Request对象，并且把他们返回，scrapy会自动的去抓取这些链接