爬虫高级应用（16. 多线程和多进程爬虫）

最新推荐文章于 2024-05-12 17:16:43 发布
最新推荐文章于 2024-05-12 17:16:43 发布
阅读量732 收藏 2
点赞数
分类专栏： 高级爬虫案例教程 文章标签： 爬虫 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/to_upper/article/details/124205268
版权

目录

内容概括

  1. 进程和线程的区别
  2. 在Python中实现线程
  3. 为线程传递参数
  4. 线程类
  5. 用线程锁和信号量同步线程
  6. 生产者和消费者
  7. 多线程的实现
  8. 通过真实项目演示如何用多线程和多线程实现爬虫应用

干货

16.1 single_thread单线程

使用Python单线程调用两个函数：fun1和fun2，这两个函数中使用sleep函数休眠一定时间，如果用单线程调用这两个函数，那么会顺序执行这两个函数

from time import sleep,ctime
def fun1():
    print('开始巡行fun1：',ctime())
    # 休眠4秒
    sleep(4)
    print('fun1巡行完毕：',ctime())
def fun2():
    print('开始巡行fun2：', ctime())
    # 休眠2秒
    sleep(2)
    print('fun2巡行完毕：', ctime())
def main():
    print('开始运行时间：',ctime())
    # 在单线程中调用fun1和fun2
    fun1()
    fun2()
    print('结束运行时间：',ctime())
if __name__ == '__main__':
    main()

16.2 _thread线程库

  1. 使用_thread模块中的start_new_thread函数会直接开启一个线程，该函数的第1个参数需要制定一个函数，
  2. 可以把这个函数成为线程函数，当线程启动时会自动调用这个函数。第2个参数是给线程函数传递的参数必须是元组类型
import _thread as thread
from time import sleep, ctime
def fun1():
    print('开始巡行fun1：',ctime())
    # 休眠4秒
    sleep(4)
    print('fun1巡行完毕：',ctime())
def fun2():
    print('开始巡行fun2：', ctime())
    # 休眠2秒
    sleep(2)
    print('fun2巡行完毕：', ctime())
def main():
    print('开始运行时间：',ctime())
    # 启动一个线程运行fun1函数
    thread.start_new_thread(fun1, ())
    # 启动一个线程运行fun2函数
    thread.start_new_thread(fun2, ())
    # 休眠6秒
    sleep(6)
    print('结束时间：',ctime())
if __name__ == '__main__':
    main()

从结果中可以看出，fun1休眠的4秒钟中，fun2没有闲着，趁虚而入，先fun1一步结束了函数的运行

16.3 multi_thread_args带参数的多线程

利用for循环和start_new_thread函数启动8个线程，并未每一个线程函数传递不同的参数值，然后在线程函数中输出传入的参数值

import random
from time import sleep
import _thread as thread
# 线程函数，其中a和b是通过start_new_thread函数传入的参数
def fun(a,b):
    print(a,b)
    # 随机休眠一个的时间（1~4s）
    sleep(random.randint(1,5))
# 启动8个线程
for i in range(8):
    # 为每一个线程函数传入2个参数值
    thread.start_new_thread(fun,(i+1,'a'*(i+1)))
# 通过从终端输出入一个字符串的方式让线程暂停
input()

结论：线程之间会相互抢占资源，趁虚而入

16.4 lock线程锁

锁lock的的用法

 allocate_lock函数用于创建对象，然后使用锁对象的acquire方法获取锁
如果不需要锁了，可以用锁对象的release方法释放锁。
如果要判断锁是否被释放，可以使用锁对象的locked方法
  1. 启动2个线程，创建2个锁，再运行线程函数之前，获取2个锁，意味着锁处于锁定状态，在启动时将2个锁对象分别传入2个线程各自的锁对象，
  2. 当线程函数执行完，会调用锁对象的release方法释放锁。在main函数最后，使用while循环和locked方法判断这2个锁是否已经释放
  3. 只要有一个没有释放，while就不会退出，如果都释放了，则立刻结束
