Praktische Tipps zum Crawlen von Websites mit Python

Vorwort

Die Skripte, die ich geschrieben habe, haben eines gemeinsam: Sie beziehen sich alle auf das Internet, und zwar viele Ich möchte meine Erfahrungen hier zusammenfassen, damit ich die Arbeit in Zukunft nicht wiederholen muss.

1. Das einfachste Site-Grabbing

import urllib2
content = urllib2.urlopen('http://XXXX').read()

2. Verwenden Sie einen Proxyserver

Dies ist in bestimmten Situationen nützlicher, z. B. wenn die IP blockiert ist oder die Anzahl der IP-Besuche begrenzt ist usw.

import urllib2
proxy_support = urllib2.ProxyHandler({'http':'http://XX.XX.XX.XX:XXXX'})
opener = urllib2.build_opener(proxy_support, urllib2.HTTPHandler)
urllib2.install_opener(opener)
content = urllib2.urlopen('http://XXXX').read()

3. Situationen, die eine Anmeldung erfordern

Situationen, in denen eine Anmeldung erforderlich ist problematisch Lassen Sie mich die Frage aufteilen:

3.1 Cookie-Verarbeitung

import urllib2, cookielib
cookie_support= urllib2.HTTPCookieProcessor(cookielib.CookieJar())
opener = urllib2.build_opener(cookie_support, urllib2.HTTPHandler)
urllib2.install_opener(opener)
content = urllib2.urlopen('http://XXXX').read()

Ja, wenn Sie möchten Proxy und Cookie gleichzeitig verwenden, proxy_support hinzufügen und dann operner in

opener = urllib2.build_opener(proxy_support, cookie_support, urllib2.HTTPHandler)

3.2 Formularverarbeitung ändern

Für die Anmeldung ist ein Formular erforderlich. Wie fülle ich das Formular aus? Verwenden Sie zunächst das Tool, um den Inhalt des auszufüllenden Formulars abzufangen.

Zum Beispiel verwende ich normalerweise das Firefox+httpfox-Plugin, um zu sehen, welche Pakete ich gesendet habe

Nehmen Sie zuerst verycd als Beispiel gesendet. Anforderungs- und POST-Formularelemente:

Wenn Sie verycd sehen können, müssen Sie Benutzername, Passwort, continueURI, fk, login_submit eingeben , unter denen fk Es wird zufällig generiert (eigentlich nicht zu zufällig, es sieht so aus, als würde es einfach durch Codieren der Epochenzeit generiert. Es muss von der Webseite abgerufen werden, was bedeutet, dass Sie zuerst die Webseite besuchen und verwenden müssen). Tools wie reguläre Ausdrücke zum Abfangen der zurückgegebenen Daten. continueURI kann, wie der Name schon sagt, beiläufig geschrieben werden, während login_submit fest ist , was aus dem Quellcode ersichtlich ist. Und Benutzername, Passwort sind offensichtlich.

Okay, mit den auszufüllenden Daten müssen wir Postdaten generieren

import urllib
postdata=urllib.urlencode({
 'username':'XXXXX',
 'password':'XXXXX',
 'continueURI':'http://www.verycd.com/',
 'fk':fk,
 'login_submit':'登录'
})

und dann eine http-Anfrage generieren, und Dann senden Sie die Anfrage:

req = urllib2.Request(
 url = 'http://secure.verycd.com/signin/*///m.sbmmt.com/',
 data = postdata
)
result = urllib2.urlopen(req).read()

3.3 Verkleidung als Browser für den Zugriff

Einige Websites sind angewidert der Besuch von Crawlern, daher werden Anfragen für Crawler immer abgelehnt. Zu diesem Zeitpunkt müssen wir uns als Browser tarnen, was durch Ändern des Headers im http-Paket erreicht werden kann:

headers = {
 'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6'
}
req = urllib2.Request(
 url = 'http://secure.verycd.com/signin/*///m.sbmmt.com/',
 data = postdata,
 headers = headers
)

3.4 Anti-Diebstahl-Link"

