Python网络爬虫学习笔记 -第五章:多线程爬虫实践

课程地址 https://edu.csdn.net/course/detail/24756/280664

多线程:

什么是多线程:

  1. 理解:默认情况下,一个程序只有一个进程和一个线程,代码是依次线性执行的。而多线程则可以并发执行,一次性多个人做多件事,自然比单线程更快。
  2. 官方:https://baike.baidu.com/item/多线程/1190404?fr=aladdin

如何创建一个基本的多线程:

使用threading模块下的Thread类即可创建一个线程。这个类有一个target参数,需要指定一个函数,那么以后这个线程执行的时候,就会执行这个函数的代码。示例代码如下:

import time
import threading

def coding():
    for x in range(3):
        print("%d正在写代码..."%x)
        time.sleep(1)

def drawing():
    for x in range(3):
        print("%d正在画图..." % x)
        time.sleep(1)

def multi_thread():
    th1 = threading.Thread(target=coding)
    th2 = threading.Thread(target=drawing)

    th1.start()
    th2.start()

if __name__ == '__main__':
    # single_thread()
    multi_thread()

查看当前线程:

  1. threading.current_thread:在线程中执行这个函数,会返回当前线程的对象。
  2. threading.enumerate:获取整个程序中所有的线程。

继承自threading.Thread类:

  1. 我们自己写的类必须继承自threading.Thread类。
  2. 线程代码需要放在run方法中执行。
  3. 以后创建线程的时候,直接使用我们自己创建的类来创建线程就可以了。
  4. 为什么要使用类的方式创建线程呢?原因是因为类可以更加方便的管理我们的代码,可以让我们使用面向对象的方式进行编程。

全局变量共享的问题:

在多线程中,如果需要修改全局变量,那么需要在修改全局变量的地方使用锁锁起来,执行完成后再把锁释放掉。
使用锁的原则:

  1. 把尽量少的和不耗时的代码放到锁中执行。
  2. 代码执行完成后要记得释放锁。
    在Python中,可以使用threading.Lock来创建锁,lock.acquire()是上锁操作,lock.release()是释放锁的操作。

生产者和消费者模式:

生产者和消费者模式是多线程开发中经常见到的一种模式。生产者的线程专门用来生产一些数据,然后存放到一个中间的变量中。消费者再从这个中间的变量中取出数据进行消费。通过生产者和消费者模式,可以让代码达到高内聚低耦合的目标,程序分工更加明确,线程更加方便管理。

Lock版本的生产者和消费者模式:

import threading
import random

gMoney = 0
gLock = threading.Lock()
gTimes = 0


class Producer(threading.Thread):
    def run(self) -> None:
        global gMoney
        global gTimes
        while True:
            gLock.acquire()
            if gTimes >= 10:
                gLock.release()
                break
            money = random.randint(0, 100)
            gMoney += money
            gTimes += 1
            print("%s生产了%d元钱"%(threading.current_thread().name,money))
            gLock.release()


class Consumer(threading.Thread):
    def run(self) -> None:
        global gMoney
        while True:
            gLock.acquire()
            money = random.randint(0,100)
            if gMoney >= money:
                gMoney -= money
                print("%s消费了%d元钱"%(threading.current_thread().name,money))
            else:
                if gTimes >= 10:
                    gLock.release()
                    break
                print("%s想消费%d元钱,但是余额只有%d"%(threading.current_thread().name,money,gMoney))
            gLock.release()

def main():
    for x in range(5):
        th = Producer(name="生产者%d号"%x)
        th.start()

    for x in range(5):
        th = Consumer(name="消费者%d号"%x)
        th.start()

if __name__ == '__main__':
    main()

Condition版本的生产者和消费者模式:

Lock版本的生产者与消费者模式可以正常的运行。但是存在一个不足,在消费者中,总是通过while True死循环并且上锁的方式去判断钱够不够。上锁是一个很耗费CPU资源的行为。因此这种方式不是最好的。还有一种更好的方式便是使用threading.Condition来实现。threading.Condition可以在没有数据的时候处于阻塞等待状态。一旦有合适的数据了,还可以使用notify相关的函数来通知其他处于等待状态的线程。这样就可以不用做一些无用的上锁和解锁的操作。可以提高程序的性能。首先对threading.Condition相关的函数做个介绍,threading.Condition类似threading.Lock,可以在修改全局数据的时候进行上锁,也可以在修改完毕后进行解锁。以下将一些常用的函数做个简单的介绍:

  1. acquire:上锁。
  2. release:解锁。
  3. wait:将当前线程处于等待状态,并且会释放锁。可以被其他线程使用notify和notify_all函数唤醒。被唤醒后会继续等待上锁,上锁后继续执行下面的代码。
  4. notify:通知某个正在等待的线程,默认是第1个等待的线程。
  5. notify_all:通知所有正在等待的线程。notify和notify_all不会释放锁。并且需要在release之前调用。

代码如下:

