梨视频,进程池、线程池爬取

[TOC]

进程池

import requests, re, time
from multiprocessing.dummy import Pool
import random

IpPool = [{‘http‘: ‘183.147.230.104: 8118‘}, {‘http‘: ‘60.217.64.237: 31923‘},
          {‘http‘: ‘221.193.50.166: 8118‘}]

url = ‘https://www.pearvideo.com/category_loading.jsp?reqType=5&categoryId=9&start=0‘

start = time.time()

video_list=[]

ret = requests.get(url)
reg = ‘<a href="(.*?)" class="vervideo-lilink actplay">‘
video_urls = re.findall(reg, ret.text)
print(video_urls)
for url in video_urls:
    proxy = random.choice(IpPool)
    ret_detail = requests.get(‘https://www.pearvideo.com/‘ + url, proxies=proxy)
    print(proxy)
    reg = ‘srcUrl="(.*?)",vdoUrl=srcUrl‘
    mp4_url = re.findall(reg, ret_detail.text)[0]  # type:str

    video_name = mp4_url.rsplit(‘/‘, 1)[-1]

    dic = {
        ‘v_name‘: video_name,
        ‘v_url‘: mp4_url
    }
    video_list.append(dic)

print(video_list)
def get_video(dic):
    url = dic[‘v_url‘]
    name = dic[‘v_name‘]
    print(f‘开始下载{name}‘)
    video_data = requests.get(url=url)
    print(url)
    with open(name, ‘wb‘) as f:
        for line in video_data.iter_content():
            f.write(line)
        print(f‘{name}下载完成‘)

    end = time.time()
    ctime = end - start
    print(ctime)

pools = Pool(12)
pools.map(get_video, video_list)
pools.close()
pools.join()

线程池

import requests
import re
import random
from concurrent.futures import ThreadPoolExecutor

import time
start = time.time()

pool = ThreadPoolExecutor(12)

IpPool = [{‘http‘: ‘183.147.230.104: 8118‘}, {‘http‘: ‘60.217.64.237: 31923‘},
          {‘http‘: ‘221.193.50.166: 8118‘}]

url = ‘https://www.pearvideo.com/category_loading.jsp?reqType=5&categoryId=9&start=0‘

video_list=[]

ret = requests.get(url)
reg = ‘<a href="(.*?)" class="vervideo-lilink actplay">‘
video_urls = re.findall(reg, ret.text)
print(video_urls)
for url in video_urls:
    proxy = random.choice(IpPool)
    ret_detail = requests.get(‘https://www.pearvideo.com/‘ + url, proxies=proxy)
    print(proxy)
    reg = ‘srcUrl="(.*?)",vdoUrl=srcUrl‘
    mp4_url = re.findall(reg, ret_detail.text)[0]  # type:str

    video_name = mp4_url.rsplit(‘/‘, 1)[-1]

    dic = {
        ‘v_name‘: video_name,
        ‘v_url‘: mp4_url
    }
    video_list.append(dic)

def get_video(dic):
    url = dic[‘v_url‘]
    name = dic[‘v_name‘]
    print(f‘开始下载{name}‘)
    video_data = requests.get(url=url)
    print(url)
    with open(name, ‘wb‘) as f:
        for line in video_data.iter_content():
            f.write(line)
        print(f‘{name}下载完成‘)
        end = time.time()
        ctime = end - start
        print(ctime)

print(video_list)
def main():
    for url in video_list:
        done = pool.submit(get_video, url)

if __name__ == ‘__main__‘:
    main()
    pool.shutdown(wait=True)

原文地址:https://www.cnblogs.com/kai-/p/12658461.html

时间: 2024-11-08 17:14:57

梨视频,进程池、线程池爬取的相关文章

使用进程池模拟多进程爬取url获取数据,使用进程绑定的回调函数去处理数据

1 # 使用requests请求网页,爬取网页的内容 2 3 # 模拟使用进程池模拟多进程爬取网页获取数据,使用进程绑定的回调函数去处理数据 4 5 import requests 6 from multiprocessing import Pool 7 8 # response = requests.get('http://www.baidu.com') # 访问网页获取网页内容,得到一个网页内容的结果对象<Response [200]>这个200是一个状态码,200表示网页正常的返回,40

进程池/线程池/协程

导入进程池线程池模块@@ from concurrent import ProcessPoolExecutor,ThreadPoolExecutor 同步提交,异步提交@@ from concurrent import ProcessPoolExecutor,ThreadPoolExecutorimport osdef foo(name): print('进程%s,进程号为%s'%(name,os.getpid())) return os.getpid() if __nmae__=='__mai

Python3 从零单排28_线程队列&amp;进程池&amp;线程池

1.线程队列 线程队列有三种:先进先出,后进先出,按优先级进出,具体如下: 1 import queue 2 3 # 先进先出 4 q = queue.Queue(3) 5 6 q.put(1) 7 q.put(2) 8 q.put(3) 9 # q.put(4) # 再放阻塞,等待队列消费 10 # q.put(4,block = False) # 不阻塞,强制放数据,如果满的情况下直接报错 等价与 q.put_nowait(4) 11 # q.put(4,block = True) # 阻塞

进程池线程池 协程

socket服务端实现并发 服务端需要满足以下3点: 1 固定的ip和port 2 24小时提供服务 3 能够实现并发 多线程实现并发: 服务端: import socket from threading import Thread import os server = socket.socket() server.bind(('127.0.0.1',8080)) server.listen(5) #半连接池 def communicate(conn): while True: try: dat

Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池

目录 Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池 1.昨日回顾 2.死锁现象与递归锁 2.1死锁现象 2.2递归锁 3.信号量 4.GIL全局解释器锁 4.1背景 4.2为什么加锁 5.GIL与Lock锁的区别 6.验证计算密集型IO密集型的效率 6.1 IO密集型 6.2 计算密集型 7.多线程实现socket通信 7.1服务端 7.2客户端 8.进程池,线程池 Python并发编程05/ 死锁/递归锁/信号量/GIL锁/进程池/线程池 1.昨日回顾 #生产者消

进程池线程池

进程池,线程池 什么是池 # 要在程序开始的时候,还没提交任务先创建固定数量的进程或线程 放在一个池子里,这就是池 为什么要用池? # 如果先开好进程/线程,那么有任务之后就可以直接使用这个池中的数据了 # 并且开好的线程或者进程会一直存在在池中 处理完毕进程并不关闭,可以被多个任务反复利用 # 这样极大的减少了开启\关闭\调度线程/进程的时间开销 # 池中的线程/进程个数控制了操作系统需要调度的任务个数,控制池中的单位 # 有利于提高操作系统的效率,减轻操作系统的负担 开启一个池 from c

并发编程---线程queue---进程池线程池---异部调用(回调机制)

线程 队列:先进先出 堆栈:后进先出 优先级:数字越小优先级越大,越先输出 import queue q = queue.Queue(3) # 先进先出-->队列 q.put('first') q.put(2) # q.put('third') # q.put(4) #由于没有人取走,就会卡主 q.put(4,block=False) #等同于q.get_nowait(), Ture 阻塞,Flase不阻塞,报异常满了 # # q.put(4,block=True,timeout=3) prin

android线程与线程池-----线程池(二)《android开发艺术与探索》

android 中的线程池 线程池的优点: 1 重用线程池中的线程,避免了线程的创建和销毁带来的性能开销 2 能有效的控制最大并发数,避免大量线程之间因为喜欢抢资源而导致阻塞 3 能够对线程进行简单的管理,提供定时执行以及指定间隔时间循环执行等 android 中的线程池源自java 中的Executor,Executor是一个接口,正真的实现是ThreadPoolExecutor. ThreadPoolExecutor 提供参数配置线程池. 下面是一个常用的构造方法: public Threa

9-[多线程] 进程池线程池

1 # 进程池,线程池 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor import os import time def task(name): print('%s is running <pid: %s>' % (name, os.getpid())) time.sleep(2) if __name__ == '__main__': # p = Process(target=task, args=

GIL全局解释器锁和进程池.线程池

GIL全局解释器锁 GIL本质就是一把互斥锁,是夹在解释器身上的,同一个进程内的所有线程都需要先抢到GIl锁,才能执行解释器代码 GIL的优缺点: 优点:保证Cpython解释器内存管理的线程安全 缺点:同一个进程内所有的线程同一时刻只能有一个执行,也就是说Cpython解释器的多线程无法实现并行,无法取得多核优势 GIL与单线程 每个进程的内存空间中都有一份python解释器的代码,所以在单线程的情况下,GIL锁没有线程争抢,只有垃圾回收机制线程会定时获取GIL权限 GIL与多线程 有了GIL