import _thread as thread
from time import sleep, ctime
# 线程函数，index是一个整数类型的索引、sec是休眠时间（单位：秒），lock是锁对象
def fun(index,sec,lock):
    print('开始执行{}执行时间：{}'.format(index,ctime()))
    # 休眠sec秒
    sleep(sec)
    print('执行结束{}执行时间：{}'.format(index, ctime()))
    # 释放锁对象
    lock.release()

def main():
    lock1 = thread.allocate_lock()
    # 获得锁，即上锁
    lock1.acquire()
    # 启动第1个线程，并传入第1个锁对象，10是索引，4是休眠时间，lock1是锁对象
    thread.start_new_thread(fun,(10,4,lock1))

    lock2 = thread.allocate_lock()
    lock2.acquire()
    # 启动第2个线程，并传入第2个锁对象，20是索引，2是休眠时间，lock2是锁对象
    thread.start_new_thread(fun, (20, 2, lock2))
    # 使用while循环和locked方法判断lock1和lock2是否被释放
    # 只要有一个没有释放，while循环就不会退出
    while lock1.locked() or lock2.locked():
        pass

if __name__ == '__main__':
    main()

16.5 threating另一个线程库

  1. threading模块中Thread类的实例是一个执行线程的对象
  2. _thread模块可以看作线程的面向过程版本，而Thread类可以看作线程的面向对象版本
  3. Thread类的构造方法的target关键字执行线程函数，通过args关键字参数指定传给线程函数的参数。然后调用start方法启动线程
import threading
from time import sleep,ctime
# 线程函数，index是一个整数类型的索引、sec是休眠时间（单位：秒）
def fun(index,sec):
    print('开始执行{}执行时间：{}'.format(index,ctime()))
    # 休眠sec秒
    sleep(sec)
    print('执行结束{}执行时间：{}'.format(index, ctime()))

def main():
    # 创建第1个Thread对象，通过target关键字参数指定线程函数fun，传入索引10和休眠时间4s
    thread1 = threading.Thread(target=fun,args=(10,4))
    thread1.start()
    # 创建第2个Thread对象，通过target关键字参数指定线程函数fun，传入索引20和休眠时间2s
    thread2 = threading.Thread(target=fun, args=(20, 2))
    thread2.start()
    # 等待第1个线程函数执行完毕
    thread1.join()
    # 等待第2个函数执行完毕
    thread2.join()

if __name__ == '__main__':
    main()

总结：join方法不需要手动释放锁，threating库更加方便了

16.6 thread_obj对象的线程默认启动方法

target关键字参数不仅可以是一个函数，还可以是一个对象，
类中必须有一个__call__方法，线程启动时会自动调用线程对象__call__方法

import threading
from time import sleep,ctime
# 线程对象对应的类
class Mythread(object):
    # func表示线程函数，args表示线程函数的参数
    def __init__(self,func,args):
        # 将线程函数与线程函数的参数赋给当前的类的成员变量
        self.func = func
        self.args = args
    # 线程启动时会调用该方法
    def __call__(self):
        # 调用线程函数，并将元组类型的参数分解为单个的参数值传入线程函数
        self.func(*self.args)

# 线程函数
def fun(index,sec):
    print('开始执行{}执行时间：{}'.format(index,ctime()))
    # 休眠sec秒
    sleep(sec)
    print('执行结束{}执行时间：{}'.format(index, ctime()))

def main():
    print('执行开始时间：',ctime())
    # 创建第1个Thread对象，通过target关键字参数指定线程函数fun，传入索引10和休眠时间4s
    thread1 = threading.Thread(target = Mythread(fun,(10, 4)))
    thread1.start()
    # 创建第2个Thread对象，通过target关键字参数指定线程函数fun，传入索引20和休眠时间2s
    thread2 = threading.Thread(target = Mythread(fun,(20, 2)))
    thread2.start()
    # 创建第3个Thread对象，通过target关键字参数指定线程函数fun，传入索引20和休眠时间2s
    thread3 = threading.Thread(target = Mythread(fun,(30, 1)))
    thread3.start()
    # 等待执行完毕
    thread1.join()
    thread2.join()
    thread3.join()
    print('所有的线程函数均执行完毕：',ctime())

