python爬虫笔记

创建文件夹

if not os.path.exists(word):
    os.mkdir(word)  

#pycharm ctrl+ r
#sublim ctrl+ h
#(.?): (.?)\n
#’\1’: ‘\2’,\n

切换pip下载来源
切换pip 源 国内很多优秀的源，比如豆瓣源， 阿里源
修改配置文件， 永久设置为国内源
windows:
在pip.ini文件里修改以下内容
[global]
timeout = 6000
index-url = http://pypi.douban.com/simple
trusted-host = pypi.douban.com
linux:
1.cd ~
2.mkdir ~/.pip
3.vi ~/.pip/pip.conf
4.编辑的内容和windows样的

requests模块
requests.get(…)
requests.post(…)
requests.request(‘post/get’,…)

• 参数
  requests.Session() 用于保存客户端历史访问信息
  requests.request
  • method: 提交方式
  • url: 提交地址
  • params: 在URL中传递的参数，GET data = {‘name’: ‘germey’ }
  • data: 在请求体里传递的数据，POST
  • json: 在请求体里传递的数据（字典中嵌套字典的时候使用）
  • headers: 请求头
  • cookies: 能放到headers里面
  • files: 上传文件
  • auth: 身份验证登录（路由器等|基本不用）
  • timeout: 等待服务器响应时间
  • proxies: 代理设置
  • stream: True缓慢下载/False
  • verify: False忽略证书/True
  • cert: 证书文件
  • allow_redirects: 是否允许重定向
• 返回信息
  • cookies.get_dict()： 返回的cookies信息
  • text - content - json() -encoding
    status_code属性得到状态码，输出headers属性得到响应头，输出cookies属性得到Cookies，输出url属性得到URL，输出history属性得到请求历史

http协议：
url组成部分： 协议，主机，端口，资源，参数，锚点
http:80
https:443
ftp:21
mysql:3306
redis:6379
mongodb:27017

