爬虫知识总结

一、 爬虫是否违法？

• 法不禁止即为许可
• 隐匿自己的身份（商业IP代理）
• 不要被目标网站举证有破坏动产行为
• 尽量遵守爬虫协议（robots.txt）

二、 爬虫的分类和作用？

• 通用爬虫 —> 搜索引擎
• 定向爬虫 —> 有具体的爬取目标

对中小企业来说，数据一定是短板，要么花钱买数据，要么写爬虫
国家机器和很多的互联网产品做舆情监控基本也是通过网络爬虫来

三、 爬虫怎么写？

1、抓取页面 —> requests / aiohttp

2、解析页面

• 正则表达式解析 —> re（regular expression）

  • compile() —> Pattern
  • search() / match() —> Match —> group()
  • findall() —> list

• XPath解析 —> lxml

  • 右键菜单“检查” —> Copy —> Copy full XPath

• CSS选择器解析 —> beautifulsoup4 / pyquery

  • BeautifulSoup
    • select()：获取跟CSS选择器匹配的元素（列表）
    • select_one()：获取跟CSS选择器匹配的第一个元素 —> Tag
      • text：获取标签中的内容
      • attrs：字典，通过键值对的方式获取标签的属性值

3、保存数据

• CSV（逗号分隔值文件）—> csv
  • reader / writer —> writerow()
• Excel —> xlrd / xlwt / openpyxl
  • Workbook —> 工作簿 —> create_sheet()
    —> Worksheet —> 工作表
    —> cell(row, col, value) —> 单元格

四、如何抓取动态内容？

1、直接找到提供JSON数据的接口

• 浏览器开发者工具 —> Network —> XHR
• 专业的抓包工具 —> Charles / Fiddler / Wireshark

2、 Selenium驱动浏览器获取动态内容

​ - 自动化测试工具

• IDE

• Remote Control

• WebDriver：驱动浏览器模拟用户操作 —> 抓取到动态内容

  • - Chrome()

    • get()：加载页面

    • 隐式等待 / 显示等待

      • implictly_wait(10)：如果元素在10秒内没有出现就引发异常
      • WebDriverWait(browser, 10) —> until() —> 指定等待条件

    • page_source：页面带动态内容的HTML代码

    • find_element_by_xxx() —> WebElement

    • find_elements_by_xxx() —> [WebElement]

      • text：获取标签中的文本内容

      • get_attribute()：获取标签属性

import time
from concurrent.futures.thread import ThreadPoolExecutor

import requests
from selenium.webdriver import Chrome


def dowload_image(image_url):
    resp = requests.get(image_url)
    if resp.status_code == 200:
        filename = image_url[image_url.rfind('/') + 1:]
        try:
            with open(f'image360/{filename}', 'wb') as f:
                for data in resp.iter_content(512):
                    f.write(data)
        except OSError:
            pass


def main():
    browser = Chrome()
    browser.get('https://image.so.com/z?ch=beauty')

    for _ in range(20):
        # 让浏览器执行JS代码
        browser.execute_script('window.scrollTo(0, window.scrollY + 1500)')
        time.sleep(0.5)

    # 隐式等待
    # 在使用find_xxx方法获取页面元素时，如果元素没有出现，可以等待指定时间，
    # 如果等待超时就引发异常，如果在指定的时间内获取到元素就返回对应的元素
    browser.implicitly_wait(10)
    # 显示等待  ---> 创建一个等待对象
    # wait = WebDriverWait(browser, 10)
    # # 设置等待条件
    # wait.until(expected_conditions.presence_of_element_located(
    #     (By.CSS_SELECTOR, 'span.img > img')
    # ))
    image_tags = browser.find_elements_by_css_selector('span.img>img')
    # print(len(image_tags))

    with ThreadPoolExecutor(max_workers=32) as pool:
        start = time.time()
        for image_tags in image_tags:
            image_url = image_tags.get_attribute('src')
            pool.submit(dowload_image, image_url)
    end = time.time()
    print(f'下载耗时:{end - start:.3f}秒')
    browser.close()


