Menu
Random Explore

Python爬虫403错误解决方法与实例

Jun 19,2017   10919 words   39 min

Tags: Python

在上一篇博客中说到，程序使用一段时间后会遇到HTTP Error 403: Forbidden错误。 因为在短时间内直接使用Get获取大量数据，会被服务器认为在对它进行攻击，所以拒绝我们的请求，自动把电脑IP封了。 解决这个问题有两种方法。一是将请求加以包装，变成浏览器请求模式，而不再是“赤裸裸”的请求。 但有时服务器是根据同一IP的请求频率来判断的，即使伪装成不同浏览器。由于是同一IP访问，还是会被封。 所以就有了第二种方法，就是降低请求频率。具体说来也有两种方法。一种是在每次请求时暂停短暂时间，从而降低请求频率。 第二种是使用不同的IP进行访问。显然第一种方法不是最佳选择。 因为我们并不希望下载太慢，尤其是在请求次数很多时。当然如果间隔很短时间，从感官上并无差别，如0.1秒。 但对于服务器而言频率就降低了很多。 所以这是一种最安全可靠的办法，尽管我们并不想用它。第二种方法也就是使用代理IP。下面逐一介绍。

1.增加Header

在浏览谷歌地图时会发现，浏览了大量数据依然没有被封IP，但程序中我们只下了几百张瓦片， 就被封了。主要原因是我们是直接Get请求数据，而浏览器的请求是有Header的。 基于这一点，把请求伪装成浏览器请求，就可以解决这个问题了。 代码如下：

# coding=utf-8
import urllib2 as ulb
import numpy as np
import PIL.ImageFile as ImageFile
import cv2
import random

# 收集到的常用Header
my_headers = [
    "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36",
    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:30.0) Gecko/20100101 Firefox/30.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/537.75.14",
    "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)",
    'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11',
    'Opera/9.25 (Windows NT 5.1; U; en)',
    'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)',
    'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)',
    'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12',
    'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9',
    "Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
    "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 "
]


# 获取影像数据
def getImage(url):
    # 用urllib2库链接网络图像
    response = ulb.Request(url)

    # 随机选择一个Header伪装成浏览器
    response.add_header('User-Agent', random.choice(my_headers))

    # 打开网络图像文件句柄
    fp = ulb.urlopen(response)

    # 定义图像IO
    p = ImageFile.Parser()

    # 开始图像读取
    while 1:
        s = fp.read(1024)
        if not s:
            break
        p.feed(s)

    # 得到图像
    im = p.close()

    # 将图像转换成numpy矩阵
    arr = np.array(im)

    # 将图像RGB通道变成BGR通道，用于OpenCV显示
    pic = np.zeros(arr.shape, np.uint8)
    pic[:, :, 0] = arr[:, :, 2]
    pic[:, :, 1] = arr[:, :, 1]
    pic[:, :, 2] = arr[:, :, 0]

    return pic


img = getImage('https://static.fuwo.com/upload/attachment/1601/08/bea48ebeb5a811e58e9e00163e00254c.jpg')
cv2.imshow('image', img)
cv2.waitKey(0)

如下所示，获取到的网络上的图片： 但有时这样的做法也不一定有用。前面也说到，服务器是根据IP判断。 给请求增加Header只是伪装成不同的浏览器而已。如果同一个IP在短时间内频繁访问， 就算是浏览器请求也会被拒绝掉。因此对于这个问题就只好从另一个方面着手，即适当降低单个IP访问频率。 对于每个IP而言，每次请求操作之间都暂停一段时间。同时利用多个IP进行访问。通过这两种手段可以降低被拒绝的可能性。

2.代理IP

简单地说是通过自动更换不同IP来“迷惑”服务器，让它认为是来自不同电脑的访问请求， 从而不会被拒绝掉。由于代理IP的时效性很强，所以需要经常更换。最好是“现用现找”。代码如下：

# coding=utf-8
import urllib2 as ulb
import numpy as np
import PIL.ImageFile as ImageFile
import cv2
import random