if __name__ == '__main__':
    main()

16.7 thread_inherit继承线程类

  1. 从Thread类继承的子类MyThread，重写父类的构造方法和run方法。
  2. 最后通过MyThread类创建并启动两个线程，并使用join方法等待这两个线程结束后再退出程序
import threading
from time import ctime,sleep
# 从Thread类派生的子类
class MyThread(threading.Thread):
    # 重写父类的构造方法，其中func是线程函数，args是传入线程函数的参数，name是线程名
    def __init__(self,func,args,name=''):
        # 调用父类的构造方法，并传入响应的参数值
        super().__init__(target=func,name=name,args=args)
        # 重写父类的run方法
        def run(self):
            self._target(*self.args)

# 线程函数
def fun(index,sec):
    print('开始执行{}执行时间：{}'.format(index,ctime()))
    # 休眠sec秒
    sleep(sec)
    print('执行结束{}执行时间：{}'.format(index, ctime()))

def main():
    print('k开始：',ctime())
    # 创建第1个线程，并指定线程名为“线程1”
    thread1 = MyThread(fun,(10,4),"线程1")
    # 创建第2线程，并指定线程名为“线程2”
    thread2 = MyThread(fun, (20, 2), "线程2")
    thread1.start()
    thread2.start()
    print(thread1.name)
    print(thread2.name)
    thread1.join()
    thread2.join()

    print('结束：',ctime())

if __name__ == '__main__':
    main()

16.8 lock_demo线程锁对象

  1. 在线程函数中使用for循环输出线程名和循环变量的值，并通过线程锁将这段代码编程原子操作（原子性：不可中断）
  2. 这样就只有当前线程的for循环执行完，其他线程函数的for循环才会重新获得线程锁权限并执行
from atexit import register
import random
from threading import Thread,Lock,currentThread
from time import sleep,ctime
# 创建线程锁对象
lock = Lock()
def fun():
    # 获取线程锁权限
    lock.acquire()
    # for循环已经变成了原子操作:因为获取了锁，所以其他的线程无法抢走for的cpu资源，故for循环可以完整运行结束
    for i in range(5):
        print('Thread Name={} i={}'.format(currentThread().name,i))
        # 休眠一段时间4s
        sleep(random.randint(1,5))
    # 释放线程锁，其他线程函数可以获得这个线程锁的权限
    lock.release()

def main():
    # 通过循环启动了三个线程
    for i in range(3):
        Thread(target=fun).start()

# 当程序结束时会调用这个函数
@register
def exit():
    print('线程执行完毕：',ctime())
if __name__ == '__main__':
    main()

16.9 semaphore信号量（资源）

这里涉及到一些操作系统上的知识点，semaphore资源，本质上是由操作系统给各个进程（线程分配资源），这时候就需要考虑到资源的使用，不能产生死锁的情况，否则会引起故障。
这里不做细说，读者可以看看博主的操作系统专栏，会有很多收获。

使用BoundedSemaphore类的实例，acquire方法和release方法获取资源（-1）和释放资源（+1）

from threading import BoundedSemaphore
Max = 3
# 创建信号量对象，并设置计数器的最大值，计数器不能超过这个值
semaphore = BoundedSemaphore(Max)
print(semaphore._value)
# 申请资源-1
semaphore.acquire()
print(semaphore._value)
semaphore.acquire()
print(semaphore._value)
semaphore.acquire()
print(semaphore._value)
# 当计数器为0时，不能再获取资源，所以acquire方法会返回False
print(semaphore.acquire(False))
print(semaphore._value)

# 释放资源+1
semaphore.release()
print(semaphore._value)
semaphore.release()
print(semaphore._value)
semaphore.release()
print(semaphore._value)
# 抛出异常，但计数器到达最大值，不能再释放资源
semaphore.release()

acquire方法的参数值为False，当计数器为0时不会阻塞，而是直接返回False，表示没有获取资源，如果成功获得资源，会返回True。