import threading
import random
import time

gMoney = 0
gCondition = threading.Condition()
gTimes = 0


class Producer(threading.Thread):
    def run(self) -> None:
        global gMoney
        global gTimes
        while True:
            gCondition.acquire()
            if gTimes >= 10:
                gCondition.release()
                break
            money = random.randint(0, 100)
            gMoney += money
            gTimes += 1
            print("%s生产了%d元钱,剩余%d元钱"%(threading.current_thread().name,money,gMoney))
            gCondition.notify_all()
            gCondition.release()
            time.sleep(1)


class Consumer(threading.Thread):
    def run(self) -> None:
        global gMoney
        while True:
            gCondition.acquire()
            money = random.randint(0,100)
            while gMoney < money:
                if gTimes >= 10:
                    print("%s想消费%d元钱,但是余额只有%d元钱了,并且生产者已经不再生产了!"%(threading.current_thread().name,money,gMoney))
                    gCondition.release()
                    return
                print("%s想消费%d元钱,但是余额只有%d元钱了,消费失败!"%(threading.current_thread().name,money,gMoney))
                gCondition.wait()
            gMoney -= money
            print("%s消费了%d元钱,剩余%d元钱"%(threading.current_thread().name,money,gMoney))
            gCondition.release()
            time.sleep(1)


def main():
    for x in range(5):
        th = Producer(name="生产者%d号"%x)
        th.start()

    for x in range(5):
        th = Consumer(name="消费者%d号"%x)
        th.start()

if __name__ == '__main__':
    main()

线程安全的队列Queue:

在线程中,访问一些全局变量,加锁是一个经常的过程。如果你是想把一些数据存储到某个队列中,那么Python内置了一个线程安全的模块叫做queue模块。Python中的queue模块中提供了同步的、线程安全的队列类,包括FIFO(先进先出)队列Queue,LIFO(后入先出)队列LifoQueue。这些队列都实现了锁原语(可以理解为原子操作,即要么不做,要么都做完),能够在多线程中直接使用。可以使用队列来实现线程间的同步。相关的函数如下:
初始化Queue(maxsize):创建一个先进先出的队列。

  1. qsize():返回队列的大小。
  2. empty():判断队列是否为空。
  3. full():判断队列是否满了。
  4. get():从队列中取最后一个数据。默认情况下是阻塞的,也就是说如果队列已经空了,那么再调用就会一直阻塞,直到有新的数据添加进来。也可以使用block=False,来关掉阻塞。如果关掉了阻塞,在队列为空的情况获取就会抛出异常。
  5. put():将一个数据放到队列中。跟get一样,在队列满了的时候也会一直阻塞,并且也可以通过block=False来关掉阻塞,同样也会抛出异常。

GIL:

什么是GIL:

Python自带的解释器是CPython。CPython解释器的多线程实际上是一个假的多线程(在多核CPU中,只能利用一核,不能利用多核)。同一时刻只有一个线程在执行,为了保证同一时刻只有一个线程在执行,在CPython解释器中有一个东西叫做GIL(Global Intepreter Lock),叫做全局解释器锁。这个解释器锁是有必要的。因为CPython解释器的内存管理不是线程安全的。当然除了CPython解释器,还有其他的解释器,有些解释器是没有GIL锁的,见下面:

  1. Jython:用Java实现的Python解释器。不存在GIL锁。更多详情请见:https://zh.wikipedia.org/wiki/Jython
  2. IronPython:用.net实现的Python解释器。不存在GIL锁。更多详情请见:https://zh.wikipedia.org/wiki/IronPython
  3. PyPy:用Python实现的Python解释器。存在GIL锁。更多详情请见:https://zh.wikipedia.org/wiki/PyPy
    GIL虽然是一个假的多线程。但是在处理一些IO操作(比如文件读写和网络请求)还是可以在很大程度上提高效率的。在IO操作上建议使用多线程提高效率。在一些CPU计算操作上不建议使用多线程,而建议使用多进程。

有了GIL,为什么还需要Lock:

GIL只是保证全局同一时刻只有一个线程在执行,但是他并不能保证执行代码的原子性。也就是说一个操作可能会被分成几个部分完成,这样就会导致数据有问题。所以需要使用Lock来保证操作的原子性。

动态网页爬虫

什么是动态网页爬虫和AJAX技术:

  1. 动态网页,是网站在不重新加载的情况下,通过ajax技术动态更新网站中的局部数据。比如拉勾网的职位页面,在换页的过程中,url是没有发生改变的,但是职位数据动态的更改了。
  2. AJAX(Asynchronouse JavaScript And XML)异步JavaScript和XML。前端与服务器进行少量数据交换,Ajax 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下,对网页的某部分进行更新。传统的网页(不使用Ajax)如果需要更新内容,必须重载整个网页页面。因为传统的在传输数据格式方面,使用的是XML语法。因此叫做AJAX,其实现在数据交互基本上都是使用JSON。使用AJAX加载的数据,即使使用了JS,将数据渲染到了浏览器中,在右键->查看网页源代码还是不能看到通过ajax加载的数据,只能看到使用这个url加载的html代码。