urllib库
1.四大模块
urllib.request 用来模拟发送url请求
urllib.error 包含urllib.request抛出的异常
urllib.parse 用于处理 URL(拆分、解析、合并等)
urllib.robotparser用于解析robots.txt文件
2.get请求
import urllib.request
import urllib.parse
wd = input(“请输入关键字:”)
url = “https://www.baidu.com/s?”
#get传参
data = { “wd”:wd }
#处理参数
data = urllib.parse.urlencode(data)
#拼接url
url += data
#构建请求对象
headers = {“User-Agent”: “Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36” }
request = urllib.request.Request(url=url, headers=headers)
# 发送请求，获取响应
response = urllib.request.urlopen(request)
with open(filename.html, “wb”) as fp:
fp.write(response.read())
3.post请求
碰到form-data中有sign token 要进行加密 一定要加上所有的头信息
import urllib.request
import urllib.parse
post_url = “https://fanyi.baidu.com/sug”
word = input(“请输入您要查询的英文单词:”)
data= { “kw”:word }
#form-data 表单数据
#重点！！！一定要对表单数据进行处理，先转换为字符串，再转化为字节
data = urllib.parse.urlencode(data).encode(“utf8”)
#构建请求对象
headers = {“User-Agent”: “Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36” }
request = urllib.request.Request(post_url, headers=headers)
# 发送请求，获取响应
response = urllib.request.urlopen(request, data=data)
4.ajax-get请求
import urllib.request
import urllib.parse
url = “https://movie.douban.com/j/chart/top_list?type=11&interval_id=95%3A85&action=&”
page = int(input(“请输入第几页的电影:”))
start = (page - 1)*10
limit = 10
data = { “start”:start, “limit”:limit }
#处理data
data = urllib.parse.urlencode(data)
url += data
headers = { “User-Agent”: “Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36”}
request = urllib.request.Request(url=url,headers=headers)
response = urllib.request.urlopen(request)
print(response.read().decode(“utf8”))
5.ajax-post请求
import urllib.request
import urllib.parse
cname = input(“请输入你要查询的城市:”)
post_url = “http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=keyword”
data = {“cname”: “”,“pid”:"", “keyword”: cname,“pageIndex”: “1”,“pageSize”: “10”}
data = urllib.parse.urlencode(data).encode(“utf8”)
headers = {
“User-Agent”: “Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36”
}
request = urllib.request.Request(post_url,headers=headers)
response = urllib.request.urlopen(request, data=data)
print(response.read().decode(“utf8”))
6.URLError和HTTPError
异常处理的类，都是在urllib.error
URLError:访问不存在的域名，会触发
HTTPError：访问不存在页面的时候，会触发
作用：使咱们的代码更加健壮
try:
response =urllib.request.urlopen(url)
except urllib.error.HTTPError as e:
print(“页面走丢了！！！”)
7.代理
代理是什么？代驾，代购，代练
程序中代理服务器：快代理，西祠代理，阿布云代理，芝麻代理
(1):浏览器设置代理ip
三个点-》设置-》高级设置-》打开代理设置-》链接-》局域网设置-》
为wlan设置代理服务器,输入ip和端口号即可
!!!注意！！！！！！！ 设置完代理ip，不用的时候一定要关闭
(2):代码如何设置
#就需要使用到handler
handler = urllib.request.ProxyHandler(proxies={“http”:“59.32.37.28:8010”})
#根据handler创建一个opener
opener = urllib.request.build_opener(handler)
response = opener.open(url)
8.cookies
#让代码来保存cookie
import http.cookiejar
#1.c创建一个cookiejar的对象， 用来保存cookie
ck = http.cookiejar.CookieJar()
#2.根据Cookiejar对象创建一个handler
handler = urllib.request.HTTPCookieProcessor(ck)
#3.根据handler创建opener
opener = urllib.request.build_opener(handler)
#再往下所有的请求都是用opener.open（）
#在登录的时候，服务器会返回cookie值
#先使用登录的接口，把cookie获取到
post_url = “http://www.renren.com/ajaxLogin/login?1=1&uniqueTimestamp=2019331011943”
data = {
‘email’: ‘18203601672’,
‘icode’: ‘’,
‘origURL’: ‘http://www.renren.com/home’,
‘domain’: ‘renren.com’,
‘key_id’: ‘1’,
‘captcha_type’: ‘web_login’,
‘password’: ‘4ef01c2a9c67a3de85f1b6d642355d02cf35e08e20561ac9a66ca1ae2918f787’,
‘rkey’: ‘44004bcb0ca18674fda556afec101a93’,
‘f’:’’
}
data = urllib.parse.urlencode(data).encode()
headers = {
‘User-Agent’: ‘Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36’,
}
#创建请求对象
request = urllib.request.Request(url=post_url, headers=headers)
#关键的一步open的一瞬间就把cookie保存起来了
response = opener.open(request, data = data)
#登录以后，随便的一个url都可以，向这个url发送请求的时候，opener都带有cookie
get_url = “http://www.renren.com/969334012/profile”
request1 = urllib.request.Request(url=get_url, headers=headers)
r = opener.open(request1)

正则匹配
单个字符的匹配：
\d：所有的数字字符
\D:除了\d(非数字字符)
\s:匹配所有的空白字符 \t \n \r 空格
\S:除了\s(非空格字符)
\w:匹配数字，字母,下划线，中文
\W:除了\w
.:除了换行符以外的所有字符
[]:[0-5] [a-z] 范围
^:抑扬符 以xxx为开头
$:以xxx结尾
(ab){5}:小括号视为一个整体
数量的修饰：
1aaaaaaaaaaaa
\da{5,8}
{5}:修饰前面的一个字符出现的次数
{5,}:至少5次，能匹配多少就匹配多少啊
{5,8}：至少5次，最多8次
{0,}：任意多次， *
{1,}:至少匹配1次， +
{0,1}：可有可无 ？

延伸的用法：.* 都能匹配（换行不行），长度不限
           .+ 得有一个我才能正确匹配

贪婪：
.*?(重点)
.+?
模式修正符：
re.I:忽略大小写
re.S:视为单行模式（重要）
re.M:视为多行模式