Einige Websites verfügen über sogenannte Anti-Hotlinking-Einstellungen. Tatsächlich ist es sehr einfach, es ganz klar auszudrücken. Es geht darum, zu überprüfen, ob die verweisende Website seine eigene ist Wir müssen also nur so etwas wie 3.3 tun. Ändern Sie einfach den Verweis der Header auf die Website:

headers = {
 'Referer':'http://www.cnbeta.com/articles'
}

Header ist eine diktierte Datenstruktur. Sie können jeden beliebigen Header einfügen, um ihn zu verschleiern. Einige intelligente Websites werfen beispielsweise immer gerne einen Blick auf die Privatsphäre von Personen. Wenn jemand über einen Proxy zugreift, liest er das X-Forwarded-For im Header, um die tatsächliche IP-Adresse der Person zu sehen das X-Forwarded-For Ändern Sie es, Sie können es in alles ändern, was Spaß macht, ihn zu schikanieren und zu schikanieren, haha.

3.5 Der ultimative Trick

Manchmal wird der Zugriff auch dann blockiert, wenn Sie 3.1-3.4 ausführen, sodass es keine andere Möglichkeit gibt, einfach die angezeigten Header zu entfernen in httpfox Wenn Sie sie alle aufschreiben, ist das normalerweise in Ordnung. Wenn es nicht funktioniert, können Sie nur den ultimativen Trick verwenden, um den Browser direkt zu steuern. Solange der Browser es kann, kann er es auch. Ähnliche sind Pamie, Watir usw.

4. Gleichzeitiges Multithreading

Wenn ein einzelner Thread zu langsam ist, ist Multithreading erforderlich pool Das Vorlagenprogramm druckt einfach 1-10, aber es ist ersichtlich, dass dies gleichzeitig erfolgt.

from threading import Thread
from Queue import Queue
from time import sleep
#q是任务队列
#NUM是并发线程总数
#JOBS是有多少任务
q = Queue()
NUM = 2
JOBS = 10
#具体的处理函数，负责处理单个任务
def do_somthing_using(arguments):
 print arguments
#这个是工作进程，负责不断从队列取数据并处理
def working():
 while True:
  arguments = q.get()
  do_somthing_using(arguments)
  sleep(1)
  q.task_done()
#fork NUM个线程等待队列
for i in range(NUM):
 t = Thread(target=working)
 t.setDaemon(True)
 t.start()
#把JOBS排入队列
for i in range(JOBS):
 q.put(i)
#等待所有JOBS完成
q.join()

5. Verarbeitung des Bestätigungscodes

Wenn Sie auf den Bestätigungscode stoßen verwalten? Hier gibt es zwei Situationen, mit denen man umgehen muss:

1. Bestätigungscode wie Google, cool

2. Einfacher Bestätigungscode: Die Anzahl der Zeichen ist begrenzt und nur einfache Übersetzung oder Drehung plus Rauschen Wird ohne Verzerrung verwendet, ist es immer noch möglich, diese Art von Problem zu lösen. Die allgemeine Idee besteht darin, es zurückzudrehen, das Rauschen zu entfernen und dann die einzelnen Zeichen zu teilen. Verwenden Sie dann die Merkmalsextraktionsmethode (z als PCA), um die Dimension zu reduzieren und eine Feature-Bibliothek zu generieren, und vergleichen Sie dann den Verifizierungscode mit der Feature-Datenbank. Dies ist ziemlich kompliziert und kann nicht in einem Blogbeitrag erklärt werden, daher werde ich hier nicht auf Details eingehen. Bitte besorgen Sie sich ein entsprechendes Lehrbuch, um die spezifischen Methoden zu studieren.

Tatsächlich sind einige Verifizierungscodes immer noch sehr schwach, daher werde ich sie hier nicht nennen. Wie auch immer, ich habe Verifizierungscodes mit Methode 2 mit sehr hoher Genauigkeit extrahiert, sodass 2 tatsächlich machbar ist.

6 gzip/deflate-Unterstützung

现在的网页普遍支持gzip压缩，这往往可以解决大量传输时间，以 VeryCD 的主页为例，未压缩版本247K，压缩了以后45K，为原来的1/5。这就意味着抓取速度会快5倍。

