python爬虫之三（Python3 爬虫）

发布时间：2022-11-15

本文目录一览：

  1. python网络爬虫怎么学习
  2. 如何用Python做爬虫
  3. [「2022 年」崔庆才 Python3 爬虫教程 - 代理的使用方法](#「2022 年」崔庆才 Python3 爬虫教程 - 代理的使用方法)
  4. [如何入门 Python 爬虫](#如何入门 Python 爬虫)

python网络爬虫怎么学习

链接：
提取码：2b6c 课程简介
毕业不知如何就业？工作效率低经常挨骂？很多次想学编程都没有学会？
Python 实战：四周实现爬虫系统，无需编程基础，二十八天掌握一项谋生技能。
带你学到如何从网上批量获得几十万数据，如何处理海量大数据，数据可视化及网站制作。 课程目录
开始之前，魔力手册 for 实战学员预习
第一周：学会爬取网页信息
第二周：学会爬取大规模数据
第三周：数据统计与分析
第四周：搭建 Django 数据可视化网站
......

如何用Python做爬虫

1）首先你要明白爬虫怎样工作。 想象你是一只蜘蛛，现在你被放到了互联“网”上。那么，你需要把所有的网页都看一遍。怎么办呢？没问题呀，你就随便从某个地方开始，比如说人民日报的首页，这个叫initial pages，用$表示吧。 在人民日报的首页，你看到那个页面引向的各种链接。于是你很开心地从爬到了“国内新闻”那个页面。太好了，这样你就已经爬完了俩页面（首页和国内新闻）！暂且不用管爬下来的页面怎么处理的，你就想象你把这个页面完完整整抄成了个html放到了你身上。 突然你发现，在国内新闻这个页面上，有一个链接链回“首页”。作为一只聪明的蜘蛛，你肯定知道你不用爬回去的吧，因为你已经看过了啊。所以，你需要用你的脑子，存下你已经看过的页面地址。这样，每次看到一个可能需要爬的新链接，你就先查查你脑子里是不是已经去过这个页面地址。如果去过，那就别去了。 好的，理论上如果所有的页面可以从initial page达到的话，那么可以证明你一定可以爬完所有的网页。 那么在python里怎么实现呢？ 很简单

import Queue
initial_page = "初始化页"
url_queue = Queue.Queue()
seen = set()
seen.insert(initial_page)
url_queue.put(initial_page)
while(True): #一直进行直到海枯石烂
    if url_queue.size() > 0:
        current_url = url_queue.get() #拿出队列中第一个的url
        store(current_url) #把这个url代表的网页存储好
        for next_url in extract_urls(current_url): #提取把这个url里链向的url
            if next_url not in seen:
                seen.put(next_url)
                url_queue.put(next_url)
    else:
        break

写得已经很伪代码了。 所有的爬虫的backbone都在这里，下面分析一下为什么爬虫事实上是个非常复杂的东西——搜索引擎公司通常有一整个团队来维护和开发。 2）效率 如果你直接加工一下上面的代码直接运行的话，你需要一整年才能爬下整个豆瓣的内容。更别说Google这样的搜索引擎需要爬下全网的内容了。 问题出在哪呢？需要爬的网页实在太多太多了，而上面的代码太慢太慢。设想全网有N个网站，那么分析一下判重的复杂度就是N*log(N)，因为所有网页要遍历一次，而每次判重用set的话需要log(N)的复杂度。OK，OK，我知道python的set实现是hash——不过这样还是太慢了，至少内存使用效率不高。 通常的判重做法是怎样呢？Bloom Filter。简单讲它仍然是一种hash的方法，但是它的特点是，它可以使用固定的内存（不随url的数量而增长）以O(1)的效率判定url是否已经在set中。可惜天下没有白吃的午餐，它的唯一问题在于，如果这个url不在set中，BF可以100%确定这个url没有看过。但是如果这个url在set中，它会告诉你：这个url应该已经出现过，不过我有2%的不确定性。注意这里的不确定性在你分配的内存足够大的时候，可以变得很小很少。一个简单的教程:Bloom Filters by Example 注意到这个特点，url如果被看过，那么可能以小概率重复看一看（没关系，多看看不会累死）。但是如果没被看过，它会告诉你应该已经出现过，不过我有2%的不确定性。[IMPORTANT: 此段有问题，请暂时略过] 好，现在已经接近处理判重最快的方法了。另外一个瓶颈——你只有一台机器。不管你的带宽有多大，只要你的机器下载网页的速度是瓶颈的话，那么你只有加快这个速度。用一台机子不够的话——用很多台吧！当然，我们假设每台机子都已经进了最大的效率——使用多线程（python的话，多进程吧）。 3）集群化抓取 爬取豆瓣的时候，我总共用了100多台机器昼夜不停地运行了一个月。想象如果只用一台机子你就得运行100个月了... 那么，假设你现在有100台机器可以用，怎么用python实现一个分布式的爬取算法呢？ 我们把这100台中的99台运算能力较小的机器叫作slave，另外一台较大的机器叫作master，那么回顾上面代码中的url_queue，如果我们能把这个queue放到这台master机器上，所有的slave都可以通过网络跟master联通，每当一个slave完成下载一个网页，就向master请求一个新的网页来抓取。而每次slave新抓到一个网页，就把这个网页上所有的链接送到master的queue里去。同样，bloom filter也放到master上，但是现在master只发送确定没有被访问过的url给slave。Bloom Filter放到master的内存里，而被访问过的url放到运行在master上的Redis里，这样保证所有操作都是O(1)。（至少平摊是O(1)，Redis的访问效率见:LINSERT – Redis） 考虑如何用python实现： 在各台slave上装好scrapy，那么各台机子就变成了一台有抓取能力的slave，在master上装好Redis和rq用作分布式队列。 代码于是写成

#slave.py
current_url = request_from_master()
to_send = []
for next_url in extract_urls(current_url):
    to_send.append(next_url)
store(current_url);
send_to_master(to_send)
#master.py
distributed_queue = DistributedQueue()
bf = BloomFilter()
initial_pages = ""
while(True):
    if request == 'GET':
        if distributed_queue.size() > 0:
            send(distributed_queue.get())
        else:
            break
    elif request == 'POST':
        bf.put(request.url)

好的，其实你能想到，有人已经给你写好了你需要的：darkrho/scrapy-redis · GitHub 4）展望及后处理 虽然上面用很多“简单”，但是真正要实现一个商业规模可用的爬虫并不是一件容易的事。上面的代码用来爬一个整体的网站几乎没有太大的问题。 但是如果附加上你需要这些后续处理，比如

  • 有效地存储（数据库应该怎样安排）
  • 有效地判重（这里指网页判重，咱可不想把人民日报和抄袭它的大民日报都爬一遍）
  • 有效地信息抽取（比如怎么样抽取出网页上所有的地址抽取出来，“朝阳区奋进路中华道”），搜索引擎通常不需要存储所有的信息，比如图片我存来干嘛...
  • 及时更新（预测这个网页多久会更新一次） 如你所想，这里每一个点都可以供很多研究者十数年的研究。虽然如此， “路漫漫其修远兮,吾将上下而求索”。 所以，不要问怎么入门，直接上路就好了：）

「2022 年」崔庆才 Python3 爬虫教程 - 代理的使用方法

前面我们介绍了多种请求库，如 urllib、requests、Selenium、Playwright 等用法，但是没有统一梳理代理的设置方法，本节我们来针对这些库来梳理下代理的设置方法。 在本节开始之前，请先根据上一节了解一下代理的基本原理，了解了基本原理之后我们可以更好地理解和学习本节的内容。 另外我们需要先获取一个可用代理，代理就是 IP 地址和端口的组合，就是 ip:port 这样的格式。如果代理需要访问认证，那就还需要额外的用户名密码两个信息。 那怎么获取一个可用代理呢？ 使用搜索引擎搜索 “代理” 关键字，可以看到许多代理服务网站，网站上会有很多免费或付费代理，比如快代理的免费 HTTP 代理：上面就写了很多免费代理，但是这些免费代理大多数情况下并不一定稳定，所以比较靠谱的方法是购买付费代理。付费代理的各大代理商家都有套餐，数量不用多，稳定可用即可，我们可以自行选购。 另外除了购买付费 HTTP 代理，我们也可以在本机配置一些代理软件，具体的配置方法可以参考 ，软件运行之后会在本机创建 HTTP 或 SOCKS 代理服务，所以代理地址一般都是 127.0.0.1:端口 这样的格式，不同的软件用的端口可能不同。 这里我的本机安装了一部代理软件，它会在本地 7890 端口上创建 HTTP 代理服务，即代理为 127.0.0.1:7890。另外，该软件还会在 7891 端口上创建 SOCKS 代理服务，即代理为 127.0.0.1:7891，所以只要设置了这个代理，就可以成功将本机 IP 切换到代理软件连接的服务器的 IP 了。 在本章下面的示例里，我使用上述代理来演示其设置方法，你也可以自行替换成自己的可用代理。 设置代理后，测试的网址是 http://httpbin.org/ip，访问该链接我们可以得到请求的相关信息，其中返回结果的 origin 字段就是客户端的 IP，我们可以根据它来判断代理是否设置成功，即是否成功伪装了 IP。 好，接下来我们就来看下各个请求库的代理设置方法吧。 首先我们以最基础的 urllib 为例，来看一下代理的设置方法，代码如下：

from urllib.request import ProxyHandler, build_opener
proxy = '127.0.0.1:7890'
proxy_handler = ProxyHandler({
    'http': 'http://' + proxy,
    'https': 'https://' + proxy
})
opener = build_opener(proxy_handler)
response = opener.open('http://httpbin.org/ip')
print(response.read())

运行结果如下：

{
  "origin": "127.0.0.1"
}

这里我们需要借助 ProxyHandler 设置代理，参数是字典类型，键名为协议类型，键值是代理。注意，此处代理前面需要加上协议，即 http:// 或者 https://，当请求的链接是 HTTP 协议的时候，会使用 http 键名对应的代理，当请求的链接是 HTTPS 协议的时候，会使用 https 键名对应的代理。不过这里我们把代理本身设置为了 HTTP 协议，即前缀统一设置为了 http://，所以不论访问 HTTP 还是 HTTPS 协议的链接，都会使用我们配置的 HTTP 协议的代理进行请求。 创建完 ProxyHandler 对象之后，我们需要利用 build_opener 方法传入该对象来创建一个 Opener，这样就相当于此 Opener 已经设置好代理了。接下来直接调用 Opener 对象的 open 方法，即可访问我们所想要的链接。 运行输出结果是一个 JSON，它有一个字段 origin，标明了客户端的 IP。验证一下，此处的 IP 确实为代理的 IP，并不是真实的 IP。这样我们就成功设置好代理，并可以隐藏真实 IP 了。 如果遇到需要认证的代理，我们可以用如下的方法设置：

proxy = 'username:password@127.0.0.1:7890'

这里改变的只是 proxy 变量，只需要在代理前面加入代理认证的用户名密码即可，其中 username 就是用户名，password 为密码，例如 username 为 foo，密码为 bar，那么代理就是 foo:bar@127.0.0.1:7890。 如果代理是 SOCKS5 类型，那么可以用如下方式设置代理：

import socks
import socket
from urllib.request import build_opener
socks.set_default_proxy(socks.SOCKS5, "127.0.0.1", 7891)
socket.socket = socks.socksocket
opener = build_opener()
response = opener.open('http://httpbin.org/ip')
print(response.read())

此处需要一个 socks 模块，可以通过如下命令安装：

pip install pysocks

这里需要本地运行一个 SOCKS5 代理，运行在 7891 端口，运行成功之后和上文 HTTP 代理输出结果是一样的：

{
  "origin": "127.0.0.1"
}

结果的 origin 字段同样为代理的 IP，代理设置成功。 对于 requests 来说，代理设置非常简单，我们只需要传入 proxies 参数即可。 这里以我本机的代理为例，来看下 requests 的 HTTP 代理设置，代码如下：

import requests
proxies = {
    'http': 'http://127.0.0.1:7890',
    'https': 'https://127.0.0.1:7890'
}
response = requests.get('http://httpbin.org/ip', proxies=proxies)
print(response.text)

运行结果如下：

{
  "origin": "127.0.0.1"
}

和 urllib 一样，当请求的链接是 HTTP 协议的时候，会使用 http 键名对应的代理，当请求的链接是 HTTPS 协议的时候，会使用 https 键名对应的代理，不过这里统一使用了 HTTP 协议的代理。 运行结果中的 origin 若是代理服务器的 IP，则证明代理已经设置成功。 如果代理需要认证，那么在代理的前面加上用户名和密码即可，代理的写法就变成如下所示：

proxies = {
    'http': 'http://username:password@127.0.0.1:7890',
    'https': 'https://username:password@127.0.0.1:7890'
}

这里只需要将 username 和 password 替换即可。 如果需要使用 SOCKS 代理，则可以使用如下方式来设置：

proxies = {
    'http': 'socks5://127.0.0.1:7891',
    'https': 'socks5://127.0.0.1:7891'
}

这里我们需要额外安装一个包 requests[socks]，相关命令如下所示：

pip install requests[socks]

运行结果是完全相同的：

{
  "origin": "127.0.0.1"
}

另外，还有一种设置方式，即使用 socks 模块，也需要像上文一样安装 socks 库。这种设置方法如下所示：

import socks
import socket
from requests.utils import getproxies
socks.set_default_proxy(socks.SOCKS5, "127.0.0.1", 7891)
socket.socket = socks.socksocket
response = requests.get('http://httpbin.org/ip')
print(response.text)

使用这种方法也可以设置 SOCKS 代理，运行结果完全相同。相比第一种方法，此方法是全局设置的。我们可以在不同情况下选用不同的方法。 httpx 的用法本身就与 requests 的使用非常相似，所以其也是通过 proxies 参数来设置代理的，不过与 requests 不同的是，proxies 参数的键名不能再是 http 或 https，而需要更改为 http:// 或 https://，其他的设置是一样的。 对于 HTTP 代理来说，设置方法如下：

import httpx
proxies = {
    'http://': 'http://127.0.0.1:7890',
    'https://': 'https://127.0.0.1:7890'
}
client = httpx.Client(proxies=proxies)
response = client.get('http://httpbin.org/ip')
print(response.text)

对于需要认证的代理，也是改下 proxy 的值即可：

proxies = {
    'http://': 'http://username:password@127.0.0.1:7890',
    'https://': 'https://username:password@127.0.0.1:7890'
}

这里只需要将 username 和 password 替换即可。 运行结果和使用 requests 是类似的，结果如下：

{
  "origin": "127.0.0.1"
}

对于 SOCKS 代理，我们需要安装 httpx-socks 库，安装方法如下：

pip install httpx-socks

这样会同时安装同步和异步两种模式的支持。 对于同步模式，设置方法如下：

from httpx_socks import SyncProxyTransport
transport = SyncProxyTransport.from_url("socks5://127.0.0.1:7891")
with httpx.Client(transport=transport) as client:
    response = client.get("http://httpbin.org/ip")
    print(response.text)

对于异步模式，设置方法如下：

from httpx_socks import AsyncProxyTransport
transport = AsyncProxyTransport.from_url("socks5://127.0.0.1:7891")
async with httpx.AsyncClient(transport=transport) as client:
    response = await client.get("http://httpbin.org/ip")
    print(response.text)

和同步模式不同的是，transport 对象我们用的是 AsyncProxyTransport 而不是 SyncProxyTransport，同时需要将 Client 对象更改为 AsyncClient 对象，其他的不变，运行结果是一样的。 Selenium 同样可以设置代理，这里以 Chrome 为例来介绍其设置方法。 对于无认证的代理，设置方法如下：

from selenium import webdriver
options = webdriver.ChromeOptions()
options.add_argument('--proxy-server=http://127.0.0.1:7890')
browser = webdriver.Chrome(options=options)
browser.get('http://httpbin.org/ip')

运行结果如下：

{
  "origin": "127.0.0.1"
}

代理设置成功，origin 同样为代理 IP 的地址。 如果代理是认证代理，则设置方法相对比较繁琐，具体如下所示：

import zipfile
from selenium import webdriver
manifest_json = """
{
    "version": "1.0.0",
    "manifest_version": 2,
    "name": "Chrome Proxy",
    "permissions": [
        "proxy",
        "tabs",
        "unlimitedStorage",
        "storage",
        "<all_urls>",
        "webRequest",
        "webRequestBlocking"
    ],
    "background": {
        "scripts": ["background.js"]
    }
}
"""
background_js = """
var config = {
        mode: "fixed_servers",
        rules: {
        singleProxy: {
            scheme: "http",
            host: "127.0.0.1",
            port: parseInt(7890)
        },
        bypassList: ["localhost"]
        }
    };
chrome.proxy.settings.set({value: config, scope: "regular"}, function () {});
function callbackFn(details) {
    return {
        authCredentials: {
            username: "username",
            password: "password"
        }
    };
}
chrome.webRequest.onAuthRequired.addListener(
    callbackFn,
    {urls: ["<all_urls>"]},
    ['blocking']
);
"""
def create_proxy_extension(proxy_host, proxy_port, username=None, password=None):
    pf = tempfile.mkdtemp()
    os.chdir(pf)
    with open("manifest.json", 'w') as f:
        f.write(manifest_json)
    with open("background.js", 'w') as f:
        f.write(background_js)
    zf = zipfile.ZipFile('proxy_auth_plugin.zip', 'w')
    for filename in ['manifest.json', 'background.js']:
        zf.write(filename)
    zf.close()
    return pf
proxy_extension = create_proxy_extension('127.0.0.1', 7890, 'username', 'password')
options = webdriver.ChromeOptions()
options.add_extension(proxy_extension)
browser = webdriver.Chrome(options=options)
browser.get('http://httpbin.org/ip')

运行结果和上例一致，origin 同样为代理 IP。 SOCKS 代理的设置也比较简单，把对应的协议修改为 socks5 即可，如无密码认证的代理设置方法为：

options = webdriver.ChromeOptions()
options.add_argument('--proxy-server=socks5://127.0.0.1:7891')
browser = webdriver.Chrome(options=options)
browser.get('http://httpbin.org/ip')

运行结果是一样的。 对于 aiohttp 来说，我们可以通过 proxy 参数直接设置。HTTP 代理设置如下：

import aiohttp
import asyncio
async def fetch():
    async with aiohttp.ClientSession() as session:
        async with session.get('http://httpbin.org/ip', proxy='http://127.0.0.1:7890') as response:
            print(await response.text())
asyncio.run(fetch())

如果代理有用户名和密码，像 requests 一样，把 proxy 修改为如下内容：

proxy='http://username:password@127.0.0.1:7890'

这里只需要将 username 和 password 替换即可。 对于 SOCKS 代理，我们需要安装一个支持库 aiohttp-socks，其安装命令如下：

pip install aiohttp-socks

我们可以借助于这个库的 ProxyConnector 来设置 SOCKS 代理，其代码如下：

import aiohttp
import asyncio
from aiohttp_socks import ProxyConnector
async def fetch():
    connector = ProxyConnector(host='127.0.0.1', port=7891, ssl=False)
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get('http://httpbin.org/ip') as response:
            print(await response.text())
asyncio.run(fetch())

运行结果是一样的。 另外，这个库还支持设置 SOCKS4、HTTP 代理以及对应的代理认证，可以参考其官方介绍。 对于 Pyppeteer 来说，由于其默认使用的是类似 Chrome 的 Chromium 浏览器，因此其设置方法和 Selenium 的 Chrome 一样，如 HTTP 无认证代理设置方法都是通过 args 来设置的，实现如下：

from pyppeteer import launch
async def main():
    browser = await launch(args=['--proxy-server=http://127.0.0.1:7890'])
    page = await browser.newPage()
    await page.goto('http://httpbin.org/ip')
    content = await page.content()
    print(content)
    await browser.close()
asyncio.run(main())

运行结果如下：

{
  "origin": "127.0.0.1"
}

同样可以看到设置成功。 SOCKS 代理也一样，只需要将协议修改为 socks5 即可，代码实现如下：

async def main():
    browser = await launch(args=['--proxy-server=socks5://127.0.0.1:7891'])
    page = await browser.newPage()
    await page.goto('http://httpbin.org/ip')
    content = await page.content()
    print(content)
    await browser.close()
asyncio.run(main())

运行结果也是一样的。 相对 Selenium 和 Pyppeteer 来说，Playwright 的代理设置更加方便，其预留了一个 proxy 参数，可以在启动 Playwright 的时候设置。 对于 HTTP 代理来说，可以这样设置：

from playwright.sync_api import sync_playwright
with sync_playwright() as p:
    browser = p.chromium.launch(proxy={"server": "http://127.0.0.1:7890"})
    page = browser.new_page()
    page.goto('http://httpbin.org/ip')
    print(page.content())
    browser.close()

在调用 launch 方法的时候，我们可以传一个 proxy 参数，是一个字典。字典有一个必填的字段叫做 server，这里我们可以直接填写 HTTP 代理的地址即可。 运行结果如下：

{
  "origin": "127.0.0.1"
}

对于 SOCKS 代理，设置方法也是完全一样的，我们只需要把 server 字段的值换成 SOCKS 代理的地址即可：

browser = p.chromium.launch(proxy={"server": "socks5://127.0.0.1:7891"})

运行结果和刚才也是完全一样的。 对于有用户名和密码的代理，Playwright 的设置也非常简单，我们只需要在 proxy 参数额外设置 username 和 password 字段即可，假如用户名和密码分别是 foo 和 bar，则设置方法如下：

browser = p.chromium.launch(proxy={"server": "http://127.0.0.1:7890", "username": "foo", "password": "bar"})

这样我们就能非常方便地为 Playwright 实现认证代理的设置。 以上我们就总结了各个请求库的代理使用方式，各种库的设置方法大同小异，学会了这些方法之后，以后如果遇到封 IP 的问题，我们可以轻松通过加代理的方式来解决。 本节代码：

如何入门 Python 爬虫

链接：
提取码：2b6c 课程简介
毕业不知如何就业？工作效率低经常挨骂？很多次想学编程都没有学会？
Python 实战：四周实现爬虫系统，无需编程基础，二十八天掌握一项谋生技能。
带你学到如何从网上批量获得几十万数据，如何处理海量大数据，数据可视化及网站制作。 课程目录
开始之前，魔力手册 for 实战学员预习
第一周：学会爬取网页信息
第二周：学会爬取大规模数据
第三周：数据统计与分析
第四周：搭建 Django 数据可视化网站
......

推荐文章