if __name__ == '__main__':
    main()

五、如何实现并发（并行）编程？

并行：真正的同时进行，需要多CPU的支持

并发：可能不是真正的同时进行，但是通过快速的切换制造出并行的效果

线程：操作系统分配CPU的基本单位，最小的执行单元

进程：操作系统分配内存的基本单位，是程序在一组数据上的活动

通常我们启动一个程序，就启动了一个（或多个）进程，一个进程中又可以包含
一个或多个线程。

单线程（只有主线程，只有唯一的一个执行线索）

• 多线程 —> I/O密集型任务（爬虫）—> GIL（全局解释器锁）—> 无法使用多核特性
• 多进程 —> 计算密集型任务（音视频编解码、文件压缩、机器学习算法）
• 异步编程 —> I/O密集型任务（爬虫）—> 通过提高CPU利用率达到协作式并发

C —> CPython —> malloc() / free()
Java —> Jython
C# —> IronPython
Python —> PyPy

import random
import time
from concurrent.futures.thread import ThreadPoolExecutor

"""
装饰器：用一个函数去装饰另一个函数或者类，为其提供额外的功能(横切关注功能：程序中和正常业务逻辑没有必然关联的功能)

装饰器实现了设计模式(前任总结的可重用的设计理念)中的代理模式(proxy pattern)

cross-concern
一等函数(一等公民):
    ~ 函数可以赋值给变量
    ~ 函数可以作为函数的参数
    ~ 函数可以作为函数的返回值
"""


# 装饰器的参数是被装饰的函数，返回值是带有装饰功能的函数
def record_time(func):
    # 带有装饰功能的函数(除了执行原函数外，返回值是带有装饰功能的函数)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f'{func.__name__}时间:{end - start:.3f}秒')
        return result

    return wrapper


# download = record_time(download)
@record_time
def download(filename):
    print(f'开始下载{filename}.')
    time.sleep(random.randint(4, 6))
    print(f'{filename}下载完成.')


@record_time
def upload(filename):
    print(f'开始下载{filename}.')
    time.sleep(random.randint(5, 8))
    print(f'{filename}上传完成.')


@record_time
def main():
    # # 通过调用Thread类的构造器就可以穿件线程对象，
    # # 指定target和args参数告诉线程启动后要执行的任务以及对应的参数
    # t1 = Thread(target=download, args=('Python从入门到住院'), )
    # t2 = Thread(target=download, args=('MySQl从删库到跑路'), )
    # t3 = Thread(target=upload, args=('数据分析从精通到放弃'), )
    # # 通过调用线程对象的star()方法启动线程
    # t1.start()
    # t2.start()
    # t3.start()
    # # 通过调用线程对象的join()方法等待线程结束
    # # 让主线程等待t1、t2、t3对应的线程执行结束
    # t1.join()
    # t2.join()
    # t3.join()
    # 创建和释放一个线程是有比较大的系统开销，如果系统频繁的地释放线程，
    # 那么代码的性能也会受到影响，所以使用线程最佳的方式是提前创建线程池，
    # 线程池是一个容器，维持了若干个线程对象，需要线程的时候就从线程池中
    # 获取一个线程，用完了之后不释放而是归还给线程池，以便重复使用
    with ThreadPoolExecutor(max_workers=32) as pool:
        # 调用线程池对象的submit方法教给线程池中的线程去执行
        # submit方法会返回Future对象(让你在将来可以获得线程的执行结果)
        pool.submit(download, 'Python从入门到住院')
        pool.submit(download, 'MySQl从删库到跑路')
        pool.submit(upload, '数据分析从精通到放弃')
        # f1.result()
        # f2.result()
        # f3.result()


if __name__ == '__main__':
    main()

ps：老师推荐的光学文字识别服务

easyocr —> ocr (optical character recognition)

pip install easyocr