Conseils pratiques pour explorer des sites Web avec Python

Avant-propos

Les scripts que j'ai écrits ont un point commun. Ils sont tous liés au web. Certaines méthodes d'obtention de liens sont toujours utilisées, et beaucoup. de captures de robots ont été accumulées. Je voudrais résumer mon expérience ici, afin de ne pas avoir à répéter le travail lors de la création de choses à l'avenir.

1. La capture de site la plus basique

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

2. Utilisez un serveur proxy

Ceci est plus utile dans certaines situations, comme l'IP est bloquée, ou le nombre de visites IP est limité, etc.

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. Situations qui nécessitent une connexion

Situations où la connexion est plus gênant Permettez-moi de diviser la question :

3.1 Traitement des cookies

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()

Oui, si Si vous le souhaitez utilisez proxy et cookie en même temps, ajoutez proxy_support puis remplacez operner par

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

3.2 Traitement du formulaire

Un formulaire est nécessaire pour vous connecter. Comment remplir le formulaire ? Tout d’abord, utilisez l’outil pour intercepter le contenu du formulaire à remplir.

Par exemple, j'utilise habituellement le plug-in Firefox httpfox pour voir quels paquets j'ai envoyés

Laissez-moi vous donner un exemple. Prenez verycd comme exemple, trouvez d'abord la requête POST que vous avez envoyée. envoyé et les éléments du formulaire POST :

Si vous pouvez voir verycd, vous devez remplir nom d'utilisateur, mot de passe, continueURI, fk, login_submit, où fk est généré de manière aléatoire (en fait, pas trop aléatoire, il semble qu'il soit généré en encodant simplement l'heure), qui doit être obtenu à partir de la page Web, ce qui signifie que vous devez d'abord visiter la page Web et utiliser des outils tels que expressions régulières pour intercepter le fk dans l'élément de données renvoyé. continueURI, comme son nom l'indique, peut être écrit avec désinvolture, tandis que login_submit est corrigé , ce qui peut être vu à partir du code source. Et le nom d'utilisateur et le mot de passe sont évidents.

D'accord, avec les données à renseigner, il faut générer des postdata

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

Puis générer une requête http, et ensuite envoyer la demande :

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

3.3 Se déguiser en navigateur pour accéder à

Certains sites internet sont dégoûtés par le visite des robots, donc les demandes sont toujours rejetées pour les robots. À ce stade, nous devons nous déguiser en navigateur, ce qui peut être réalisé en modifiant l'en-tête dans le package http :

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/*/http://www.php.cn/',
 data = postdata,
 headers = headers
)

3.4 Lien antivol"

Certains sites ont des paramètres dits anti-hotlinking. En fait, c'est très simple pour le dire crûment. Il s'agit de vérifier si le site référent dans l'en-tête que vous envoyez la requête est la sienne, il suffit donc de faire quelque chose comme 3.3 De même, changez simplement le référent des en-têtes vers le site Web. Prenons comme exemple le fameux cnbeta louche :

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

Les en-têtes sont une structure de données dict. Vous pouvez mettre n'importe quel en-tête que vous souhaitez déguiser. Par exemple, certains sites Web intelligents aiment toujours jeter un œil à la vie privée des gens. Si quelqu'un accède via un proxy, il lira le X-Forwarded-For dans l'en-tête pour voir la véritable adresse IP de la personne. S'il n'y a rien à dire, il suffit de le mettre. le X-Forwarded-For Changez-le, vous pouvez le changer en n'importe quoi d'amusant pour l'intimider et l'intimider, haha.

3.5 L'astuce ultime

Parfois même si vous faites 3.1-3.4, l'accès sera toujours bloqué, donc il n'y a pas d'autre moyen, supprimez simplement les en-têtes vus dans httpfox Si vous les écrivez tous, c'est généralement bien. Si cela ne fonctionne pas, vous ne pouvez utiliser que l'astuce ultime. Selenium contrôle directement l'accès au navigateur. Tant que le navigateur peut le faire, il peut également le faire. Les similaires incluent Pamie, Watir, etc.

4. Exploration simultanée multithread

Si un seul thread est trop lent, le multithread est nécessaire. pool Le programme modèle imprime simplement 1 à 10, mais on peut voir que cela est fait simultanément.

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. Traitement du code de vérification

Lorsque vous rencontrez le code de vérification gérer? Il y a deux situations à gérer ici :

1. Code de vérification comme Google, cool

2. Code de vérification simple : le nombre de caractères est limité, et seulement une simple traduction ou rotation plus du bruit est utilisé sans distorsion, il est toujours possible de résoudre ce genre de problème. L'idée générale est de le faire pivoter, de supprimer le bruit, puis de diviser les caractères individuels une fois la division terminée, d'utiliser la méthode d'extraction de fonctionnalités (telle que ). comme PCA) pour réduire la dimension et générer une bibliothèque de fonctionnalités, puis comparer le code de vérification avec la base de données de fonctionnalités. C'est assez compliqué et ne peut pas être expliqué dans un seul article de blog, je n'entrerai donc pas dans les détails ici. Veuillez vous procurer un manuel pertinent pour étudier les méthodes spécifiques.

En fait, certains codes de vérification sont encore très faibles, donc je ne les nommerai pas ici. Quoi qu'il en soit, j'ai extrait les codes de vérification avec une très grande précision grâce à la méthode 2, donc 2 est réellement réalisable.

Support 6 gzip/dégonflage

现在的网页普遍支持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. 总结

如此，以上就是总结Conseils pratiques pour explorer des sites Web avec Python的全部内容了，本文内容代码简单，使用方便，性能也不俗，相信对各位使用python有很大的帮助。

更多Conseils pratiques pour explorer des sites Web avec Python相关文章请关注PHP中文网！