# 免费代理IP不能保证永久有效，如果不能用可以更新
# https://www.goubanjia.com/
proxy_list = [
    '183.95.80.102:8080',
    '123.160.31.71:8080',
    '115.231.128.79:8080',
    '166.111.77.32:80',
    '43.240.138.31:8080',
    '218.201.98.196:3128'
]


# 获取影像数据
def getImage(url):
    # 随机从IP列表中选择一个IP
    proxy = random.choice(proxy_list)
    # 基于选择的IP构建连接
    urlhandle = ulb.ProxyHandler({'http': proxy})
    opener = ulb.build_opener(urlhandle)
    ulb.install_opener(opener)

    # 用urllib2库链接网络图像
    response = ulb.Request(url)

    # 打开网络图像文件句柄
    fp = ulb.urlopen(response)

    # 定义图像IO
    p = ImageFile.Parser()

    # 开始图像读取
    while 1:
        s = fp.read(1024)
        if not s:
            break
        p.feed(s)

    # 得到图像
    im = p.close()

    # 将图像转换成numpy矩阵
    arr = np.array(im)

    # 将图像RGB通道变成BGR通道，用于OpenCV显示
    pic = np.zeros(arr.shape, np.uint8)
    pic[:, :, 0] = arr[:, :, 2]
    pic[:, :, 1] = arr[:, :, 1]
    pic[:, :, 2] = arr[:, :, 0]

    return pic


img = getImage('https://mt2.google.cn/vt/lyrs=s&hl=zh-CN&gl=CN&x=214345&y=107714&z=18')
cv2.imshow('image', img)
cv2.waitKey(0)

在之前由于过多使用，导致本机IP被封，所以无法访问Google地图瓦片，出现如下提示。 运行这段代码后，就可以成功获取瓦片，如下所示： 这样就成功解决访问瓦片403问题了。 至于在哪找免费的代理IP，可以点击这里。代码列表中的IP就是在这里找的。 网站中还有更多付费的高级功能，如果有需要也可以购买。这里只是简单测试，就不买了。

3.终极方法

说了上面两种方法后，很自然地就会想到把两种方法结合起来。这样就会大大提高请求的种类。 如在下面的代码中Header有13个，IP有6个，排列组合就有78中请求。从理论上来说， 组合数越多就越不容易被封。同时再加上请求延迟，是较好的解决方案。

# coding=utf-8
import urllib2 as ulb
import numpy as np
import PIL.ImageFile as ImageFile
import cv2
import random
import time

# 免费代理IP不能保证永久有效，如果不能用可以更新
# https://www.goubanjia.com/
proxy_list = [
    '183.95.80.102:8080',
    '123.160.31.71:8080',
    '115.231.128.79:8080',
    '166.111.77.32:80',
    '43.240.138.31:8080',
    '218.201.98.196:3128'
]

# 收集到的常用Header
my_headers = [
    "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36",
    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:30.0) Gecko/20100101 Firefox/30.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/537.75.14",
    "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)",
    'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11',
    'Opera/9.25 (Windows NT 5.1; U; en)',
    'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)',
    'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)',
    'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12',
    'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9',
    "Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
    "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 "
]


# 获取影像数据
def getImage(url):
    # 设置暂停时间为0.1秒
    t = 0.1
    time.sleep(t)

    # 随机从列表中选择IP、Header
    proxy = random.choice(proxy_list)
    header = random.choice(my_headers)

    print proxy, header

    # 基于选择的IP构建连接
    urlhandle = ulb.ProxyHandler({'http': proxy})
    opener = ulb.build_opener(urlhandle)
    ulb.install_opener(opener)

    # 用urllib2库链接网络图像
    response = ulb.Request(url)

    # 增加Header伪装成浏览器
    response.add_header('User-Agent', header)

    # 打开网络图像文件句柄
    fp = ulb.urlopen(response)

    # 定义图像IO
    p = ImageFile.Parser()

    # 开始图像读取
    while 1:
        s = fp.read(1024)
        if not s:
            break
        p.feed(s)

    # 得到图像
    im = p.close()

    # 将图像转换成numpy矩阵
    arr = np.array(im)

    # 将图像RGB通道变成BGR通道，用于OpenCV显示
    pic = np.zeros(arr.shape, np.uint8)
    pic[:, :, 0] = arr[:, :, 2]
    pic[:, :, 1] = arr[:, :, 1]
    pic[:, :, 2] = arr[:, :, 0]

    return pic


