1.要重构下载函数，建立一个类，用来下载，并记录下载数据。下次下载时还要判断是否已经下载过了。
所以需要一个下载类Downloader类，和一个Cache类（用来记录是否下载，已经下载状态code）
import time
import re
from urllib import parse
from urllib import robotparser
import csv
from urllib.request import *
from urllib.parse import *
from urllib.error import URLError
import lxml.html
import socket
DEFAULT_AGENT = 'wswp'
DEFAULT_DELAY = 3
DEFAULT_RETRIES = 1
DEFAULT_TIMEOUT = 10
class Cache:
d=dict()
def __getitem__(self,key):
return self.d[key]
def __setitem__(self,key,value):
self.d[key]=value
class Timedelay:
#初始化
def __init__(self,delay):
#设置延迟时间
self.delay=delay
#创建记录主站的字典
self.domains={}
#创建等待函数，同时还要实现记录走后一次访问时间
def wait(self,url):
netloc=urlparse(url).netloc
last_time=self.domains.get(netloc)
if self.delay and last_time:
sleeptime=self.delay-(time.time()-last_time)
if sleeptime>0:
time.sleep(sleeptime)
#每次暂停后，或者没暂停都重置最后一次访问时间
self.domains[netloc]=time.time()
class Downloader:
def __init__(self,user_agent=DEFAULT_AGENT,proxy=None,retries=DEFAULT_RETRIES,delay=DEFAULT_DELAY,timeout=DEFAULT_TIMEOUT,cache=None):
socket.setdefaulttimeout(timeout)
self.delay=Timedelay(delay)
self.num_retries=retries
self.cache=cache
self.user_agent=user_agent
self.proxy=proxy
#回调函数在下载时回调
def __call__(self,url):
result=None
#用来判断存储是否可用
if self.cache:
try:
result=self.cache[url]#查询下载结果，Cache类需要__getitem__()方法
except KeyError as e :
pass
else:
#网页有错误的（code=404）和已经下载好了的（code=200）都不用再下载了。前者不用下载是
#因为再下载也是下载不下来的，所以结果就是这个空的结果了。
#而如果是500 <=code< 600:则是服务器问题，应该继续下载，不能用现在的结果。
if self.num_retries > 0 and 500 <= result['code'] < 600:
result=None
if result is None:
self.delay.wait(url)
result=self.download(url,User_agent=self.user_agent,proxy=self.proxy,num_retry=self.num_retries)
if self.cache:
self.cache[url]=result#把下载结果存储下来，Cache类需要__setitem__()方法
#存储的形式是{url1：{'html':...,'code':....},url2:.........}
return result['html']
def download(self,url,User_agent='wswp',proxy=None,num_retry=2):
print('Downloading:',url)
headers={'User-agent':User_agent}
request=Request(url,headers=headers)
#加入代理服务器的处理，就不用urlopen来下载网页了，而是用自己构建的opener来打开
opener=build_opener()
#若设置了代理，执行下面操作加入代理到opener中
print('start proxy',proxy)
if proxy:
print('proxy is:',proxy)
proxy_params={urlparse(url).scheme:proxy}
opener.add_handler(ProxyHandler(proxy_params))#在自己构建的浏览器中加入了代理服务器
#当没有设置代理时，下面的打开方式和urlopen是一样的
try:
response=opener.open(request)
html=response.read()
code=response.code
except Exception as e:#引入URLError进行分析
print('Download error:',e.reason)
html=''
if hasattr(e,'code'):
code=e.code
if num_retry>0 and 500<=e.code<600:
return self.download(url,num_retry=num_retry-1)
else:
code=''
return {'html':html,'code':code}
class ScrapeCallback:
def __init__(self):
self.fields=['area','population','iso','country','capital','continent','tld','currency_code','currency_name','phone','postal_code_format','postal_code_regex','languages','neighbours']
self.writer=csv.writer(open(r'C:\Users\Desktop\python学习笔记\table2.csv','w',newline=''))
self.writer.writerow(self.fields)
def __call__(self,url,html):
if re.search('/view/',url):
row=[]
for field in self.fields:
tree=lxml.html.fromstring(html)
row.append(tree.cssselect('table>tr#places_%s__row>td.w2p_fw'%field)[0].text_content())
self.writer.writerow(row)
def link_crawler(seed_url,link_res,User_agent=DEFAULT_AGENT,delay=DEFAULT_DELAY,proxy=None,maxdepth=2,scrape_callback=ScrapeCallback()):
crawl_queue=[seed_url]
#seen=set(crawl_queue)
seen={seed_url:0}
#读取robots.txt
rp=robotparser.RobotFileParser()
rp.set_url('http://example.webscraping.com/robots.txt')
rp.read()
d=Downloader(cache=Cache())#初始化
'''
这里的前几行是初始赋值的作用，后面的循环中
就不再需要赋值了，特别是在循环中很难操作set（）
使其增加
'''
while crawl_queue:
url=crawl_queue.pop()
#检查该url是否能被禁止爬取
if rp.can_fetch(User_agent,url):
'''
while True:
try:
html=d(url)#回调函数
except Exception as e:
print('超时')
else:
break
'''
html=d(url)
dept=seen[url]#获取现在的深度
links=[]
links.extend(scrape_callback(url,html.decode()) or [])
#加入一个过滤器#在过滤器中看是否重复
if dept!=maxdepth:
for link in get_link(html):
if re.match(link_res,link):
link=parse.urljoin(seed_url,link)
if link not in seen:#先筛选符合条件的link，再进行筛选是否看过，这个顺序能减少工作量。
crawl_queue.append(link)
seen[link]=dept+1#新加入的网址都要在原来的深度上加一
else:
print('Blocked by robots.txt',url)
print(seen,links)
def get_link(html):
webpage_patt=re.compile('<a[^>]+href=["\'](.*?)["\']',re.IGNORECASE)
return webpage_patt.findall(html.decode())#返回一个包含所以页面link的列表
link_crawler('http://example.webscraping.com','/(index|view)',delay=1,maxdepth=-1)
2.下面考虑怎么把数据通过Cache类存在磁盘的实际空间中。
*不同url需要保存在不同路径中，所以要建立url到文件名的映射关系。
import re,os
from urllib import parse
class Diskcache:
def __init__(self,cache_dir='d:\\1'):
self.cache_dir=cache_dir
def urltopath(self,url):
'''
创建一个把url转换为储存路径的函数
'''
#对以/结尾的网址命名，如果转换为路径，那么文件的名字就是空的。所以对这样的网址后面都加上index.html
ParseResult=parse.urlparse(url)
path=ParseResult.path
if not path:
path='/index.html'
elif path.endswith('/'):
path+='index.html'
filename=ParseResult.netloc+path+ParseResult.query
#对url进行修改，以满足Windows的文件命名规则
filename=re.sub('[^/0-9a-zA-Z\,.;_ ]','_',filename)
#对各级目录的长度进行规定，长的进行切片
filename='/'.join([segment[:250] for segment in filename.split('/')])
return os.path.join('cache'，filename)
3.还缺少数据写入磁盘和读取的方法。
在Downloader类中是通过
1在初始化中进行实例化
self.cache=Diskcache()
2在回调函数中
result=self.cache[url]来查询数据
self.cache[url]=result来存储数据
很自然想到的是用setitem()和getitem()
import os,re,pickle
from urllib import parse
class Diskcache:
def __init__(self,cache_dir='d:\\1'):
self.cache_dir=cache_dir
def urltopath(self,url):
'''
创建一个把url转换为储存路径的函数
'''
#对以/结尾的网址命名，如果转换为路径，那么文件的名字就是空的。所以对这样的网址后面都加上index.html
ParseResult=parse.urlparse(url)
path=ParseResult.path
if not path:
path='/index.html'
elif path.endswith('/'):
path+='index.html'
filename=ParseResult.netloc+path+ParseResult.query
#对url进行修改，以满足Windows的文件命名规则
filename=re.sub('[^/0-9a-zA-Z\,.;_ ]','_',filename)
#对各级目录的长度进行规定，长的进行切片
filename='\\'.join([segment[:250] for segment in filename.split('/') if segment])
return os.path.join(self.cache_dir,filename)
def __getitem__(self,url):
fullpath=self.urltopath(url)
if not os.path.exists(fullpath):
raise KeyError(url+'does not exist')
with open(fullpath,'rb') as f:
return pickle.loads(f.read())
def __setitem__(self,url,result):
fullpath=self.urltopath(url)
dirname=os.path.dirname(fullpath)#文件名的路径名（绝对路径=路径名+文件名）
if not os.path.exists(dirname):
os.makedirs(dirname)#建立文件目录
with open(fullpath,'wb') as f:
f.write(pickle.dumps(result))
4.运行了一次后，想重新下载也不行了，加入clear方法用来清楚所以缓存。
class Diskcache:
def clear(self):
if os.path.exists(self.cache_dir):
shutil.rmtree(self.cache_dir)
加入后完整代码文件见
（3）下载缓存的爬虫.py
5.给下载的html加上时间戳
from datetime import datetime,timedelta
class Diskcache:
def __init__(self,cache_dir='d:\\1',expiretime=timedelta(days=1)):
self.cache_dir=cache_dir
self.expiretime=expiretime
def urltopath(self,url):
'''
创建一个把url转换为储存路径的函数
'''
#对以/结尾的网址命名，如果转换为路径，那么文件的名字就是空的。所以对这样的网址后面都加上index.html
ParseResult=parse.urlparse(url)
path=ParseResult.path
if not path:
path='/index.html'
elif path.endswith('/'):
path+='index.html'
filename=ParseResult.netloc+path+ParseResult.query
#对url进行修改，以满足Windows的文件命名规则
filename=re.sub('[^/0-9a-zA-Z\,.;_ ]','_',filename)
#对各级目录的长度进行规定，长的进行切片
filename='\\'.join([segment[:250] for segment in filename.split('/') if segment])
return os.path.join(self.cache_dir,filename)
def __getitem__(self,url):
fullpath=self.urltopath(url)
if not os.path.exists(fullpath):
raise KeyError(url+'does not exist')
with open(fullpath,'rb') as f:
result,timestamp=pickle.loads(f.read())
if self.cache__is__expired(timestamp):
raise KeyError(url+ 'has expired')
return result
def __setitem__(self,url,result):
fullpath=self.urltopath(url)
dirname=os.path.dirname(fullpath)#文件名的路径名（绝对路径=路径名+文件名）
if not os.path.exists(dirname):
os.makedirs(dirname)#建立文件目录
timestamp=datetime.now()
result=(result,timestamp)
with open(fullpath,'wb') as f:
f.write(pickle.dumps(result))
def cache__is__expired(self,timestamp):
return datetime.now()>self.expiretime+timestamp
总结：该爬虫运用了
1.Downloader类————下载网页html数据
2.Diskcache类————存储下载的html数据
3.ScrapeCallback类————用来对页面数据进行分析，抓取有用信息，并保存。
4.Timedelay类————用来限制下载速度
5.用了队列的方法pop和append进栈出栈加上while 进行对所有目标遍历。