BeautifulSoup模块
pip install bs4
pip install lxml
from bs4 import BeautifulSoup
#将网页生成一个对象
html_doc = requests.get(url=‘http://www.baidu.com’)
soup = BeautifulSoup(html_doc,‘lxml’) html.parser
1.根据标签进行查找
tag = soup.a #找到第一个a标签
# string/text/get_text() 获取文本的内容
# name属性获取节点的名称
# attrs获取所有属性 attrs[‘name’]
2.函数查找
tag1 = soup.find(‘a’) # 找到第一个a标签
tag2 = soup.find_all(‘a’) # 找到所有的a标签
tag3 = soup.find_all(‘a’,‘title’) # 查找所有a标签中class=‘title’的语句（class是关键字,可以用class_）
tag4 = soup.find_all(“a”,title=“su”) # 查找所有a标签中title=‘su’的语句
tag5 = soup.find_all(‘a’,id=‘link2’) # 查找所有a标签中id=link2的标签
tag6 = soup.select(’#link2’) # 查找所有a标签中id=link2的标签
# 找到name属性值为_xsrf的input标签，并获取其相应的value值
xsrf = bs.find(“input”,attrs={“name”:"_xsrf"}).get(“value”)
soup.find_all(text=re.compile(‘link’))
find_all(name , attrs , recursive , text , **kwargs)

xpath模块
xml和html的区别：
1.一个是用来传输数据的，一个是用来显示数据的
2.xml是可以自己定义标签的，html是系统封装好的标签
xpath用来在xml 数据通过路径表达式，来提取指定的数据
xpath使用:
from lxml import etree
html = etree.HTML(text)
html.xpath(’//li/a/@href’) 属性获取
html.xpath(’//li[@class=“item-0”]’) 属性匹配
html.xpath(’//li[contains(@class, “li”)]/a/text()’) 属性多值匹配 第一个参数传入属性名称，第二个参数传入属性值，只要此属性包含所传入的属性值
html.xpath(’//li[@class=“item-0”]/text()’) 文本获取
html.xpath(’//li[contains(@class, “li”) and @name=“item”]/a/text()’) 多属性匹配
xpath的路径指向
/ :从根节点开始寻找
//:从任何位置开始寻找
. :当前节点
…:父节点
@ :选取属性
bookstore/book :在bookstore下面book节点，是直接的子节点
//book :文档中所有的book节点
boostore//book :找到bookstore下面的所有的book节点
//@lang :查到所有的lang属性的节点
bookstore/book[1]:找第一个子节点
bookstore/book[last()] :找到最后一个子节点
bookstore/book[position() < 3]:取前两个的book节点
bookstore//book[1] :所有的book第一个
//title[@lang] :找到所有的有lang属性的title
//title[@lang=‘eng’] :找到所有的有lang属性的title 并且lang=‘eng’
bookstore/* :找到所有bookstore 节点

selenium+phantomjs
selenium
浏览器自动化测试工具，通过selenium写代码，去执行代码
谷歌驱动的下载地址：
http://chromedriver.storage.googleapis.com/index.html
谷歌驱动和谷歌浏览器关系的对应表：
https://blog.csdn.net/huilan_same/article/details/51896672
浏览器有几个函数需要大家记：
find_element_by_id :根据id来进行查找
find_element_by_name :根据name查找元素，返回的是一个列表
find_element_by_xpath :根据xpath来查找这个元素
find_element_by_tag_name :根据标签的名字来查找元素
find_element_by_class_name :根据类名查找
find_element_by_css_selector:根据css选择器来查找
find_element_by_link_text :根据内容查找a链接
from selenium import webdriver
browser = webdriver.Chrome(executable_path=’’)
browser.get(‘https://www.taobao.com’)
input_first = browser.find_element_by_id(‘q’)
input_first = browser.find_element_by_name(‘q’)
input_secon = browser.find_element_by_css_selector(’#q’)
input_third = browser.find_element_by_xpath(’//*[@id=“q”]’)
input_third = browser.find_element_by_link_text(‘测试’)
# 输入文字用send_keys()方法
input = browser.find_element_by_id(‘q’)
input.send_keys(‘iPhone’)
# 清空文字时用clear()方法
input.clear()
# 点击按钮时用click()方法
button.click()
# back()方法后退，使用forward()方法前进
# close()方法关闭浏览器
phantomjs(停止维护)
是一款浏览器，是一款无界面的浏览器，既然是一个浏览器，他就应该具备
浏览器的功能，响应的内容是html，css，js，浏览器是可以翻译成图文并茂
并且最重要的是执行js代码！！！
browser = webdriver.PhantomJS(executable_path=path)
#打开百度
browser.get(‘https://www.baidu.com/’)
time.sleep(3)
#拍照片，通过拍照片，查看走到哪里了？
browser.save_screenshot("./pic/baidu1.png")

headlesschrome（无界面浏览器）
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import time
chrome_options = Options()
#这个是对谷歌浏览器的一些设置，设置谷歌浏览为无界面的
chrome_options.add_argument(’–headless’)
chrome_options.add_argument("–disable-gpu")
path = r"C:\Users\10737\PycharmProjects\爬虫\selenium\ChromeDriver\chromedriver.exe"
browser = webdriver.Chrome(executable_path=path,chrome_options=chrome_options)
browser.get(“http://www.baidu.com/”)
time.sleep(3)
browser.save_screenshot("./pic/chrome.png")
browser.quit()

线程和进程
多任务:生活当中，在同时进行，比如吃着火锅唱着歌
操作系统：vnc 录屏，sublime 都在同时执行
代码里面：以唱歌，吃火锅为例，要实现多任务， 必须学习一个是进程，一个是线程

1.进程（process）：
进程：每一个软件启动起来就是一个进程，代码中，在没有运行之前，称之为程序，运行之后成为进程。
多进程：之前写代码的时候，就算是一个进程了，这个叫主进程。再创建其他进程称为子进程
进程之间是否能够共享局部变量：不共享
进程之间是否能够共享全局变量：不共享
面向过程的一种写法：
p = Process(target=, args= )
target:就是目标函数（新建的进程）
args：主进程给子进程进行传参，是一个元祖
p.start():启动进程
os.getpid:获取进程id
os.getppid:获取父进程id
p.join():主进程等待子进程结束以后再结束
案例：
from multiprocessing import Process
import time
import os
def sing(name):
print(“杰哥的女神为:%s”%name)
print(“唱歌的id%s”%os.getpid())
print(“唱歌的父进程的id为%s”%os.getppid())
for x in range(1,6):
print(“我在唱霍元甲”)
time.sleep(1)
def dance():
print(“跳舞的id%s”%os.getpid())
for x in range(1,6):
print(“我在跳钢管舞”)
time.sleep(1)
def main():
name = “刘慧娟”
print(“主进程的id号为:%s”%os.getpid())
p_sing = Process(target = sing, args=(name,))
p_dance = Process(target = dance)
#要启动进程
p_sing.start()
p_dance.start()

      p_sing.join()
      p_dance.join()
      #主进程里面有子进程的信息，如果写上join之后，主进程要等待子进程结束以后再结束
      print("主进程结束啦")
面向对象的一张写法：
  自定义的类一定要继承Process
  重写run方法，如果需要传递参数，通过构造方法进行传参
  进程池：
  规定能够能够创建的最大的进程数，始终使用这几个进程来处理数据
  pol = Pool(3):创建进程池
  pol.apply_async():向池中添加任务
  pol.close():关闭池子，意味着你不能再添加了
  pol.join():让主进程等待子进程执行完以后再结束
  案例：
    from multiprocessing import Process
    import time
    class SingProcess(Process):
      #手动调用父类的方法
      def __init__(self, name):
        super().__init__()
        self.name = name
      def run(self):
        print("传递的参数为%s"%self.name)
        for x in range(1,6):
          print("我在唱青藏高原")
          time.sleep(1)

    class DanceProcess(Process):
      def run(self):
        for x in range(1,6):
          print("我在跳肚皮舞")
          time.sleep(1)
    def main():
      name = "陈独秀"
      p_sing = SingProcess(name)
      p_dance = DanceProcess()
      p_sing.start()
      p_dance.start()
      p_sing.join()
      p_dance.join()
      print("主进程结束执行")

2.线程！！！！（重要！！！！）
线程：更加抽象，暴风影音:音频和视频同时播放,线程是在进程里面执行的，进程垮掉，线程随之消失
多线程是最好的一种选择：多线程：比多进程好,如果一个线程挂了，整个进程也就挂了真正的cpu在进行单位切换的时候，是以线程为单位的
线程能否共享全局变量：能
线程能否共享局部变量：不能
面向过程的编程：
和process非常类似
t = threading.Thread()
参数：target 目标函数
args 传的参数
t.start()：开启线程
t.join():让主进程等待子进程执行完以后再结束
threading.current_thread().name:获取线程的名字的
案例：
import threading
import time
def sing(name):
print(“接受的参数为%s”%name)
print(“sing线程的名字是%s”%threading.current_thread().name)
for x in range(1,20):
print(“我在唱dragon的传人”)
time.sleep(1)
def main():
name = “王力宏”
t_string = threading.Thread(target = sing, args = (name, ))
t_string.start()
t_string.join()
print(“主线程结束”)
面向对象的编程：
import threading
import time
class SingThread(threading.Thread):
def init(self, name):
super().init()
self.name = name
def run(self):
print(“传递过来的参数为%s”%self.name)
for x in range(1,6):
print(“我喜欢唱女人花”)
time.sleep(1)
class DanceThread(threading.Thread):
def run(self):
for x in range(1,6):
print(“跳街舞”)
time.sleep(1)
def main():
name = “旧时王谢堂前燕，飞入寻常百姓家”
t_sing = SingThread(name)
t_dance = DanceThread()
t_dance.start()
t_sing.start()
t_dance.join()
t_sing.join()
print(“主线程结束”)

Scrapy
认识一下框架：
框架有5部分组成：引擎，spiders,调度器（scheduler），下载器（downloader），管道
基本命令
scrapy startproject itcast # 创建一个scrapy项目
scrapy genspider itcast ‘itcast.cn’ # 创建爬虫
scrapy list # 查看当前有多少个爬虫
scrapy crawl 爬虫名 # 执行爬虫
scrapy crawl 爬虫名 -o 爬虫名.json 导出为json信息(4种类型) .json .csv .json1 .xml
目录结构
firstblood 工程目录
scrapy.cfg 没啥用
firstblood 项目目录
pycache python缓存的文件
init.py 包的标志
items.py 定义数据结构的地方（）
middlewares.py 中间件
pipelines.py 管道文件（）
settings.py 配置文件（）
spiders 爬虫文件存放的目录（）
pycache 缓存文件
init.py 包的标志
lala.py 爬虫文件（*）
注意：
1.取消准从robots协议 setting.py ROBOTS_OBEY=False
2.设置默认的user_agent头部
编写代码
a. name不能省略
b. start_urls,起始URL地址
c. allowed_domains = [‘xx.com’] 允许爬取的域名
d. 重写start_requests
def start_requests(self):
for url in urls:
yield scrapy.Request(url=url, callback=self.parse1)
e.响应的response
字符串格式的内容 response.text
字节格式的内容 response.body
提取网页的内容 response.xpath()返回的类型是一个对象
【注】：在scrapy里面已经集成了xpath和bs4,只需要使用即可
extract():如果xpath精确到内容或者属性的时候，一定要经过extract进行提取，将对象转化为字符串
f.Scrapy shell
scrapy shell是scrapy的终端调试工具，只要在这个地方写代码是对的，你把代码移植到你的scrapy项目
依赖第三方的库：pip install ipython
如何使用：
在终端输入一个命令：
scrapy shell url 一般都可以进来了
response直接可以使用
response.text:获取字符串内容的
response.url:获取当前的url
response.body:获取字节的内容
response.headers:获取当前头部
response.status:获取状态码
方法：
ret = response.xpath("//input[@id=‘su’]/@value")
ret 是一个对象，取值
ret[0].extract()===ret.extract()[0]====ret.extract_first()
POST请求
class FanyiSpider(scrapy.Spider):
name = ‘fanyi’
allowed_domains = [‘fanyi.baidu.com’]
#z这个只能是get请求的url
#start_urls = [‘http://699pic.com/food.html’]
#重写start_requests这个函数，你只要重写这个函数,p爬虫会立马启动post请求
def start_requests(self):
post_url = “https://fanyi.baidu.com/sug”
data = {
‘kw’: ‘baby’
}
yield scrapy.FormRequest(url = post_url, formdata=data, callback=self.parse)
def parse(self, response):
print(response.body)
管道文件
#要使用的管道， 管道的优先级，s数值在1-1000 之间， 越小优先级越高
ITEM_PIPELINES = { ‘qiubaiproject.pipelines.QiubaiprojectPipeline’: 300, }
# 管道其实就是传输数据的
class QiubaiprojectPipeline(object):
def init(self):
self.fp = open(‘qiu1.txt’, ‘w’, encoding=‘utf8’)
# 回调处理item函数,每一个item过来，都会调用这个函数，
# 值在item
def process_item(self, item, spider):
obj = dict(item)
sting = json.dumps(obj, ensure_ascii=False)
self.fp.write(sting + ‘\n’)
return item
# 将item保存到文件中
# item:对象—》dict
def close_spider(self, spider):
self.fp.close()
下载图片
1.
import os
import json
import urllib.request
class ShetuprojectPipeline(object):
def init(self):
self.fp = open(‘image.txt’, “w”, encoding=“utf8”)
def process_item(self, item, spider):
obj = dict(item)
string = json.dumps(obj, ensure_ascii=False)
self.fp.write(string+"\n")
#下载图片的函数
self.download(item)
return item
def download(self, item):
dirname = r"C:\Users\images"
filename = item[“name”]+’.’+item[“image_url”].split(".")[-1]
filpath = os.path.join(dirname, filename)
urllib.request.urlretrieve(item[“image_url”], filpath)
def close_spider(self):
self.fp.close()
2.
settings.py配置
# 存储的图片路径
IMAGES_STORE = ‘D:/Program Files/Scrapy框架项目/Douyu/images/’
ROBOTSTXT_OBEY = False
from scrapy.pipelines.images import ImagesPipeline
import os
from Douyu.settings import IMAGES_STORE as images_store
import scrapy
class DouyuPipeline(ImagesPipeline):
def get_media_requests(self, item, info):
# 获取图片的地址
image_url = item[‘vertical_src’]
# 下载图片
yield scrapy.Request(image_url)
def item_completed(self, result, item, info):
# 取出result里图片信息中的图片路径的值
image_path = [x[“path”] for ok, x in result if ok]
# 修改下载后的图片名称
os.rename(images_store + image_path[0],images_store + item[‘nickname’] +
‘-’+item[‘city’] + ‘.jpg’)
return item
日志信息和错误等级
日志信息：运行scrapy的时候，显示的所有信息就是日志信息
CRITICAL
ERRORS
WARNING
INFO
DEBUG :scrapy下面默认就是这个等级
设置等级LOG_LEVEL = “ERROR” 在设置文件中写
把日志写进文件中在设置文件中
LOG_FILE = ‘log.txt’
CrawlSpider
是一个类，是一个和Spider一样的类，只不过这个类更加强大而已，自己会提取链接写一个规则，然后进行提取
scrapy genspider -t crawl itcast ‘itcast.cn’ # 创建爬虫
LinkExtractors:链接提取器
le = LinkExtractors(allow = xxx, restrcit_xpath = xxx,restrict_css = xxx )
allow :正则表达式
restrict_xpaths:xpath
restrict_css:css选择器
Cookie问题
from scrapy.http.cookies import CookieJar
cookie_obj = CookieJar()
cookie_obj.extract_cookies(response, response.request)
print(cookie_obj._cookies)
配置文件
BOT_NAME = ‘Douyu’ 爬虫名
USER_AGENT = ‘’ 请求头
ROBOTSTXT_OBEY = False 尊不遵守爬虫协议(fasle不遵守)
CONCURRENT_REQUESTS = 32 并发请求数
DOWNLOAD_DELAY = 3 下载延迟
CONCURRENT_REQUESTS_PER_DOMAIN = 16 对单个网站进行并发请求的最大值
CONCURRENT_REQUESTS_PER_IP = 16 对单个IP进行并发请求的最大值
COOKIES_ENABLED = False 是否爬取cookie
TELNETCONSOLE_ENABLED = False 禁用Telnet控制台（默认启用）
DOWNLOADER_MIDDLEWARES = {‘x.xx.xxx’: 543,} 启用或禁用下载器中间件
EXTENSIONS = {‘scrapy.extensions.telnet.TelnetConsole’: None,} 启用或禁用扩展程序
ITEM_PIPELINES = {‘demo1.pipelines.Demo1Pipeline’: 300,} 配置项目管道
#启用和配置AutoThrottle扩展（默认情况下禁用）
#AUTOTHROTTLE_ENABLED = True
#初始下载延迟
#AUTOTHROTTLE_START_DELAY = 5
#在高延迟的情况下设置的最大下载延迟
#AUTOTHROTTLE_MAX_DELAY = 60
#Scrapy请求的平均数量应该并行发送每个远程服务器
#AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0
#启用显示所收到的每个响应的调节统计信息：
#AUTOTHROTTLE_DEBUG = False
#启用和配置HTTP缓存（默认情况下禁用）
#HTTPCACHE_ENABLED = True
#HTTPCACHE_EXPIRATION_SECS = 0
#HTTPCACHE_DIR = ‘httpcache’
#HTTPCACHE_IGNORE_HTTP_CODES = []
#HTTPCACHE_STORAGE = ‘scrapy.extensions.httpcache.FilesystemCacheStorage’