然而python的urllib/urllib2默认都不支持压缩，要返回压缩格式，必须在request的header里面写明'accept-encoding'，然后读取response后更要检查header查看是否有'content-encoding'一项来判断是否需要解码，很繁琐琐碎。如何让urllib2自动支持gzip, defalte呢？

其实可以继承 BaseHanlder 类，然后build_opener的方式来处理：

import urllib2
from gzip import GzipFile
from StringIO import StringIO
class ContentEncodingProcessor(urllib2.BaseHandler):
 """A handler to add gzip capabilities to urllib2 requests """
 
 # add headers to requests
 def http_request(self, req):
 req.add_header("Accept-Encoding", "gzip, deflate")
 return req
 
 # decode
 def http_response(self, req, resp):
 old_resp = resp
 # gzip
 if resp.headers.get("content-encoding") == "gzip":
  gz = GzipFile(
     fileobj=StringIO(resp.read()),
     mode="r"
     )
  resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code)
  resp.msg = old_resp.msg
 # deflate
 if resp.headers.get("content-encoding") == "deflate":
  gz = StringIO( deflate(resp.read()) )
  resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code) # 'class to add info() and
  resp.msg = old_resp.msg
 return resp
 
# deflate support
import zlib
def deflate(data): # zlib only provides the zlib compress format, not the deflate format;
 try:    # so on top of all there's this workaround:
 return zlib.decompress(data, -zlib.MAX_WBITS)
 except zlib.error:
 return zlib.decompress(data)

然后就简单了，

encoding_support = ContentEncodingProcessor
opener = urllib2.build_opener( encoding_support, urllib2.HTTPHandler )
 
#直接用opener打开网页，如果服务器支持gzip/defalte则自动解压缩
content = opener.open(url).read()

7. 更方便地多线程

总结一文的确提及了一个简单的多线程模板，但是那个东东真正应用到程序里面去只会让程序变得支离破碎，不堪入目。在怎么更方便地进行多线程方面我也动了一番脑筋。先想想怎么进行多线程调用最方便呢？

1、用twisted进行异步I/O抓取

事实上更高效的抓取并非一定要用多线程，也可以使用异步I/O法：直接用twisted的getPage方法，然后分别加上异步I/O结束时的callback和errback方法即可。例如可以这么干：

from twisted.web.client import getPage
from twisted.internet import reactor
 
links = [ 'http://www.verycd.com/topics/%d/'%i for i in range(5420,5430) ]
 
def parse_page(data,url):
 print len(data),url
 
def fetch_error(error,url):
 print error.getErrorMessage(),url
 
# 批量抓取链接
for url in links:
 getPage(url,timeout=5) \
  .addCallback(parse_page,url) \ #成功则调用parse_page方法
  .addErrback(fetch_error,url)  #失败则调用fetch_error方法
 
reactor.callLater(5, reactor.stop) #5秒钟后通知reactor结束程序
reactor.run()

twisted人如其名，写的代码实在是太扭曲了，非正常人所能接受，虽然这个简单的例子看上去还好；每次写twisted的程序整个人都扭曲了，累得不得了，文档等于没有，必须得看源码才知道怎么整，唉不提了。

如果要支持gzip/deflate，甚至做一些登陆的扩展，就得为twisted写个新的 HTTPClientFactory 类诸如此类，我这眉头真是大皱，遂放弃。有毅力者请自行尝试。

2、设计一个简单的多线程抓取类

还是觉得在urllib之类python“本土”的东东里面折腾起来更舒服。试想一下，如果有个Fetcher类，你可以这么调用

f = Fetcher(threads=10) #设定下载线程数为10
for url in urls:
 f.push(url) #把所有url推入下载队列
while f.taskleft(): #若还有未完成下载的线程
 content = f.pop() #从下载完成队列中取出结果
 do_with(content) # 处理content内容

这么个多线程调用简单明了，那么就这么设计吧，首先要有两个队列，用Queue搞定，多线程的基本架构也和“技巧总结”一文类似，push方法和pop方法都比较好处理，都是直接用Queue的方法，taskleft则是如果有“正在运行的任务”或者”队列中的任务”则为是，也好办，于是代码如下：