img = getImage('https://mt2.google.cn/vt/lyrs=s&hl=zh-CN&gl=CN&x=214345&y=107714&z=18')
cv2.imshow('image', img)
cv2.waitKey(0)

上述代码中，将每一次使用的代理IP、Header都输出到了控制台中，利用for循环连续获取15次。 输出的结果如下： 在上述代码中使用了请求伪装、代理IP和请求延迟。 可以看到效果很好，15次请求都没有被拒绝。以上这些手段只是增加了不被服务器拒绝的概率， 并不代表一定会成功。但相比于不加任何处理的请求，成功几率高很多。

4.实例练习

在上篇博客中编写了获取瓦片小程序。这里在此基础上进行扩展，实现批量下载某区域瓦片功能。

# coding=utf-8
import urllib2 as ulb
import numpy as np
import PIL.ImageFile as ImageFile
import cv2
import math
import random
import time

# 免费代理IP不能保证永久有效，如果不能用可以更新
# https://www.goubanjia.com/
proxy_list = [
    '183.95.80.102:8080',
    '123.160.31.71:8080',
    '115.231.128.79:8080',
    '166.111.77.32:80',
    '43.240.138.31:8080',
    '218.201.98.196:3128'
]

# 收集到的常用Header
my_headers = [
    "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36",
    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:30.0) Gecko/20100101 Firefox/30.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/537.75.14",
    "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)",
    'Mozilla/5.0 (Windows; U; Windows NT 5.1; it; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11',
    'Opera/9.25 (Windows NT 5.1; U; en)',
    'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)',
    'Mozilla/5.0 (compatible; Konqueror/3.5; Linux) KHTML/3.5.5 (like Gecko) (Kubuntu)',
    'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20070731 Ubuntu/dapper-security Firefox/1.5.0.12',
    'Lynx/2.8.5rel.1 libwww-FM/2.14 SSL-MM/1.4.1 GNUTLS/1.2.9',
    "Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.7 (KHTML, like Gecko) Ubuntu/11.04 Chromium/16.0.912.77 Chrome/16.0.912.77 Safari/535.7",
    "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0 "
]


def getTile(url):
    # 每次执行前先暂停t秒
    time.sleep(t)

    # 随机选择IP、Header
    proxy = random.choice(proxy_list)
    header = random.choice(my_headers)

    print proxy, 'sleep:', t, header

    # 基于选择的IP构建连接
    urlhandle = ulb.ProxyHandler({'http': proxy})
    opener = ulb.build_opener(urlhandle)
    ulb.install_opener(opener)

    # 用urllib2库链接网络图像
    response = ulb.Request(url)

    # 增加Header伪装成浏览器
    response.add_header('User-Agent', header)

    try:
        # 打开网络图像文件句柄
        fp = ulb.urlopen(response)

        # 定义图像IO
        p = ImageFile.Parser()

        # 开始图像读取
        while 1:
            s = fp.read(1024)
            if not s:
                break
            p.feed(s)

        # 得到图像
        im = p.close()

        # 将图像转换成numpy矩阵
        arr = np.array(im)
        return arr

    except ulb.HTTPError, e:
        print e.code, e.reason

        # 遇到异常返回256*256的黑色图片
        arr = np.zeros((256, 256, 3), np.uint8)
        return arr


# 由x、y、z计算瓦片行列号
def calcXY(lat, lon, z):
    x = math.floor(math.pow(2, int(z) - 1) * ((lon / 180.0) + 1))
    tan = math.tan(lat * math.pi / 180.0)
    sec = 1.0 / math.cos(lat * math.pi / 180.0)
    log = math.log(tan + sec)
    y = math.floor(math.pow(2, int(z) - 1) * (1 - log / math.pi))
    return int(x), int(y)


# 字符串度分秒转度
def cvtStr2Deg(deg, min, sec):
    result = int(deg) + int(min) / 60.0 + float(sec) / 3600.0
    return result