16.10 semaphore_lock资源小例子——糖果机

  1. 模拟一个糖果机补充糖果和用户获取糖果的过程，糖果机有5个槽
  2. 如果发现每个槽都没有糖果了，需要补充新的糖果
  3. 当5个槽都满了，就无法补充新的糖果了
  4. 如果5个槽都是空的，顾客也就无法购买糖果了。
    为了方便，本例假设顾客一次会购买整个槽的糖果，每次补充整个槽的糖果
from atexit import register
from random import randrange
from threading import BoundedSemaphore,Lock,Thread
from time import sleep,ctime
# 创建线程锁
lock = Lock()
# 定义糖果机的槽数，也是信号量计数器的最大值
MAX = 5
# 创建信号量对象，并指定计数器的最大值
candytray = BoundedSemaphore(MAX)
# 给糖果机的槽补充新的糖果（每次只补充一个槽）
def refill():
    # 获取线程锁，将补充糖果的操作变成原子操作
    lock.acquire()
    print('重新添加糖果...',end=' ')
    try:
        # 为糖果机的槽补充糖果 计数器+1
        candytray.release()
    except ValueError:
        print('糖果机都满了，无法添加')
    else:
        print('成功添加糖果')
    # 释放线程锁
    lock.release()

# 顾客购买糖果
def buy():
    # 获取线程锁，将购买糖果的操作变为原子操作
    lock.acquire()
    print('购买糖果...',end=' ')
    # 顾客购买糖果 计数器-1，如果购买失败（5个机器都没有糖果了），返回False
    if candytray.acquire(False):
        print('糖果购买成功')
    else:
        print('糖果机为空，无法购买糖果')
    lock.release()

# 产生多个补充糖果的动作
def producer(loops):
    for i in range(loops):
        refill()
        sleep(randrange(3))
# 产生多个购买糖果的动作
def consumer(loops):
    for i in range(loops):
        buy()
        sleep(randrange(3))

def main():
    print('开始：',ctime())
    # 产生一个2-5的随机数
    nloops = randrange(2,6)
    print('糖果机共有%d个槽！' % MAX)
    # 开始一个线程，用于执行consumer函数
    Thread(target=consumer, args=(randrange(nloops, nloops + MAX + 2),)).start()
    # 开始一个线程，用于执行producer函数
    Thread(target=producer, args=(nloops,)).start()

@register
def exit():
    print('程序执行完毕：',ctime())

if __name__ == '__main__':
    main()

10.11 producer_consumer经典案例：消费者和生产者

使用queue模块来提供线程间通信的机制，生产者和消费者共享一个队列
生产者生产商品，消费者消费商品


from random import randrange
from time import sleep,time,ctime
from threading import Lock,Thread
from queue import Queue
# 创建线程锁对象
lock = Lock()
# 从Thread派生的子类
class MyThread(Thread):
    def __init__(self,func,args):
        super().__init__(target=func,args=args)

# 向队列中添加商品
def wrireQ(queue):
    # 获取线程锁
    lock.acquire()
    print('产生了一个对象，并将其添加到队列中',end=' ')
    # 向队列中添加商品
    queue.put('商品')
    print("队列尺寸",queue.qsize())
    # 释放线程锁
    lock.release()

# 从队列中获取商品
def readQ(queue):
    # 获取线程锁
    lock.acquire()
    # 从队列中获取商品
    val = queue.get(1)
    print('消费了一个对象，队列尺寸：',queue.qsize())
    # 释放线程锁
    lock.release()

# 生成若干生产者
def writer(queue,loops):
    for i in range(loops):
        wrireQ(queue)
        sleep(randrange(1,4))

# 生成若干消费者
def reader(queue,loops):
    for i in range(loops):
        readQ(queue)
        sleep(randrange(1,4))

funcs = [writer,reader]
nfuncs = range(len(funcs))

def main():
    nloops = randrange(2,6)
    q = Queue(32)

    threads = []
    # 创建2个线程运行writer函数和reader函数
    for i in nfuncs:
        t = MyThread(funcs[i],(q,nloops))
        threads.append(t)
    # 开始线程
    for i in nfuncs:
        threads[i].start()

    # 等待2个线程结束
    for i in nfuncs:
        threads[i].join()
    print('所有的工作都结束')

