【前言】
# 本脚本用来爬取jd的页面：http://list.jd.com/list.html?cat=737,794,870到
# ......http://list.jd.com/list.html?cat=737,794,870&page=11&JL=6_0_0的所有html的内容和图片。
# 本脚本仅用于技术交流，请勿用于其他用途
# by River
# qq : 179621252
# Date : 2014-12-02 19:00:00【需求说明】
以京东为示例，爬取页面的，获取页面中得数据：记录到data.txt；获取页面中得图片，保存下来。
1、list的url如下
2、商品详情页的url如下：
【技术说明】
使用了python的以下库
import os#检查文件是否存在等
from HTMLParser import HTMLParser#用于解析html的库，有坑：如果2.6的python，可能悲剧
import httplib,re#发起http请求
import sys,json,datetime,bisect#使用了二分快速查找
from urlparse import urlparse#解析url，分析出url的各部分功能
from threading import Thread#使用多线程
import socket #设置httplib超时时间【代码逻辑说明】
1、run（获取最终要的结果）
2、parseListpageurl：返回list的总共的页面数量
3、judgelist：判断该list是否已经爬取完毕了，第一个list中的所有url、最后list的所有url都爬取完毕了，那么久说明list的所有page爬取完毕了（实际上是一种弱校验）
4、getfinalurl_content：如果list没爬取完毕，每个list爬取，解析list中得每个html（判断html是否爬取过），获得内容和img
【坑说明】
1、需要设置超时时间，和重试，否则爬取一个url卡住的时候，整个线程都悲剧了。
2、有编码的坑，如果页面是gb2312的编码，需要转换为utf-8的编码：httprestmp.decode('gbk').encode('utf-8')
3、parser.feed的内容，如果存在一些特殊字符，可能需要替换，否则解析出来会莫名不对
4、图片保存，根据url获取前面两个数字，保存。以免一个目录下保存了过多的图片。
【执行结果】
1、console输出
2、data.txt存储解析出来的内容
3、judegurl.txt（保存已经爬取过的url）
4、图片（下载的图片）
【代码详情】
# -*- coding: utf-8 -*-
__author__ = 'River'
# 本脚本用来爬取jd的页面：http://list.jd.com/list.html?cat=737,794,870到
# ......http://list.jd.com/list.html?cat=737,794,870&page=11&JL=6_0_0的所有html的内容和图片。
# 本脚本仅用于技术交流，请勿用于其他用途
# by River
# qq : 179621252
# Date : 2014-12-02 19:00:00
import os#创建文件
from HTMLParser import HTMLParser#用于解析html的库，有坑：如果2.6的python，可能悲剧
import httplib,re#发起http请求
import sys,json,datetime,bisect#使用了二分快速查找
from urlparse import urlparse#解析url，分析出url的各部分功能
from threading import Thread#使用多线程
import socket #设置httplib超时时间
#定义一个ListPageParser，用于解析ListPage，如http://list.jd.com/list.html?cat=737,794,870
#htmlparser的使用简介
#定义intt方法：需要使用到得属性
#定义handle_starttag，处理你想分析的tag的具体操作
#定义handle_data，遇到你定义的情况，获取相应标签的data
#定义你获取最终返回的各种数据
class ListPageParser(HTMLParser):
def __init__(self):
self.handledtags=['a']
self.processing=None
self.flag=''
self.link=''
self.setlinks=set()##该list页面中包含的每个商品的url，定义为set，主要是为了使用其特性：去重
self.pageNo=1
self.alldata=[]
self.lasturl=""#指的最后一页的url如10
HTMLParser.__init__(self)
def handle_starttag(self, tag, attrs):
pattern = re.compile(r'^[0-9]{2,}')
pattern2=re.compile(r'^http:\/\/item.jd.com\/\d{1,10}.html$')#取出link
pattern3=re.compile(r'^http:\/\/list.jd.com\/list.html\?cat=\d{0,9}%2C\d{0,9}%2C\d{0,9}&page=*')#取出link
#attrs是属性的list，每个属性（包含key，value）又是一个元组
#创维酷开(coocaa) K50J 50英寸八核智能wifi网络安卓平板液晶电视(黑色)
#已上为例子：判断了该list的长度为3（其他的a标签就被过滤了）
if tag in self.handledtags and len(attrs)==3 :#非常关键的是，找出你想的url和不想要的url的区别
#print "debug:attrs",attrs
self.flag=''
self.data=''
self.processing=tag
for target,href in attrs:#非常关键的是，找出你想的url和不想要的url的区别
if pattern2.match(href):#再加一层判断，如果匹配上pattern2，说明是我们想要的url
self.setlinks.add(href)
else:
pass
#怎样获取list中最后一页的url？分析吧：10
#1、长度为1
#2，href是由规则的：cat=737%2C794%2C798&page=10&JL=6_0_0，所以，以下代码就出来了
if tag in self.handledtags and len(attrs)==1 :
self.flag=''
self.data=''
self.processing=tag
for href,url in attrs:#非常关键的是，找出你想的url和不想要的url的区别
#print 'debug:attrs',attrs
if pattern3.match(url):
#print 'debug:url',url
self.lasturl=url
else:
pass
def handle_data(self, data):
if self.processing:#去掉空格
pass#其实这里我们根本没使用获取到得data，就pass把
else:
pass
def handle_endtag(self, tag):
if tag==self.processing:
self.processing=None
def getlinks(self):
return self.setlinks
def getlasturl(self):
return self.lasturl
#定义一个FinallPageParser，用于解析最终的html页面，如http://item.jd.com/1258277.html
#FinallPageParser的定义过程参考上个parser，关键是怎样分析页面，最终写出代码，并且验证，这里就不详细说了
class FinallPageParser(HTMLParser):
def __init__(self):
self.handledtags=['div','h1','strong','a','del','div','img','li','span','tbody','tr','th','td','i']
self.processing=None
self.title=''
self.jdprice=''
self.refprice=''
self.partimgs_show=set()#展示图片
self.partimgs=set()#详情图片
self.partdetail={}#商品详情，参数等
self.specification=[]#规格参数
self.typeOrsize=set()#尺码和类型
self.div=''
self.flag={}
self.flag['refprice']=''
self.flag['title']=''
self.flag['jdprice']=''
self.flag['typeOrsize']=''
self.flag['partimgs']=''
self.flag['partdetail']=''
self.flag['specification']=''
self.flag['typeOrsize']=''
self.link=''
self.partslinks={}
HTMLParser.__init__(self)
def handle_starttag(self, tag, attrs):
self.titleflag=''
self.flag['refprice']=''
self.flag['title']=''
self.flag['jdprice']=''
self.flag['typeOrsize']=''
self.flag['partimgs']=''
self.flag['partdetail']=''
self.flag['specification']=''
self.flag['typeOrsize']=''
if tag in self.handledtags:
self.data=''
self.processing=tag
if tag=='div':
for key,value in attrs:
self.div=value# 取出div的name，判断是否是所需要的图片等元素
if tag=='i':
self.flag['typeOrsize']='match'
if tag=='a' and len(attrs)==2:
tmpflag=""
for key,value in attrs:
if key=='href' and re.search(r'^http:\/\/item.jd.com\/[0-9]{1,10}.html$',value):
tmpflag="first"
if key=='title' and value!="":
tmpflag=tmpflag+"second"
if tmpflag== "firstsecond":
self.flag['typeOrsize']='match'
if tag=='h1':
self.flag['title']='match'
if tag=='strong' and len(attrs)==2:
for tmpclass,id in attrs:
if id=='jd-price':
self.flag['jdprice']='match'
if tag=='del':
self.flag['refprice']='match'
if tag=='li':
self.flag['partdetail']='match'
if tag=='th' or tag=='tr' or tag=='td' :#++++++++############################################879498.html td中有br的只取到第一个,需要把
喜欢为“”
self.flag['specification']='match'
if tag=='img' :
imgtmp_flag=''
imgtmp=''
for key,value in attrs:
if re.search(r'^http://img.*jpg|^http://img.*gif|^http://img.*png',str(value)) and (key=='src' or key=='data-lazyload'):
imgtmp=value
if key== 'width':############可能还有logo
if re.search(r'^\d{1,9}$',value):
if int(value)<=160:
imgtmp_flag='no'
break
if self.div=="spec-items" and imgtmp!='':
imgtmp=re.compile("/n5/").sub("/n1/",imgtmp)
self.partimgs_show.add(imgtmp)
elif imgtmp_flag!='no' and imgtmp!='':
self.partimgs.add(imgtmp)#
def handle_data(self, data):
if self.processing:
self.data+=data
if self.flag['title']=='match':#获取成功
self.title=data
if self.flag['jdprice']=='match':
self.jdprice=data.strip()
if self.flag['typeOrsize']=='match':
self.typeOrsize.add(data.strip())
if self.flag['refprice']=='match':
self.refprice=data.strip()
if self.flag['partdetail']=='match' and re.search(r'：',data):#获取成功
keytmp=data.split("：")[0].strip()
valuetmp=data.split("：")[1].strip()
self.partdetail[keytmp]=valuetmp
if self.flag['specification']=='match' and data.strip() != '' and data.strip()!='主体':
self.specification.append(data.strip())
else:
pass
def handle_endtag(self, tag):
if tag==self.processing:
self.processing=None
def getdata(self):
return {'title':self.title,'partimgs_show':self.partimgs_show,'jdprice':self.jdprice,'refprice':self.refprice,'partimgs':self.partimgs,'partdetail':self.partdetail,'specification':self.specification,'typeOrsize':self.typeOrsize}
#定义方法httpread，用于发起http的get请求，返回http的获取内容
#这也是代码抽象的结果，如若不抽象这块代码出来，后续你回发现很多重复的写这块代码
def httpread(host,url,headers):
httprestmp=''
try:
conn = httplib.HTTPConnection(host)
conn.request('GET',url,None,headers)
httpres = conn.getresponse()
httprestmp=httpres.read()
except Exception,e:
conn = httplib.HTTPConnection(host)
conn.request('GET',url,None,headers)
httpres = conn.getresponse()
httprestmp=httpres.read()
print e
finally:
if conn:
conn.close()
return httprestmp
#定义方法sendhttp，调用httpread，获取结果并替换编码（gbk换为utf-8），并保存到文件中（以免下次再去下载页面，这样就节省了时间）
#
def sendhttp(url,host,savefile):
#定义http头部，很多网站对于你不携带User-Agent及Referer等情况，是不允许你爬取。
#具体的http的头部有些啥信息，你可以看chrome，右键审查元素，点击network，点击其中一个链接，查看request header
headers = {"Host":host,
"Origin":"http://www.jd.com/",
"Referer":"http://www.jd.com/",
"Content-type": "application/x-www-form-urlencoded; charset=UTF-8",
"Accept": "text/html;q=0.9,p_w_picpath/webp,*/*;q=0.8",
"User-Agent":"Mozilla/3.0 AppleWebKit/537.36 (KHTML,Gecko) Chrome/3.0.w4.",
"Cookie":"__utmz=qwer2434.1403499.1.1.utmcsr=www.jd.com|utmccn=(refrral)|utmcmd=rferral|utmcct=/order/getnfo.action; _pst=xx89; pin=x9; unick=jaa; cshi3.com=D6045EA24A6FB9; _tp=sdyuew8r9e7r9oxr3245%3D%3D; user-key=1754; cn=0; ipLocation=%u7F0C; ipLoc97; areaId=1; mt_ext2%3a%27d; aview=6770.106|68|5479.665|675.735|6767.100|6757.13730|6ee.9ty711|1649.10440; atw=65.15.325.24353.-4|188.3424.-10|22; __j34|72.2234; __jdc=2343423; __jdve|-; __jdu=3434"
}
httprestmp=''
try:
httprestmp=httpread(host,url,headers)
if httprestmp=='':#
httprestmp=httpread(host,url,headers)
if httprestmp=='':#重试2次
httprestmp=httpread(host,url,headers)
except Exception,e:
try:
httprestmp=httpread(host,url,headers)
if httprestmp=='':#
httprestmp=httpread(host,url,headers)
if httprestmp=='':#重试2次
httprestmp=httpread(host,url,headers)
except Exception,e:
print e
print e
if re.search(r'charset=gb2312',httprestmp):#如果是gb2312得编码，就要转码为utf-8（因为全局都使用了utf-8）
httprestmp.replace("charset=gb2312",'charset=utf-8')
try:
httprestmp=httprestmp.decode('gbk').encode('utf-8')#有可能转码失败，所以要加上try
except Exception,e:#如果html编码本来就是utf8或者转换编码出错的时候，就啥都不做，就用原始内容
print e
try:
with open(savefile, 'w') as file_object:
file_object.write(httprestmp)
file_object.flush()
except Exception,e:
print e
return httprestmp
#list的页面的解析方法
def parseListpageurl(listpageurl):
urlobj=urlparse(listpageurl)
if urlobj.query:
geturl=urlobj.path+"?"+urlobj.query
else:
geturl=urlobj.path
htmlfile="html/list"+geturl
if not os.path.exists(htmlfile):
httpresult=sendhttp(geturl,urlobj.hostname,htmlfile)
with open(htmlfile) as file:
htmlcontent=file.read()
parser= ListPageParser()#声明一个解析对象
#http://list.jd.com/list.html?cat=737%2C794%2C870&page=11&JL=6_0_0,所以这里需要把'amp;'去掉
parser.feed(htmlcontent.replace('amp;',''))#将html的内容feed进去
#print 'debug:htmlcontent',htmlcontent
finalparseurl=parser.getlinks()#然后get数据即可
lastpageurl=parser.getlasturl()
urlobj_lastpageurl=urlparse(lastpageurl)
#print 'debug:urlobj_lastpageurl',urlobj_lastpageurl
totalPageNo='0'
#print urlobj
if re.search(r'&',urlobj_lastpageurl.query):
try:
totalPageNo=urlobj_lastpageurl.query.split("&")[1].split("=")[1]#获得总共有多少页
except Exception,e:
print "lastpageurl:"+str(lastpageurl)
print e
parseListpageurl_rult={'finalparseurls':finalparseurl,'totalPageNo':totalPageNo}
if parseListpageurl_rult['finalparseurls'] !="" and parseListpageurl_rult['totalPageNo']!='':
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",parse listpageurl succ:"+listpageurl
else:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",parse listpageurl fail:"+listpageurl
return parseListpageurl_rult
#最终的html页面的解析方法：会使用到html得解析器FinallPageParser
def parseFinallyurl(finallyurl):
urlobj=urlparse(finallyurl)
geturl=urlobj.path
htmlfiledir="html/finally/"+geturl.split('/')[1][0:2]
if not os.path.exists(htmlfiledir):
try:
os.makedirs(htmlfiledir)
except Exception,e:
print e
htmlfile=htmlfiledir+geturl
if not os.path.exists(htmlfile):
httpresult=sendhttp(geturl,urlobj.hostname,htmlfile)
if httpresult:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",sent http request succ,Finallyurl:"+finallyurl
else:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",sent http request fail,Finallyurl:"+finallyurl
with open(htmlfile) as file:
htmlcontent=file.read()
parser= FinallPageParser()
##htmmparser遇到/>就表示tag结尾，所以必须替换，遇到
替换为BRBR，否则会解析失败
htmlcontent=re.compile('
').sub('BRBR',htmlcontent)
parser.feed(htmlcontent)
finalparseurl=parser.getdata()
if finalparseurl:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",parse finalparseurl succ:"+finallyurl
else:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",parse finalparseurl fail:"+finallyurl
return finalparseurl
#获取图片的方法
def getimg(imgdir,imgurl):
imgobj=urlparse(imgurl)
getimgurl=imgobj.path
imgtmppathlist=getimgurl.split('/')
imgname=imgtmppathlist[len(imgtmppathlist)-1]
if not os.path.exists(imgdir):
try:
os.makedirs(imgdir)
except Exception,e:
print e
savefile=imgdir+"/"+imgname
if not os.path.exists(savefile):
sendhttp_rult=sendhttp(getimgurl,imgobj.hostname,savefile)
if sendhttp_rult:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",sent http request succ,getimg:"+imgurl
else:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",sent http request fail,getimg:"+imgurl
else:
pass
#获取价格
def getprice(pricedir,priceurl):
priceobj=urlparse(priceurl)
getpriceurl=priceobj.path+"?"+priceobj.query
pricename="price"
if not os.path.exists(pricedir):
try:
os.makedirs(pricedir)
except Exception,e:
print e
savefile=pricedir+"/"+pricename
if not os.path.exists(savefile):
sendhttp_rult=sendhttp(getpriceurl,priceobj.hostname,savefile)
if sendhttp_rult:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",sent http request succ,getprice:"+priceurl
else:
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+",sent http request fail,getprice:"+priceurl
else:
pass
with open(savefile) as file:
price_content=file.read()
price_content=re.compile('cnp\\(\\[|\\]\\);').sub('',price_content)
price_dic={"id":"0","p":"0","m":"0"}
if re.search(r':',price_content):
try:
price_dic=json.loads(price_content)#以免数据格式不对悲剧
except Exception,e:
print e
return {"jdprice":price_dic['p'],'refprice':price_dic['m']}
#获取最后页面的具体内容
def getfinalurl_content(partlists,listpageurl,finalparseurl):
parseFinallyurl_rult=parseFinallyurl(finalparseurl)
htmlname_tmp=urlparse(finalparseurl).path
imgtopdir_tmp="img/"+htmlname_tmp.split('/')[1][0:2]
imgdir=imgtopdir_tmp+htmlname_tmp+"/introduction"
imgshowdir=imgtopdir_tmp+htmlname_tmp+"/show"
partdetail_tmp=""
for imgurl in parseFinallyurl_rult['partimgs']:#获取商品介绍的图片
getimg(imgdir,imgurl)
for imgshowurl in parseFinallyurl_rult['partimgs_show']:#获取展示图片
getimg(imgshowdir,imgshowurl)
for key in parseFinallyurl_rult['partdetail'].keys():
partdetail_tmp=partdetail_tmp+key+"$$"+parseFinallyurl_rult['partdetail'][key]+","#商品介绍
specification_tmp=""
i=0
for specification_var in parseFinallyurl_rult["specification"]:#规格参数
if i==0:
str_slip=""
elif(i%2==0 and i!=0 ):
str_slip=","
else:
str_slip="$$"
specification_tmp=specification_tmp+str_slip+specification_var
i=i+1
typeOrsize_tmp=""
for typeOrsize_var in parseFinallyurl_rult['typeOrsize']:
typeOrsize_tmp=typeOrsize_tmp+","+typeOrsize_var
priceurl="http://p.3.cn/prices/get?skuid=J_"+htmlname_tmp.split('/')[1].split('.')[0]+"&type=1&area=6_309_312&callback=cnp"
pricedir="price/"+htmlname_tmp.split('/')[1][0:2]+htmlname_tmp
getprice_dic=getprice(pricedir,priceurl)
parseFinallyurl_rult["jdprice"]=getprice_dic['jdprice']
parseFinallyurl_rult["refprice"]=getprice_dic['refprice']
#partlists[listpageurl])：商品分类
#finalparseurl，页面的url
#parseFinallyurl_rult["title"])：标题
#parseFinallyurl_rult["jdprice"]：京东的价格
#parseFinallyurl_rult["refprice"]：市场参考价格
#imgshowdir：商品展示的图片保存位置
#imgdir：商品说明的图片保存位置：jd的商品说明也是用图片的
#partdetail_tmp:商品的详细信息
#specification_tmp:商品的规则参数
#typeOrsize_tmp:商品的类型和尺寸
return str(partlists[listpageurl]).strip()+"\t"+finalparseurl.strip()+"\t"+str(parseFinallyurl_rult["title"]).strip()+"\t"+str(parseFinallyurl_rult["jdprice"]).strip()\
+"\t"+str(parseFinallyurl_rult["refprice"]).strip()+"\t"+imgshowdir.strip()+"\t"+imgdir.strip()+"\t"+partdetail_tmp.strip()+"\t"+specification_tmp.strip()+"\t"+\
typeOrsize_tmp.strip()
#判断最后的页面（商品详情页）是否被爬取了
def judgeurl(url):#优化后，使用二分法查找url(查找快了，同时也不用反复读取文件了)。第一次加载judgeurl_all_lines之后，维护好此list，同时新增的url也保存到judgeurl.txt中
url=url+"\n"
global judgeurl_all_lines
find_url_flag=False
url_point=bisect.bisect(judgeurl_all_lines,url)#这里使用二分法快速查找（前提：list是排序好的）
find_url_flag = judgeurl_all_lines and judgeurl_all_lines[url_point-1] == url
return find_url_flag
#判断list页面是否已经爬取完毕了
#这里的逻辑是：第一个list中的所有url、最后list的所有url都爬取完毕了，那么久说明list的所有page爬取完毕了（实际上是一种弱校验）。
#调用了judgeurl得方法
def judgelist(listpageurl,finallylistpageurl):#判断第一个、最后一个的list页面的所有的html是否下载完毕，以此判断该类型是否处理完毕
judgelist_flag=True
parseListpageurl_rult_finally=parseListpageurl(finallylistpageurl)
finalparseurls_deep_finally=list(parseListpageurl_rult_finally['finalparseurls'])#获取到最后的需要解析的url的列表
parseListpageurl_rult_first=parseListpageurl(listpageurl)
finalparseurls_deep_first=list(parseListpageurl_rult_first['finalparseurls'])#获取到最后的需要解析的url的列表
for finalparseurl in finalparseurls_deep_finally:
#print finalparseurl
if judgeurl(finalparseurl):
pass
else:
judgelist_flag=False
break
if judgelist_flag==True:
for finalparseurl_first in finalparseurls_deep_first:
#print finalparseurl
if judgeurl(finalparseurl_first):
pass
else:
judgelist_flag=False
break
return judgelist_flag
#整体控制的run方法
def run():
partlists={'http://list.jd.com/list.html?cat=737,794,870':'空调'}
partlistskeys=partlists.keys()
for listpageurl in partlistskeys:
parseListpageurl_rult=parseListpageurl(listpageurl)#开始解析list页面，如：http://list.jd.com/list.html?cat=737,794,870
totalPageNo=parseListpageurl_rult['totalPageNo']#获取该list总共有多少页
#print 'debug:totalPageNo',totalPageNo
finallylistpageurl=listpageurl+'&page='+str(int(totalPageNo)+1)+'&JL=6_0_0'#拼接出最后一个list页面（list页面有1、2、3。。。n页）
#print 'debug:finallylistpageurl ',finallylistpageurl
if judgelist(listpageurl,finallylistpageurl):#如果该list已经爬取完毕了。那么，就跳过这个list
print datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")+',All html done for '+str(listpageurl)+":"+str(partlists[listpageurl])+"【Done Done】,【^_^】"
continue
else:#否则就逐个沿着list，从其第1页，开始往下爬取
for i in range(1,int(totalPageNo)+2):
finalparseurl=''
listpageurl_next=listpageurl+'&page='+str(i)+'&JL=6_0_0'
#print "debug:listpageurl_next",listpageurl_next
parseListpageurl_rult=parseListpageurl(listpageurl_next)
totalPageNo=parseListpageurl_rult['totalPageNo']#需要更行总的页面数量，以免数据陈旧
finalparseurls_deep=list(parseListpageurl_rult['finalparseurls'])
for finalparseurl in finalparseurls_deep:
if judgeurl(finalparseurl):#判断该具体的url是否已经爬取
print 'finalparseurl pass yet:'+finalparseurl
pass
else:
finalurl_content=getfinalurl_content(partlists,listpageurl,finalparseurl)
finalparseurl_tmp=finalparseurl+"\n"
with open("data.txt","a") as datafile:#将爬取完毕好的url写入data.txt
datafile.writelines(finalurl_content+"\n")
with open("judgeurl.txt","a") as judgefile:#将已经爬取好的url写入judgeurl.txt
judgefile.writelines(finalparseurl+"\n")
bisect.insort_right(judgeurl_all_lines,finalparseurl+"\n")
#主方法
if __name__ == '__main__':
reload(sys)
sys.setdefaultencoding('utf8')#设置系统默认编码是utf8
socket.setdefaulttimeout(5)#设置全局超时时间
global judgeurl_all_lines#设置全局变量
#不存在文件就创建文件,该文件用于记录哪些url是爬取过的，如果临时中断了，可以直接重启脚本即可
if not os.path.exists("judgeurl.txt"):
with open("judgeurl.txt",'w') as judgefile:
judgefile.close()
#每次运行只在开始的时候读取一次，新产生的数据（已怕去过的url）也会保存到judgeurl.txt
with open("judgeurl.txt","r") as judgefile:
judgeurl_all_lines=judgefile.readlines()
judgeurl_all_lines.sort()#排序，因为后面需要使用到二分查找，必须先排序
#启多个线程去爬取
Thread(target=run(),args=()).start()
Thread(target=run(),args=()).start()
#Thread(target=run(),args=()).start()