动态网页爬虫的解决方案:

  1. 直接分析ajax调用的接口。然后通过代码请求这个接口。
  2. 使用Selenium+chromedriver模拟浏览器行为获取数据。

selenium和chromedriver:

使用selenium关闭浏览器:

  1. driver.close():关闭当前的页面。
  2. driver.quit():关闭整个浏览器。

selenium定位元素:

  1. find_element_by_id:根据id来查找某个元素。
  2. find_element_by_class_name:根据类名查找元素。
  3. find_element_by_name:根据name属性的值来查找元素。
  4. find_element_by_tag_name:根据标签名来查找元素。
  5. find_element_by_xpath:根据xpath语法来获取元素。
  6. find_element_by_css_selector:根据css选择器选择元素。

要注意,find_element是获取第一个满足条件的元素。find_elements是获取所有满足条件的元素。

selenium表单操作:

  1. webelement.send_keys:给输入框填充内容。
  2. webelement.click:点击。
  3. 操作select标签:需要首先用from selenium.webdriver.support.ui import Select来包装一下选中的对象,才能进行select选择:
    • select_by_index:按索引进行选择。
    • select_by_value:按值进行选择。
    • select_by_visible_text:按照可见文本进行选择。

selenium行为链:

有时候在页面中的操作可能要有很多步,那么这时候可以使用鼠标行为链类selenium.webdriver.common.action_chains.ActionChains来完成。比如现在要将鼠标移动到某个元素上并执行点击事件。那么示例代码如下:

inputTag = driver.find_element_by_id('kw')
submitTag = driver.find_element_by_id('su')
actions = ActionChains(driver)
actions.move_to_element(inputTag)
actions.send_keys_to_element(inputTag,'python')
actions.move_to_element(submitTag)
actions.click(submitTag)
actions.perform()

还有更多的鼠标相关的操作。
click_and_hold(element):点击但不松开鼠标。
context_click(element):右键点击。
double_click(element):双击。

更多方法请参考:http://selenium-python.readthedocs.io/api.html

为什么需要行为链条?
因为有些网站可能会在浏览器端做一些验证行为是否符合人类的行为来做反爬虫。这时候我们就可以使用行为链来模拟人的操作。行为链有更多的复杂操作,比如双击,右键等,在自动化测试中非常有用。

操作cookie:

  1. 获取所有的cookie:
    for cookie in driver.get_cookies():
        print(cookie)
    
  2. 根据cookie的key获取value:
    value = driver.get_cookie(key)
    
  3. 删除所有的cookie:
    driver.delete_all_cookies()
    
  4. 删除某个cookie:
    driver.delete_cookie(key)
    
  5. 添加cookie:
    driver.add_cookie({“name”:”username”,”value”:”abc”})
    

隐式等待和显式等待:

  1. 隐式等待:指定一个时间,在这个时间内一直会处于等待状态。隐式等待需要使用driver.implicitly_wait
  2. 显式等待:指定在某个时间内,如果某个条件满足了,那么就不会再等待,如果在指定的时间内条件都不满足,那么就不会再等待了。显式等待用的方法是from selenium.webdriver.support.ui import WebDriverWait。示例代码如下:
    driver.get("https://kyfw.12306.cn/otn/leftTicket/init?linktypeid=dc")
    WebDriverWait(driver,100).until(
        EC.text_to_be_present_in_element_value((By.ID,"fromStationText"),"长沙")
    )
    WebDriverWait(driver,100).until(
        EC.text_to_be_present_in_element_value((By.ID,"toStationText"),"北京")
    )
    btn = driver.find_element_by_id("query_ticket")
    btn.click()
    

打开新窗口和切换页面:

  1. selenium中没有专门的打开新窗口的方法,是通过window.execute_script()来执行js脚本的形式来打开新窗口的。
    window.execute_script("window.open('https://www.douban.com/')")
    
  2. 打开新的窗口后driver当前的页面依然还是之前的,如果想要获取新的窗口的源代码,那么就必须先切换过去。示例代码如下:
    window.switch_to.window(driver.window_handlers[1])
    

设置代理:

设置代理通过ChromeOptions来设置,示例代码如下:

options = webdriver.ChromeOptions()
options.add_argument("--proxy-server=http://110.52.235.176:9999")
driver = webdriver.Chrome(executable_path="D:\ProgramApp\chromedriver\chromedriver73.exe",chrome_options=options)

driver.get("http://httpbin.org/ip")

补充:

  1. get_property:获取html标签中官方写好的属性。
  2. get_attribute:获取html标签中官方和非官方的属性。
  3. driver.save_screenshoot:获取当前页面的截图,有时候请求失败了,那么可以把当前网页的截图保存下来,方便后期进行分析。
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值