if __name__ == '__main__':
    main()

16.12 multi_process多进程

进程和线程的区别：

进程：资源分配的最小单位
线程：调度的最小单位
而一个进程又可以拥有多个线程，简单来说，就是操作系统不能直接将资源分配给线程，而是分配给进程，由进程创建线程来使用资源。

进程池介绍：

  1. 如果建立的进程比较多，可以使用multiprocessing模块的进程池（Pool类），通过Pool类构造方法的processes参数，可以指定创建的进程数
  2. Pool类有一个map方法，用于将回调函数与要给回调函数传递的数据管理起来

from multiprocessing import Pool
import time
# 线程回调函数
def get_value(value):
    i = 0
    while i < 3:
        # 休眠1秒
        time.sleep(1)
        print(value,i)
        i += 1

if __name__ == '__main__':
    # 产生5个值，供多进程获取
    values = ['value{}'.format(str(i)) for i in range(0,5)]
    # 创建4个进程
    pool = Pool(processes=4)
    # 将进程回调函数与values关联
    pool.map(get_value,values)

在这里插入图片描述

程序运行过程中，通过任务管理器查看python进程，会发现多了5个python进程，其中一个是主进程，另外4个是通过Pool创建的子进程

16.13 实操案例：多线程抓取豆瓣音乐Top250排行榜

  1. 本例使用4个线程同时抓取不同的页面，进行分析
  2. 创建一个存储URL的池，一个列表。
  3. 获取这个列表中URL的工作有get_url函数完成，该函数通过线程锁进行了同步
  4. 由于在获取URL后，会将这个URL从列表中删除，所以在多线程环境下必须对这个列表进行同步，否则会出现脏数据
import threading
import datetime
import requests
from bs4 import BeautifulSoup
import re
import time
# 记录开始时间
starttime = datetime.datetime.now()
# 创建线程锁
lock = threading.Lock()
# 从URL列表中获取URL，这是一个同步函数
def get_url():
    global urls
    # 获取URl之前，加资源锁
    lock.acquire()
    if len(urls) == 0:
        lock.release()
        return ""
    else:
        url = urls[0]
        # 提取一个URL后，将整个URL从列表中删除
        del urls[0]

    # 完成工作后，释放锁
    lock.release()
    return url

# 请求头
headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) '
                  'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36',
}

def get_url_music(url,thread_name):
    html = requests.get(url, headers=headers)
    soup = BeautifulSoup(html.text, 'lxml')
    aTags = soup.find_all("a", attrs={"class": "nbg"})
    for aTag in aTags:
        get_music_info(aTag['href'], thread_name)

def get_music_info(url,thread_name):
    html = requests.get(url, headers=headers)
    soup = BeautifulSoup(html.text, 'lxml')
    name = soup.find(attrs={'id': 'wrapper'}).h1.span.text
    author = soup.find(attrs={'id': 'info'}).find('a').text
    styles = re.findall('<span class="pl">流派:</span>&nbsp;(.*?)<br />', html.text, re.S)
    if len(styles) == 0:
        style = '未知'
    else:

        style = styles[0].strip()
    time = re.findall('发行时间:</span>&nbsp;(.*?)<br />', html.text, re.S)[0].strip()
    publishers = re.findall('<span class="pl">出版者:</span>&nbsp;(.*?)<br />', html.text, re.S)
    if len(publishers) == 0:
        publisher = '未知'
    else:
        publisher = publishers[0].strip()

    score = soup.find(class_='ll rating_num').text
    info = {
        'name': name,
        'author': author,
        'style': style,
        'time': time,
        'publisher': publisher,
        'score': score
    }
    print(thread_name, info)

# 这是一个线程类
class SpiderThread(threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)
        # name是线程名
        self.name = name
    def run(self):
        while True:
            # 线程一旦运行，就会不断从URL列表中获取URL，知道列表为空
            url = get_url()
            if url != "":
                get_url_music(url,self.name)
            else:
                break