import urllib2
from threading import Thread,Lock
from Queue import Queue
import time
 
class Fetcher:
 def __init__(self,threads):
  self.opener = urllib2.build_opener(urllib2.HTTPHandler)
  self.lock = Lock() #线程锁
  self.q_req = Queue() #任务队列
  self.q_ans = Queue() #完成队列
  self.threads = threads
  for i in range(threads):
   t = Thread(target=self.threadget)
   t.setDaemon(True)
   t.start()
  self.running = 0
 
 def __del__(self): #解构时需等待两个队列完成
  time.sleep(0.5)
  self.q_req.join()
  self.q_ans.join()
 
 def taskleft(self):
  return self.q_req.qsize()+self.q_ans.qsize()+self.running
 
 def push(self,req):
  self.q_req.put(req)
 
 def pop(self):
  return self.q_ans.get()
 
 def threadget(self):
  while True:
   req = self.q_req.get()
   with self.lock: #要保证该操作的原子性，进入critical area
    self.running += 1
   try:
    ans = self.opener.open(req).read()
   except Exception, what:
    ans = ''
    print what
   self.q_ans.put((req,ans))
   with self.lock:
    self.running -= 1
   self.q_req.task_done()
   time.sleep(0.1) # don't spam
 
if __name__ == "__main__":
 links = [ 'http://www.verycd.com/topics/%d/'%i for i in range(5420,5430) ]
 f = Fetcher(threads=10)
 for url in links:
  f.push(url)
 while f.taskleft():
  url,content = f.pop()
  print url,len(content)

8. 一些琐碎的经验

1、连接池：

opener.open和urllib2.urlopen一样，都会新建一个http请求。通常情况下这不是什么问题，因为线性环境下，一秒钟可能也就新生成一个请求；然而在多线程环境下，每秒钟可以是几十上百个请求，这么干只要几分钟，正常的有理智的服务器一定会封禁你的。

然而在正常的html请求时，保持同时和服务器几十个连接又是很正常的一件事，所以完全可以手动维护一个 HttpConnection 的池，然后每次抓取时从连接池里面选连接进行连接即可。

这里有一个取巧的方法，就是利用squid做代理服务器来进行抓取，则squid会自动为你维护连接池，还附带数据缓存功能，而且squid本来就是我每个服务器上面必装的东东，何必再自找麻烦写连接池呢。

2、设定线程的栈大小

栈大小的设定将非常显著地影响python的内存占用，python多线程不设置这个值会导致程序占用大量内存，这对openvz的vps来说非常致命。stack_size必须大于32768，实际上应该总要32768*2以上

from threading import stack_size
stack_size(32768*16)

3、设置失败后自动重试

 def get(self,req,retries=3):
  try:
   response = self.opener.open(req)
   data = response.read()
  except Exception , what:
   print what,req
   if retries>0:
    return self.get(req,retries-1)
   else:
    print 'GET Failed',req
    return ''
  return data

4、设置超时

 import socket
 socket.setdefaulttimeout(10) #设置10秒后连接超时

登陆更加简化了，首先build_opener中要加入cookie支持，如要登陆 VeryCD ，给Fetcher新增一个空方法login，并在 init ()中调用，然后继承Fetcher类并override login方法：

def login(self,username,password):
 import urllib
 data=urllib.urlencode({'username':username,
       'password':password,
       'continue':'http://www.verycd.com/',
       'login_submit':u'登录'.encode('utf-8'),
       'save_cookie':1,})
 url = 'http://www.verycd.com/signin'
 self.opener.open(url,data).read()

于是在Fetcher初始化时便会自动登录 VeryCD 网站。

9. 总结

如此，以上就是总结Praktische Tipps zum Crawlen von Websites mit Python的全部内容了，本文内容代码简单，使用方便，性能也不俗，相信对各位使用python有很大的帮助。

更多Praktische Tipps zum Crawlen von Websites mit Python相关文章请关注PHP中文网！