# 获取经纬度
def getNum(str):
    split = str.split(',')
    du = split[0].split('°')[0]
    fen = split[0].split('°')[1].split('\'')[0]
    miao = split[0].split('°')[1].split('\'')[1].split('"')[0]
    split1 = cvtStr2Deg(du, fen, miao)
    du = split[1].split('°')[0]
    fen = split[1].split('°')[1].split('\'')[0]
    miao = split[1].split('°')[1].split('\'')[1].split('"')[0]
    split2 = cvtStr2Deg(du, fen, miao)
    return split1, split2


# 获取经纬度
def getNum2(str):
    split = str.split(',')
    split1 = float(split[0].split('N')[0])
    split2 = float(split[1].split('E')[0])
    return split1, split2


# 用户输入更新后的IP文件，如果没有则用代码中的默认IP
ip_path = raw_input("Input the path of IP list file(input \'no\' means use default IPs):\n")
# 判断是否输入IP文件
if ip_path != 'no':
    proxy_list = []
    file = open(ip_path)
    lines = file.readlines()
    for line in lines:
        proxy_list.append(line.strip('\n'))
    print proxy_list.__len__(), 'IPs are loaded.'

# 输入两次请求间的暂停时间
t = 0.1
t = input("Input the interval time(second) of requests(e.g. 0.1):\n")

# 输入影像层数
z = 18
z = raw_input("Input image level(0-18):\n")

# 输入左上角点经纬度并计算行列号
lt_raw = raw_input("Input lat & lon at left top(e.g. 30.52N,114.36E):\n")
lt_lat, lt_lon = getNum2(lt_raw)
lt_X, lt_Y = calcXY(lt_lat, lt_lon, z)

# 输入右下角点经纬度并计算行列号
rb_raw = raw_input("Input lat & lon at right bottom(e.g. 30.51N,114.37E):\n")
rb_lat, rb_lon = getNum2(rb_raw)
rb_X, rb_Y = calcXY(rb_lat, rb_lon, z)

# 计算行列号差值及瓦片数
cols = rb_X - lt_X
rows = rb_Y - lt_Y
tiles = cols * rows
count = 0

# 判断结果是否合理
if tiles <= 0:
    print 'Please check your input.'
    exit()
print tiles.__str__() + ' tiles will be downloaded.'

# 输入保存路径
base = raw_input("Input save path:\n")

print 'Now start...'

# 循环遍历，下载瓦片
for i in range(rows):
    for j in range(cols):
        # 拼接url
        url = 'https://mt2.google.cn/vt/lyrs=s&hl=zh-CN&gl=CN&x=' + (j + lt_X).__str__() + '&y=' + (
            i + lt_Y).__str__() + '&z=' + z.__str__()
        # 拼接输出路径
        path = base + '\\' + z.__str__() + '_' + (j + lt_X).__str__() + '_' + (i + lt_Y).__str__() + '.jpg'
        # 获取瓦片
        tile = getTile(url)
        # 保存瓦片
        cv2.imwrite(path, tile)
        # 计数变量增加
        count = count + 1
        # 输出进度信息
        print (round((float(count) / float(tiles)) * 100, 2)).__str__() + " % finished"

运行程序如下所示。按照提示依次输入IP文件路径、请求暂停时间、影像层数、西北角经纬度、东南角经纬度以及输出影像路径。 程序便会自动下载。同时会显示请求每一个瓦片用的IP、Header、SleepTime以及进度。 下载完成后的瓦片如下图所示。 输入的IP地址文件如下所示，每一行为一个IP地址。这些IP地址可以在上面说到的那个网站上找。 最后输出成exe进行了测试，可以正常使用。 exe点击这里下载，密码：oiai。

5.更多思考

在上面的程序中，我们下载了30.52N,114.36E - 30.51N,114.37E范围的18级瓦片，一共是63张。 如果要下载整个中国国境的18级瓦片，输入角点经纬度，计算得到如下结果： 一共有接近15亿张瓦片！几乎全国每个人有一张。经过统计，平均一个瓦片最小在20KB左右。 按照20KB计算，要存储全国的18级影像数据一共需要24TB。如果算上前17级，那就更是个“天文数字”了。 于是感叹那些WMTS服务的服务器确实很强。

本文作者原创,未经许可不得转载,谢谢配合

返回顶部
鼓励一下