if __name__ == '__main__':
    url_index = 0
    urls = ['https://music.douban.com/top250?start={}'.format(str(i)) for i in range(0, 100, 25)]
    print(len(urls))
    # 创建新线程
    thread1 = SpiderThread('thread1')
    thread2 = SpiderThread('thread2')
    thread3 = SpiderThread('thread3')
    thread4 = SpiderThread('thread4')

    # 开启线程
    thread1.start()
    thread2.start()
    thread3.start()
    thread4.start()
    thread1.join()
    thread2.join()
    thread3.join()
    thread4.join()
    print("退出爬虫")
    endtime = datetime.datetime.now()
    print('需要时间：', (endtime - starttime).seconds, '秒')

16.14 实操案例2：使用多进程Pool抓取豆瓣音乐Top250

import requests
from bs4 import BeautifulSoup
import re
from multiprocessing import Pool

# 请求头
headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) '
                  'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36',
}

def get_url_music(url):
    html = requests.get(url, headers=headers)
    soup = BeautifulSoup(html.text, 'lxml')
    aTags = soup.find_all("a", attrs={"class": "nbg"})
    for aTag in aTags:
        get_music_info(aTag['href'])

def get_music_info(url):
    html = requests.get(url, headers=headers)
    soup = BeautifulSoup(html.text, 'lxml')
    name = soup.find(attrs={'id': 'wrapper'}).h1.span.text
    author = soup.find(attrs={'id': 'info'}).find('a').text
    styles = re.findall('<span class="pl">流派:</span>&nbsp;(.*?)<br />', html.text, re.S)
    if len(styles) == 0:
        style = '未知'
    else:

        style = styles[0].strip()
    time = re.findall('发行时间:</span>&nbsp;(.*?)<br />', html.text, re.S)[0].strip()
    publishers = re.findall('<span class="pl">出版者:</span>&nbsp;(.*?)<br />', html.text, re.S)
    if len(publishers) == 0:
        publisher = '未知'
    else:
        publisher = publishers[0].strip()

    score = soup.find(class_='ll rating_num').text
    info = {
        'name': name,
        'author': author,
        'style': style,
        'time': time,
        'publisher': publisher,
        'score': score
    }
    print(info)

if __name__ == '__main__':
    urls = ['https://music.douban.com/top250?start={}'.format(str(i)) for i in range(0,100,25)]
    print(len(urls))
    pool = Pool(processes=4)
    pool.map(get_url_music,urls)

结语

目前爬虫专栏已经接近了尾声，最后一个章节将给大家介绍Scrapy框架，节省很多工作，如多线程，数据存储等，希望大家多多支持。
今晚两更！！

川野先生
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python爬虫之多线程、多进程爬虫
02-24
多线程对爬虫的效率提高是非凡的，当我们使用python的多线程有几点是需要我们知道的：1.Python的多线程并不如java的...3.这点其实和多线程关系不大，scrapy的并发并不是采用多线程来实现，它是一个twisted应用，通过异
Python爬虫——Python多线程爬虫详解
Itmastergo的博客
03-21 1643
网络爬虫程序是一种 IO 密集型程序，程序中涉及了很多网络 IO 以及本地磁盘 IO 操作，这些都会消耗大量的时间，从而降低程序的执行效率，而 Python 提供的多线程能够在一定程度上提升 IO 密集型程序的执行效率。
提高爬虫效率之多线程、多进程的使用
m0_64336780的博客
09-22 6749
考虑使用多线程、多进程爬虫使用多线程来处理网络请求，使用线程来处理URL队列中的 url，然后将url返回的结果保存在另一个队列中，其它线程在读取这 个队列中的数据，然后写到文件中将将要爬去的url放在一个队列中，这里使用标准库Queue。访问 url后的结果保存在结果队列中初始化一个URL队列如果队列为空，线程就会被阻塞，直到队列不为空。处理队列中的 一条数据后，就需要通知队列已经处理完该条数据。
Python爬虫案例解析：五个实用案例及代码示例（学习爬虫看这一篇文章就够了）_python抓取数据案例
最新发布
05-12 677
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
爬虫高级应用（17. 网络爬虫框架Scrapy）
to_upper的博客
04-16 1290
使用Scrapy框架抓取数据
高级前端开发工程师的爬虫实战指南
weixin_55846296的博客
06-30 2129
前端爬虫是指在前端环境中使用JavaScript等前端技术实现的网络爬虫。与后端爬虫相比，前端爬虫更侧重于从网页中抽取数据、处理数据和展示数据。前端爬虫作为一项有趣且实用的技能，有助于我们从互联网上获取数据并进行有效的数据分析。通过本文的讲解和真实应用案例的介绍，读者可以掌握前端爬虫的基本原理、常用工具和技巧，并了解其在不同领域的应用。同时，请务必牢记合法合规和道德准则，以保护网络生态的健康发展。
Python的多线程爬虫详解
Python966的博客
01-29 3770
Python 提供了两个支持多线程的模块，分别是 _thread 和 threading。其中 _thread 模块偏底层，它相比于 threading 模块功能有限，因此推荐大家使用 threading 模块。
python爬虫-python多线程爬虫爬取电影天堂资源.zip
02-25
为提高爬虫效率，可以采用多线程或者多进程技术。Python的threading模块提供了多线程功能，通过创建多个线程并行处理任务，可以显著加快数据抓取速度。不过需要注意，由于GIL（全局解释器锁）的存在，Python的多线程...
多线程爬虫源码.zip
08-23
本资源"多线程爬虫源码.zip"提供了一个使用多线程技术实现的网络爬虫的源代码，旨在帮助开发者理解和实践如何构建高效的爬虫系统。 首先，我们需要理解什么是多线程。在计算机科学中，线程是程序执行的基本单元，一...
单线程多线程多进程爬虫实例
12-01
分别使用单线程，多线程，多进程爬取网站图片，python3.7实测可用，其他版本没有试过，存放文件的路径请根据需要进行更改。无意中发现的小网站，悠着点，别给爬崩了。参考了很多大神分享的代码，非常感谢，有问题...
爬虫高阶攻略：从入门到精通！
canshanyin的博客
05-05 1778
爬虫技术日新月异，需要不断学习和实践。本文教大家进阶知识，演练实战技巧，推荐参考资源。希望大家通过这篇文章，可以更好地掌握爬虫技术，成为一名优秀的数据爬取和分析工程师！
python如何在网络爬虫程序中使用多线程(threading.Thread)
热门推荐
hubing_hust的专栏
12-14 1万+
本文介绍了如何在python爬虫程序中使用多线程
如何看待低级爬虫与高级爬虫？
这家伙很懒，什么都没有留下
07-10 1281
低级爬虫（Low-level crawler）通常指的是相对简单和基础的网络爬虫程序，它们使用基本的爬取技术和方法来从网页或网络资源中获取数据。低级爬虫一般具有以下特征：1. 基本的抓取：低级爬虫通常使用基础的HTTP请求和响应机制来获取网页内容。它们可以发送HTTP请求到目标网站，获取HTML或其他格式的响应数据，并对其进行解析和处理。2. 静态网页爬取：低级爬虫主要针对静态网页，即那些内容在每次请求时不会改变的网页。它们可以识别和提取目标网页中的特定信息，如标题、文本、链接等。
Python 爬虫高阶
既然选择远方，便只顾风雨兼程！
03-02 2996
文章目录爬虫高阶一、 验证码识别1、 简介2、 使用方法二、 模拟登录1、 通过抓包分析2、 基于 cookie三、 代理 ip四、 异步爬虫1、 简介2、 异步爬虫方式2.1 多线程，多进程2.2 线程池，进程池2.3 单线程 + 协程（推荐）2.3.1 单任务协程2.3.2 多任务协程五、 selenium1、 简介2、 用法3、 注意4、 动作链 ‘ 爬虫高阶 一、 验证码识别 1、 简介 验证码和爬虫之间的爱恨情仇？ 反爬机制：验证码，识别验证码图片中的数据，用于登录验证 识别验证码的操作：
Python爬虫之scrapy高级(全站爬取,分布式,增量爬虫)
上善若泪
09-19 3437
1 scrapy全站爬取 1.1 全站爬取简介 CrawlSpider：全站数据爬虫的方式，它是一个类，属于Spider的子类 如果不使用CrawlSpider，那么就相当于基于spider，手动发送请求，太不方便 基于CrawlSpider可以很方便地进行全站数据爬取 1.2 CrawlSpider 1.2.1 基本讲解 基本步骤： 创建一个工程:scrapy startproject ProjectName 切换到爬虫工程中后，创建爬虫文件：scrapy genspider -t crawl xxx
Python爬虫——多线程爬虫如何实现？
qq_46147573的博客
07-09 1978
Python爬虫——多任务线程1.多任务2.主线程与子线程3.查看线程数量 1.多任务 多任务指的是在同一时间不同任务需要同时进行的场景，比如边听歌边刷题，边看电视边吃饭… 要实现多任务的进行，我们首先会想到的方式如下： import time # 吃饭 def Eat(): for i in range(4): print('eating...') time.sleep(1) # 看电视 def Watch(): for i in range(4):
Python爬虫的四个水平，你在哪一个层次？
m0_59162248的博客
07-31 3607
Python爬虫老生常谈的话题了，什么兼职接单啦、爬取小说电影榜单、商业化的数据收集等，在大数据时代它能用到的地方还是蛮多的，业余玩玩小意思，如果是想要往这方面学精学深，那得下一番功夫了。爬虫能力按层次来分大概也可以分为初级、中级、高级、更高一级这四个水平，要说爬虫技术能不能达到巅峰？反正我是不敢说有，毕竟学海无涯、学无止境，可以朝着这个目标奋斗哈哈~虽然说学爬虫不需要做到那么精通Python，但如果你是零基础上手编程，基础语法是要认真去学的！万丈高楼平地起！
Python学习三： 爬虫高级技巧 与 模拟实战练习
Alan
08-10 7773
三大爬虫技巧 许多网站针对爬虫的访问都设置了一定的障碍，通过这三步技巧，轻松绕过部分的反爬虫限制。 (1)设置程序休止时间 import time import random # 休止睡眠 1 秒 这里秒可自定义 time.sleep(1); # 随机休眠0或者1秒 random.random(); # 随机休眠1或者5秒 time_interval = random .uniform(...
python多线程爬虫
m0_37623374的博客
05-09 2343
之前博客中介绍的爬取实战都是使用单线程的方法进行爬取。 简单的理解就是只有一个生产者和一个消费者。生产者负责生产出来之后，就由消费者进行消费。属于一对一过程，而多线程属于多个生产者同时生产，由多个消费者同时消费，属于多对多的过程，这就大大的增加了爬取效率。 我们本章主要介绍一下这个过程 设计一个关于生产者赚钱和消费者花钱的这样一个程序！具体及注释看下方代码： import threading#导入线程的库 import random import time gMoney=0 gCondition=thre
Python多线程和多进程爬虫
05-27
Python可以使用多线程和多进程技术来进行爬虫，提高爬虫效率。 多线程爬虫的优点是可以充分利用CPU资源，因为线程之间共享进程的地址空间，所以线程之间切换比较快。同时，多线程爬虫对于IO密集型任务比较适用，比如爬取网页数据。但是多线程也有一些缺点，比如线程之间共享资源需要考虑线程安全问题，容易出现死锁和竞争条件等问题。 多进程爬虫的优点是可以充分利用多核CPU资源，每个进程都有自己独立的地址空间，所以进程之间互相独立，不需要考虑线程安全问题。同时，多进程爬虫对于CPU密集型任务比较适用，比如对数据进行处理和分析。但是多进程爬虫需要考虑进程间通信的问题，因为进程之间无法直接共享内存。 总的来说，多线程爬虫适合IO密集型任务，多进程爬虫适合CPU密集型任务。在实际应用中，可以根据任务的特点选择不同的技术来进行爬虫。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值