文章目录
本文为马士兵教育《Python网络爬虫进阶指南》课程笔记,部分内容由AI生成。课件:第一章,第二章,第三章,第四章,第五章,第六章,第七章,第九章,第十章。
一、多线程网络爬虫
1.1 线程的基础内容、GIL
以下是一些基础概念:
- 程序:
- 编程语言编写的指令的集合,用于实现一定的功能;
- 程序本身只是一组静态的指令和数据,并不直接占用计算机的资源。
- 进程:
- 启动后的程序称为进程,一个进程至少有一个线程;
- 进程是操作系统中的执行单元,每个进程都包含了程序的执行所需的资源,如内存空间、文件句柄、系统状态等,所以进程之间相互独立、数据隔离;
- 进程通常由操作系统进行调度,以便在多个进程之间实现并发执行。
- 线程:
- 线程是CPU调度执行的基本单元,一个进程可以包含多个线程;
- 多个线程共享同一个进程的资源(除了CPU资源),包括内存空间和系统状态,所以线程之间可以更方便地进行数据交换
- 线程的引入是为了更有效地实现多任务并发,因为线程的创建和切换开销比进程要小得多。
综合来说,程序是一组指令和数据的集合,描述了任务的执行过程。进程是操作系统中的一个执行单元,包含了程序的执行所需的资源。线程是进程内的执行单元,多个线程共享进程的资源,用于实现更高效的多任务并发。
多个进程的多个线程同时进行时,CPU会通过调度算法来分配CPU时间片,以便每个进程的每个线程都能得到执行。常用的进程调度算法有:
- 先来先服务(FCFS): 按照进程或线程的到达时间先后顺序来分配CPU时间片。
- 优先级调度: 根据进程或线程的优先级来分配CPU时间片,优先级高的进程或线程将获得更多的CPU时间片。
- 轮转调度: 按照进程或线程的编号顺序来分配CPU时间片,每个进程或线程都将获得等量的CPU时间片。
- 抢占式调度: 允许操作系统在任何时候抢占正在执行的进程或线程,并将CPU时间片分配给其他进程或线程。这种调度方式确保了高响应性和公平性,但需要处理上下文切换的开销。
在多核CPU中,多个线程可以同时运行,但每个核心一次只能执行一个线程。操作系统使用线程调度算法来决定将哪些线程分配给哪些核心。线程调度的目标是最大程度地利用多核处理器的性能,以及确保线程间的平衡和公平性。
打开任务管理器,就可以看到当前电脑上活动的进程:
CPython 是 Python 编程语言的官方实现,是最常用的 Python 解释器之一,在多数情况下,“Python” 指的就是 CPython。
需要注意的是,尽管
CPython
是最常用的 Python 实现,但也有其他的 Python 实现,如Jython
(运行在 Java 虚拟机上)、IronPython
(运行在 .NET 平台上)、PyPy
(一个高性能的JIT
编译器实现)、MicroPython(用于IoT
设备和嵌入式系统。)等,它们在一些特定场景下具有独特的优势。
CPython
的一个重要特点是全局解释器锁(GIL
),它限制了同一时刻只有一个线程能够执行 Python 代码。这意味着在多线程程序中,虽然可以使用多个线程,但是多个线程不能同时并行执行 Python 代码(一般是多个线程来回切换,等待的线程可以执行I/O
等操作),这使得 CPython 在多核 CPU 上无法充分利用多核性能。
在执行计算密集型任务时(图像处理和视频编码、大规模矩阵运算、数据处理等),多线程并不能真正实现多核并行处理,因为多个线程无法同时在不同的核心上执行。此时建议使用 multiprocessing模块或 concurrent.futures模块来创建多个进程,充分利用多核处理器的并行计算能力。
每个进程都有自己独立的解释器和
GIL
,因此可以在多个核心上并行执行计算密集型任务。
尽管 GIL
限制了多线程在计算密集型任务上的效果,但在处理 I/O
密集型任务时,多线程仍然是一个合适的模型。因为 I/O
操作(如文件读写、网络请求、数据库操作、图片上传下载、用户界面应用等)往往会涉及等待,此时线程可以在等待期间执行其他任务,从而充分利用 CPU 时间。
另外在单线程情况下,一个 I/O 操作的阻塞会导致整个程序暂停执行,直到 I/O 完成。使用多线程可以避免这种情况,因为其他线程仍然可以继续执行。
利用系统监测工具(如 top、htop 等)观察 CPU 使用率和等待 I/O 的情况。如果 CPU 使用率高且 I/O 等待时间相对较少,可能是计算密集型;如果 CPU 使用率较低且 I/O 等待时间较长,可能是 I/O 密集型,这只是一种粗略的判定方法。
1.2 创建线程的两种方式
Threading
是一个Python 标准库,专用于进行python多线程编程。在 Python 中,有两种主要的方式来创建线程对象:
- 传递目标函数
import threading
# 目标函数
def my_task(param):
print("Thread task with param:", param)
# 创建线程对象,传递目标函数和参数
my_thread = threading.Thread(target=my_task, args=("Hello",))
my_thread.start()
Thread task with param: Hello
- 继承 Thread 类
import threading
# 如果不需要自定义属性,则不需要重写init方法
class MyThread(threading.Thread):
def __init__(self, param):
super().__init__()
self.param = param
self.custom_data = ['Hello'] # 自定义属性,用于存储数据
def run(self):
print("Thread task with param:", self.param)
self.custom_method() # 调用自定义方法
def custom_method(self):
print("Custom method called.")
self.custom_data.append(self.param)
def get_custom_data(self):
return self.custom_data
# 创建自定义线程对象
my_thread = MyThread("World")
my_thread.start()
my_thread.join()
# 调用自定义方法和属性
custom_data = my_thread.get_custom_data()
print("Custom data:", custom_data)
Thread task with param: Hello
Custom method called.
Custom data: ['Hello','World']
在第一种方式中,我们直接创建了一个线程对象,传递目标函数和参数。在第二种方式中,我们继承了 Thread
类,并重写了 run
方法。在 run 方法中,我们首先执行线程任务,然后调用了自定义方法。在主线程中,我们调用了 get_custom_data 方法来获取自定义属性的值。
这两种方法都可以创建线程对象,但也有一些区别:
- 传递目标函数:简单直观,不需要创建新的类。如果你只需要简单并行执行某个函数,使用传递目标函数的方式会更方便
- 继承 Thread 类:这种方式是通过继承 Thread 类并重写其 run 方法来实现的。你可以在 run 方法中定义线程要执行的任务。这种方式适用于需要更多控制和封装的情况,可以在子类中添加自定义方法和属性,适用于复杂的多线程场景。
在继承
threading.Thread
类并重写了run
方法的情况下,如果你同时设置了target
参数,实际上只有run
方法会被调用。这是因为run
方法是线程对象启动时默认要执行的方法,而target
参数是用来指定替代的目标函数。
如果你重写了run
方法,那么线程对象在启动时会自动调用你重写的run
方法,而不会执行通过target
参数指定的目标函数。因此,在这种情况下,设置target
参数是没有意义的。
1.3 threading.Thread
类
在python中,我们主要使用继承 threading.Thread类的方式来创建线程对象,下面介绍一下 Thread 类的语法和各个参数的含义。
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
group
: 线程组,为了日后扩展 ThreadGroup 类实现而保留,目前不支持。target
: 指定线程要执行的目标函数。线程对象在启动时会调用 run 方法,而 target 参数指定了在 run 方法中要执行的任务。name
: 设置线程的名称(字符串标识)。- 线程的名称可以在多线程程序中用来识别和区分不同的线程。这在调试和理解多线程程序时非常有用。
- 在默认情况下,会以 “Thread-N” 的形式构造唯一名称,如果指定了 target 参数的话,就是 “Thread-N (target)” 的形式。
args
: 传递给目标函数的位置参数(以元组形式)。kwargs
: 传递给目标函数的关键字参数(以字典形式)。daemon
: 设置线程是否为守护线程,默认为 False。在多线程程序中,有两种类型的线程:主线程(Main Thread)和守护线程(Daemon Thread)。- 主线程是程序的入口,它会等待所有的非守护线程执行完成后才结束,主线程结束意味着程序即将退出。
- 守护线程是一种后台线程。如果所有的非守护线程都结束了,守护线程会被强制终止,即使它的任务还没有执行完成,因此它们适用于一些不需要完全执行的后台任务,例如日志记录、监控等。
下面介绍一下Thread
类的主要方法和属性:
-
start()
方法: 启动线程,调用线程对象的 run 方法执行线程任务。 -
join()
方法: 等待线程执行完成。- 当调用线程对象的
join()
方法时,主线程(或当前线程)将被阻塞,直到目标线程执行完成。 - 可选参数为
timeout
,表示最长等待时间(s)。如果在指定的时间内目标线程未执行完成,主线程将继续执行。 - 如果不使用
join()
方法,主线程可能会在目标线程执行之前就完成,所以join()
方法可以保证线程之间的协调和正确的执行顺序
- 当调用线程对象的
-
is_alive()
方法: 用于检查线程是否处于活动状态,即是否正在执行。 -
name
属性: 用于获取或设置线程的名称。 -
ident
属性: 用于获取线程的唯一标识符。 -
daemon
属性: 用于设置线程是否为守护线程。守护线程会随着主线程的结束而结束。 -
target
属性: 用于获取或设置线程要执行的目标函数。 -
args
和kwargs
属性: 用于获取线程函数的参数,分别是位置参数和关键字参数。
以下是一个示例,演示了如何使用 Thread 类的主要方法和属性:
import threading
import time
class MyThread(threading.Thread):
def __init__(self, name, seconds):
super().__init__()
self.name = name
self.seconds = seconds
self.custom_data = [] # 自定义属性,用于存储数据
def run(self):
print(f"Thread {self.name} is running for {self.seconds} seconds.")
self.custom_method() # 调用自定义方法
time.sleep(2)
print(f"Thread {self.name} is complete.")
def custom_method(self):
print(f"Custom method of Thread {self.name} is called.")
self.custom_data.append(self.name)
def get_custom_data(self):
return self.custom_data
# 创建自定义线程对象并启动
thread = MyThread(name="MyThread", seconds=3)
thread.start()
# 获取线程名称和标识符、活动状态和是否为守护程序
print("Thread name:", thread.name)
print("Thread identifier:", thread.ident)
print("Is thread alive:", my_thread.is_alive())
print("Is daemon thread:", my_thread.daemon)
# 等待线程执行完成
thread.join()
# 使用自定义方法和属性
custom_data = thread.get_custom_data()
print("Custom data for Thread:", custom_data)
print("Main thread finished.")
Thread MyThread is running for 3 seconds.
Custom method of Thread MyThread is called.
Thread name: MyThread
Thread identifier: 7656
Is thread alive: False
Is daemon thread: False
Thread MyThread is complete.
Custom data for Thread: ['MyThread']
Main thread finished.
1.4 线程常用方法和锁机制
- 线程常用方法
threading 模块函数 | 作用 |
---|---|
threading.active_count() | 返回当前活动线程的数量,返回值与 enumerate() 所返回的列表长度一致 |
threading.current_thread() | 返回当前线程对象。 |
threading.enumerate() | 返回所有活动线程对象的列表,包括守护线程以及 current_thread() 创建的空线程 |
threading.main_thread() | 返回主线程对象。一般情况下,主线程是Python解释器开始时创建的线程 |
threading.get_ident() | 返回当前线程的标识符(非零的整数)。 |
- 线程的安全性和锁机制
在多线程编程中,当多个线程同时访问和操作共享资源时,可能会出现问题。例如,一个线程正在修改某个变量的值,而另一个线程也在同时访问并修改相同的变量。这可能导致数据不一致或者程序崩溃,下面以车站售票举例说明:
import threading
import time
ticket = 100 # 全局变量
def sale_ticket():
# 在函数中要修改 ticket 全局变量的值,就必须在函数内部使用global ticket声明
global ticket
for i in range(1000): # 模拟1000个人买票
while ticket >0: # 持续售票,直到所有票都售完
print(threading.current_thread().name + '--》正在出售第{}张票'.format(ticket))
ticket -= 1
time.sleep(0.1)
def start():
for i in range(2):
t = threading.Thread(target=sale_ticket)
t.start()
if __name__ == '__main__':
start() # 调用自定义的 start() 函数,创建线程对象并启动线程
Thread-1 (sale_ticket)--》正在出售第62张票
Thread-2 (sale_ticket)--》正在出售第61张票
Thread-1 (sale_ticket)--》正在出售第60张票Thread-8 (sale_ticket)--》正在出售第60张票
Thread-1 (sale_ticket)--》正在出售第58张票
打印结果显示第60张票同时被两个线程操作,导致售票出错(线程是实时调度的,每次结果会不一样)。
为了避免这种竞争条件(多个线程在访问共享资源时发生的问题),我们可以使用锁来保护共享资源,确保一次只有一个线程可以访问资源。threading
模块就提供了 Lock
和 RLock
类来实现锁机制:
Lock
锁: 互斥锁,也是最基本的锁,一次只允许一个线程持有锁,其他线程需要等待锁的释放。当一个线程获取了锁,其他线程将被阻塞,直到锁被释放。RLock
锁:可重入锁 ,也称为递归锁。同一个线程可以多次获取同一个锁,而不会造成死锁。每次获取锁后,锁的计数器会增加,必须释放相同次数的锁,才能真正释放锁。
方法 | 作用 |
---|---|
threading.Lock() | 创建锁对象 |
lock.acquire(blocking=True, timeout=None) | 获取锁,阻塞当前线程直到锁可用或超时。 |
lock.release() | 释放锁,允许其他线程获取锁。 |
lock.locked() | 返回 True 如果锁已经被某个线程获得,否则返回 False 。 |
lock.__enter__() | 作为上下文管理器的一部分,用于获取锁。 |
lock.__exit__(exc_type, exc_value, traceback) | 作为上下文管理器的一部分,用于释放锁。 |
RLock
的创建和方法与 Lock
完全一致,就不再赘述。
我们可以手动调用 acquire()
和 release()
方法来管理锁的获取和释放,也可以使用下文管理器来完成。进入 with 语句块时,lock.__enter__()
方法被调用,获取锁;当退出 with 语句块时,lock.__exit__()
方法被调用,释放锁;所以使用with语句,会使得代码更加清晰和简洁。
import threading
import time
ticket = 100 # 全局变量
lock = threading.Lock() # 创建一个线程锁
def sale_ticket():
global ticket
for i in range(1000):
while ticket >0: # 持续售票,直到所有票都售完
with lock: # 使用线程锁进行同步
print(threading.current_thread().name + '--》正在出售第{}张票'.format(ticket))
ticket -= 1
time.sleep(0.1)
def start():
for i in range(2):
t = threading.Thread(target=sale_ticket)
t.start()
if __name__ == '__main__':
start() # 调用自定义的 start() 函数,创建线程对象并启动线程
- 死锁
不正确地使用锁可能会导致死锁。死锁是指多个线程相互等待对方释放资源,从而陷入无法继续执行的状态。下面是一个比较经典的示例,展示了如何使用两个线程和两个锁来制造死锁的情况:
import threading
lock1 = threading.Lock()
lock2 = threading.Lock()
def worker1():
with lock1:
print("Worker 1 acquired lock 1")
# 为了模拟死锁,故意在获取第一个锁后休眠一段时间
# 从而在 worker2 尝试获取 lock2 时,无法释放 lock1
# 导致 worker1 和 worker2 互相等待
import time
time.sleep(1)
print("Worker 1 waiting for lock 2")
with lock2:
print("Worker 1 acquired lock 2")
def worker2():
with lock2:
print("Worker 2 acquired lock 2")
print("Worker 2 waiting for lock 1")
with lock1:
print("Worker 2 acquired lock 1")
if __name__ == "__main__":
thread1 = threading.Thread(target=worker1)
thread2 = threading.Thread(target=worker2)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print("Main thread finished")
下面这段代码将 worker2 中的第一个锁获取由 lock2 改为了 lock1,这样两个线程都会按相同的顺序获取锁,避免了死锁情况的发生。
def worker2():
with lock1: # 修改为使用相同的锁顺序
print("Worker 2 acquired lock 1")
print("Worker 2 waiting for lock 2")
with lock2:
print("Worker 2 acquired lock 2")
为了避免死锁,还可以考虑在获取锁之前,尽量减少或避免在锁内执行耗时操作。另外,使用超时机制(lock1.acquire(timeout=1)
)可以防止线程在获取锁时永久等待。
1.5 生产者-消费者模式
1.5.1 生产者-消费者模式简介
生产者-消费者模式(Producer-Consumer Pattern)是一种常见的多线程设计模式,用于解决生产者和消费者之间的协作问题。在这种模式中,有两类线程:
-
生产者(Producer): 负责生成(生产)数据或任务,并将它们放入共享的缓冲区(队列)中。生产者不断地生产数据,直到达到某个条件。如果缓冲区已满,生产者可能需要等待。
-
消费者(Consumer): 负责从共享的缓冲区中获取数据或任务,并进行处理。消费者不断地从缓冲区中获取数据,直到达到某个条件。如果缓冲区为空,消费者可能需要等待。
生产者-消费者模式的目标是实现生产者和消费者之间的有效协调,以避免资源竞争、提高效率和减少线程等待时间,下面是一个简单的示意图:
+----------------+ +----------------+ +----------------+
| 生产者 | | 缓冲区 | | 消费者 |
| |<--->| |<--->| |
| 生成数据并放入 | | 存储和协调数据 | | 从缓冲区获取 |
| 缓冲区中 | | 交换的地方 | | 数据并处理 |
+----------------+ +----------------+ +----------------+
下面是一个简单的示例:
import threading
import random
import time
g_money = 0
lock = threading.Lock() # 创建锁对象
# 生产者线程类
class Producer(threading.Thread):
def run(self):
global g_money
for _ in range(10):
with lock: # 获取锁,进入临界区
money = random.randint(1, 1000)
g_money += money
print(threading.current_thread().name, '挣了{}钱,当前余额为:{}'.format(money, g_money))
time.sleep(0.1)
# 消费者线程类
class Customer(threading.Thread):
def run(self):
global g_money
for _ in range(10):
with lock: # 获取锁,进入临界区
money = random.randint(1000, 10000)
if money <= g_money:
g_money -= money
print(threading.current_thread().name, '花了{}钱,当前余额为:{}'.format(money, g_money))
else:
print(threading.current_thread().name, '想花{}钱,但是余额不足,当前余额为:{}'.format(money, g_money))
time.sleep(0.1)
# 启动函数,创建生产者和消费者线程并启动
def start():
for i in range(5):
th = Producer(name='生产者{}'.format(i))
th.start()
for i in range(5):
cust = Customer(name='--------消费者{}'.format(i))
cust.start()
if __name__ == '__main__':
start()
这个代码示例模拟了生产者和消费者在对一个共享资源(g_money
)进行读写操作时的情况。通过线程锁 lock 来确保每次只有一个线程可以对余额进行操作,避免了资源竞争和不一致的问题。每个线程都会进行多次操作,包括挣钱、花钱以及打印当前余额等。
1.5.2 Condition
类协调线程
我们执行刚刚模拟的生产者和消费者代码,会发现经常有余额不足时消费者想消费的情况,甚至是余额已经不足,但全部生产者却生产完成的情况。此时可以使用条件变量(Condition)来协调生产者和消费者线程之间的交互。
条件变量允许线程等待某个条件满足,以及在满足条件时通知其他线程。在 Python 的 threading
模块中,Condition
类提供了这种条件变量的机制。
Condition
对象本身也是一个锁对象,也可以使用acquire(self)
和 release(self)
方法来获取和释放条件变量的锁,所以此时不需要再额外使用lock对象。Condition
类的主要方法和概念包括:
方法 | 描述 |
---|---|
__init__(self, lock=None) | 构造函数,创建一个条件变量对象。可选参数为锁对象lock ,用于在内部管理等待和通知操作的同步,否则会创建一个新的锁对象。 |
acquire(self) | 获取条件变量的锁。 |
release(self) | 释放条件变量的锁。 |
wait(self, timeout=None) | 释放锁,并进入等待状态,直到其他线程调用 notify() 或 notify_all() 来唤醒。唤醒后继续等待上锁可选参数 timeout ,如果超过指定时间条件仍未满足,线程会重新获得锁并继续执行 |
notify(self, n=1) | 通知等待队列的中的一个线程条件已满足,并将其唤醒(默认第一个)。 |
notify_all(self) | 通知所有等待队列的中的线程条件已满足,并全部唤醒(唤醒必须在释放锁之前)。 |
使用 Condition
类的一般模式如下:
- 获取条件变量的锁。
- 检查某个条件是否满足,如果条件未满足,调用
wait()
方法等待条件满足。 - 条件满足时,执行相关操作。
- 释放条件变量的锁。
下面是改进的代码:
import threading
import random
import time
g_money = 0
lock = threading.Condition() # 创建条件变量对象
g_time = 0
# 生产者线程类
class Producer(threading.Thread):
def run(self):
global g_money
global g_time
for _ in range(10):
lock.acquire() # 获取条件锁
money = random.randint(1, 1000)
g_money += money
g_time += 1
print(threading.current_thread().name, '挣了{}钱,当前余额为:{}'.format(money, g_money))
time.sleep(0.1)
lock.notify_all() # 通知等待的消费者
lock.release() # 释放锁
# 消费者线程类
class Customer(threading.Thread):
def run(self):
global g_money
for _ in range(10):
lock.acquire() # 获取锁
money = random.randint(1000, 10000)
while g_money < money: # 余额不足时一直等待
if g_time >= 50: # 当已经进行了50次生产时,结束消费者线程
lock.release()
return
print(threading.current_thread().name, '想花{}钱,但是余额不足,余额为:{}'.format(money, g_money))
lock.wait()
g_money -= money # 开始消费
print(threading.current_thread().name, '------------花了{}钱,当前余额为:{}'.format(money, g_money))
lock.release() # 释放锁
# 启动函数,创建生产者和消费者线程并启动
def start():
for i in range(5):
th = Producer(name='生产者{0}'.format(i))
th.start()
for i in range(5):
cust = Customer(name='--------消费者{}'.format(i))
cust.start()
if __name__ == '__main__':
start()
- 增加全局变量
g_time
表示生产次数。如果g_time
达到 50 次生产,表示所有生产者都已经生产完毕,此时如果还是余额不足,则消费者线程将全部结束。 - 消费者线程需要购买商品,它在循环中检查当前余额是否足够,如果不够则一直保持等待。
- 当生产者线程挣钱后,会通过
lock.notify_all()
通知等待的消费者线程。 - 这个过程使用条件变量和锁确保了生产者和消费者之间的同步,避免了竞争条件和死锁问题。
1.6 线程中的安全队列
python内置的queue
模块实现了队列格式,包括Queue
(先进先出)、LifoQueue
(后进先出、PriorityQueue
(优先级队列)。这些队列类型都实现了线程安全的数据结构,允许多个线程同时操作队列而不会引发竞争条件等问题。使用这些队列类型,可以更方便地实现生产者-消费者模型、任务调度等多线程应用。下面是更详细的解释:
-
放入数据(Put):当生产者线程调用
put
方法将数据放入队列时,队列会自动获得互斥锁,确保其他线程不能同时访问队列。一旦数据放入队列后,队列会释放互斥锁,然后使用条件变量通知正在等待数据的消费者线程。如果队列已满,生产者线程会被阻塞,直到队列有足够的空间。 -
获取数据(Get):当消费者线程调用
get
方法获取数据时,队列会自动获得互斥锁,确保其他线程不能同时访问队列。如果队列为空,消费者线程会被阻塞,直到队列有数据可供消费。一旦数据被获取,队列会释放互斥锁,然后使用条件变量通知正在等待数据空间的生产者线程。 -
等待和通知(Wait and Notify):条件变量在等待和通知的过程中起到了重要作用。消费者线程调用
get
方法时,如果队列为空,它会进入等待状态,同时释放互斥锁。当生产者线程放入新数据时,它会获取互斥锁,并通过条件变量通知等待的消费者线程。类似地,生产者线程在队列已满时也会进入等待状态,等待消费者线程释放空间。
总之,线程队列通过内部的互斥锁和条件变量,保证了多线程环境下的线程安全操作。这种机制有效地避免了竞争条件、死锁等多线程编程常见的问题,同时提供了方便的数据共享和线程间通信。
互斥锁(
Mutex
):队列内部使用互斥锁来保护对队列数据的访问。互斥锁是一种同步机制,它确保在任何时刻只有一个线程能够访问被保护的数据。当一个线程需要操作队列中的数据时,它会尝试获得互斥锁。如果锁已经被其他线程持有,那么它会阻塞等待,直到锁被释放。
条件变量(Condition
):队列内部使用条件变量来实现线程间的等待和通知机制。条件变量允许一个或多个线程等待特定的条件被满足,当条件满足时,条件变量会通知等待的线程继续执行。在线程队列中,条件变量通常用于告知消费者队列中有新数据可用,或者告知生产者队列不满。
队列的主要方法:
方法 | 描述 |
---|---|
q = Queue(maxsize) q = LifoQueue(maxsize) q = PriorityQueue(maxsize) | 创建一个新的队列对象。maxsize 可选,用于设置队列的最大容量。 |
q.put(item, block=True, timeout=None) | 将 item 放入队列。默认 block 为 True表示队列满时阻塞等待,否则不阻塞。可选参数 timeout 用于设置阻塞等待的时间。 |
q.get(block=True, timeout=None) | 从队列中获取一个元素,参数含义同get |
q.put_nowait(item) q.get_nowait() | 与 put 和 get 方法类似,但是不阻塞,如果队列已满或为空,会抛出异常。 |
q.qsize() | 返回当前队列中的元素数量。 |
q.empty() | 判断队列是否为空 |
q.full() | 判断队列是否已满 |
q.task_done() | 标记一个任务已完成。在消费者获取一个元素后,应该调用 task_done() 来通知队列这个任务已完成。 |
q.join() | 阻塞等待直到队列中所有的任务都被处理。 |
使用线程队列时,要避免线程阻塞,程序无法正常退出的情况
from queue import Queue
q = Queue(5) # 创建一个容量为5的队列
# 向队列中存放数据
for i in range(4):
q.put(i)
for _ in range(5):
try:
print(q.get(block=False)) # 尝试从队列中获取数据,不阻塞
except :
print('队列为空,程序结束')
break
在上面的例子中,我们设置了设置q.get( block=False)
表示队列为空时不被阻塞。否则,get操作将一直阻塞,直到队列中有数据可供获取,此时程序无法正常退出。你可以使用q.get_nowait()
达到同样的效果。
下面是使用线程队列的一个简单示例:
from queue import Queue
import random
import time
import threading
# 生产者线程函数,向队列中添加随机整数
def add_value(q):
while True:
q.put(random.randint(100, 1000)) # 将随机整数放入队列
time.sleep(1) # 线程休眠1秒
# 消费者线程函数,从队列中取出元素并打印
def get_value(q):
while True:
value = q.get() # 从队列中获取元素
print('取出了元素: {0}'.format(value))
# 启动函数,创建队列和线程,并启动线程
def start():
q = Queue(10) # 创建队列,最大容量为10
t1 = threading.Thread(target=add_value, args=(q,))
t2 = threading.Thread(target=get_value, args=(q,))
t1.start() # 启动生产者线程
t2.start() # 启动消费者线程
if __name__ == '__main__':
start() # 调用启动函数,开始执行生产者和消费者线程
args=(q,)
表示将队列对象q
放入元组中,然后将这个元组作为参数传递给线程函数(arg
接受元组对象)。这样,在add_value
和get_value
函数内部,可以通过函数参数来访问这个队列对象。
1.6 多线程爬取王者荣耀壁纸
王者荣耀官网高清壁纸的网址是https://pvp.qq.com/web201605/wallpaper.shtml,每张壁纸都有7种尺寸。下面我们用爬虫代码,下载所有壁纸,每张壁纸包含所有尺寸。
1.6.1 网页分析
下面先判断这些壁纸图片是网页上的静态资源还是Ajax请求(有关内容详见本文2.1节),有两种方式。我们先启动开发者模式(F12)后刷新页面
- 通过地址栏判断:壁纸一共34页,跳转到下一页,发现地址栏URL没变,说 应该是
Ajax
请求。点击Fetch/XHR,发现确实有Ajax请求(点击Preview还看不到图片)
- 通过源代码判断。
- 我们打开element标签,用左侧箭头选取一张壁纸,定位到这张壁纸在element中的位置,发现其在标签
<div class="p_newhero_item">
下,在下级标签ul中,还可以看到其余尺寸的信息。 - Ctrl+U打开网页源码,Ctrl+C复制刚才的标签信息进行查找,发现源码中确实有
<div class="p_newhero_item">
标签,但是相关信息被注释掉了,这也说明这些壁纸是Ajax请求。
- 我们打开element标签,用左侧箭头选取一张壁纸,定位到这张壁纸在element中的位置,发现其在标签
这两种方式都表示,王者荣耀壁纸是Ajax请求。我们在ALL中选择worklist元素,在preview中展开可以看到一页中20张图片的信息,这里才是真实的数据源。
我们将这个数据源的Headers中的URL(其中page=0字段表示是第一页),复制粘贴到浏览器地址栏中,就可以看到其响应的数据:
再将这些数据全部复制粘贴在json.cn网页中,可以看到右侧显示栏报错,说明这还不是json格式,因为在json字典格式之外,最外侧还多了jQuery11130793949928178278_1692852974592()
。我们将{}
之外的这部分内容去掉,就可以看到json格式内容了。其中,每个object就是一张图片,sProdImg是每个尺寸的图片链接地址。
我们选择其中一个图片地址,粘贴在地址栏打开,发现打不开。这是因为URL被编码了,所以我们需要对其进行解码操作。
# 选择一张sProdImgNo_8.jpg,解析URL
from urllib import parse
result=parse.unquote('https%3A%2F%2Fshp.qpic.cn%2Fishow%2F2735081516%2F1692089105_829394697_8720_sProdImgNo_8.jpg%2F200')
#"http://shp.qpic.cn/ishow/2735032519/1585137454_84828260_27866_sProdImgNo_8.jpg/0"
print(result)
https://shp.qpic.cn/ishow/2735081516/1692089105_829394697_8720_sProdImgNo_8.jpg/200
我们打开解析的网址,发现图片非常小。我们在element中点选这张图片的最大尺寸,可以看到其地址信息为https://shp.qpic.cn/ishow/2735081516/1692089072_829394697_3690_sProdImgNo_1.jpg/0
,与我们刚刚解析的地址区别,就是最后一个数字为0。我们将刚刚的解析地址最后一个数字改为0,就可以看到大尺寸的壁纸了。
所以,我们先要找到壁纸的数据源,然后解析URL,最后将URL末尾的数字200替换为0。
1.6.2 爬取第一页的壁纸
- 获取URL和请求头
URL就是刚刚第一页worklist元素,Headers中的Request URL,下拉还可以看到User-Agent信息。我们需要设置headers来应对反爬。建议在headers中还写一个Referer信息,表示是从哪个网址跳转过去的。
import requests
# 定义headers,模拟浏览器请求
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.100 Safari/537.36',
'referer': 'https://pvp.qq.com/web201605/wallpaper.shtml'
}
url='https://apps.game.qq.com/cgi-bin/ams/module/ishow/V1.0/query/workList_inc.cgi?activityId=2735&sVerifyCode=ABCD&sDataType=JSON&iListNum=20&totalpage=0&page=0&iOrder=0&iSortNumClose=1&jsoncallback=jQuery111304982467749514099_1692856287807&iAMSActivityId=51991&_everyRead=true&iTypeId=2&iFlowId=267733&iActId=2735&iModuleId=2735&_=1692856287809'
resp=requests.get(url,headers=headers)
print(resp.text)
我们运行此代码,可以看到返回的还不是json格式,同刚才讲的一样我们需要去除{}
之外的内容。我们可以使用replace
函数进行替换,然后用eval函数处理,就得到json格式数据。
此时也可以将URL中
&jsoncallback=jQuery111304982467749514099_1692856287807
字段删除,返回的结果就是字典格式,然后可以用.json()
方法将其转为json格式。
- 解析URL
接下来我们对json格式网页内容进行解析。在开发者模式中,所有壁纸信息都在List标签下,一共包含20个Object,每个Object的sProdImgNo_x
标签中就是我们需要的壁纸URL。
我们可以写一个exact_url
函数来提取这些壁纸URL(sProdImgNo_1到8),并对这些URL进行解析,然后将末尾的200替换为0。
- 获取壁纸名
最后,我们需要将每套壁纸都存在对应壁纸名的文件夹中。其中,壁纸名就是sProdName标签中的文本,只不过还要经过解析。比如下图的字符串,解析后就是“鹤归松栖-赵怀真”。
此时我们可以打印最终得到的壁纸名和对应的URL,看看结果是否显示正确。
import requests
from urllib import parse
from urllib import request
import os
headers={
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.100 Safari/537.36',
'referer': 'https://pvp.qq.com/web201605/wallpaper.shtml'
}
def send_request():
url='https://apps.game.qq.com/cgi-bin/ams/module/ishow/V1.0/query/workList_inc.cgi?activityId=2735&sVerifyCode=ABCD&sDataType=JSON&iListNum=20&totalpage=0&page=0&iOrder=0&iSortNumClose=1&jsoncallback=jQuery111306942951976771379_1692875716815&iAMSActivityId=51991&_everyRead=true&iTypeId=2&iFlowId=267733&iActId=2735&iModuleId=2735&_=1692875716817'
resp=requests.get(url,headers=headers).text
start_index,end_index = resp.find("(") + 1 ,resp.rfind(")")
resp=resp[start_index:end_index]
return eval(resp)
# 提取每个Object中的sProdImgNo_{}标签指向的URL信息
def exact_url(data): # data就是json数据中的20个Object信息
image_url_lst=[]
for i in range(1,9): # 提取8个sProdImgNo_标签下的URL信息并解码替换
image_url=parse.unquote(data['sProdImgNo_{}'.format(i)]).replace('200','0')
image_url_lst.append(image_url)
return image_url_lst
def parse_json(json_data):
d={} # 字典格式存储壁纸名称和对应的8个URL
data_lst=json_data['List']
for data in data_lst:
image_url_lst=exact_url(data) # 获取8个URL
sProdName=parse.unquote(data['sProdName']) # 获取壁纸名称并解析为中文
d[sProdName]=image_url_lst
for item in d:
print(item,d[item])
#save_jpg(d)
def start():
json_data=send_request()
parse_json(json_data)
if __name__ == '__main__':
start()
鹤归松栖-赵怀真 ['https://shp.qpic.cn/ishow/2735082210/1692672112_829394697_11169_sProdImgNo_1.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672112_829394697_11169_sProdImgNo_2.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672112_829394697_11169_sProdImgNo_3.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672112_829394697_11169_sProdImgNo_4.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672113_829394697_11169_sProdImgNo_5.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672113_829394697_11169_sProdImgNo_6.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672113_829394697_11169_sProdImgNo_7.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672114_829394697_11169_sProdImgNo_8.jpg/0']
鹤归松栖-云缨 ['https://shp.qpic.cn/ishow/2735082210/1692672073_829394697_8584_sProdImgNo_1.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672073_829394697_8584_sProdImgNo_2.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672073_829394697_8584_sProdImgNo_3.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672074_829394697_8584_sProdImgNo_4.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672074_829394697_8584_sProdImgNo_5.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672074_829394697_8584_sProdImgNo_6.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672075_829394697_8584_sProdImgNo_7.jpg/0', 'https://shp.qpic.cn/ishow/2735082210/1692672075_829394697_8584_sProdImgNo_8.jpg/0']
...
下面编写一个save_jpg函数,用于从壁纸的URL链接来下载图片。我们可以用urllib.request.urlretrieve(url,path)
来完成此操作。
import os
folder_name='image'
if not os.path.exists(folder_name):
os.mkdir(folder_name) # 在当前路径下创建image文件夹,用于保存爬取的图片
print(f"'{folder_name}'文件夹已创建")
def save_jpg(d): # d就是刚刚的{壁纸名:URL}字典,字典中key就是地址名
for key in d:
# 以壁纸名来命名存储的文件夹名,strip(' ')用于去除壁纸名中可能出现的空格
dir_path=os.path.join('image',key.strip(' '))
if not os.path.exists(dir_path):
os.mkdir(dir_path)
#下载图片并保存
for index, image_url in enumerate(d[key]):
img_path=os.path.join(dir_path,'{}.jpg').format(index+1)
if not os.path.exists(img_path):
request.urlretrieve(image_url,img_path)
print('{}下载完毕'.format(d[key][index]))
1.6.3 使用生产者-消费者模式进行多线程下载
上一节的代码可以正常运行,但是单线程下载速度太慢了,特别是有34页壁纸,每一页20张,每张8个尺寸,一共就是5440张。
我们可以使用上一节讲的生产者-消费者安全队列进行多线程下载。其中,生产者队列存储的是每一页的壁纸URL,消费者队列负责从队列中取出壁纸URL,然后进行下载存储。
from queue import Queue
page_queue=Queue(34) # page_queue用于存储每一页的URL,容量34
image_url_queue=Queue(200) # 用于存储网页中每张壁纸的URL,容量大于160就行。
for i in range(0,34):
page_url=f'https://apps.game.qq.com/cgi-bin/ams/module/ishow/V1.0/query/workList_inc.cgi?activityId=2735&sVerifyCode=ABCD&sDataType=JSON&iListNum=20&totalpage=0&page={i}&iOrder=0&iSortNumClose=1&iAMSActivityId=51991&_everyRead=true&iTypeId=2&iFlowId=267733&iActId=2735&iModuleId=2735&_=1595215093279'
page_queue.put(page_url)
下面我们需要创建生产者线程。因为生产者需要从page_queue
中取出page_url
,然后将解析到的image_url
放入image_url_queue
中,所以生产者线程有page_queue,image_url_queue
两个参数,这两个参数需要一开始就初始化。完整代码如下:(在URL中去除了&jsoncallback=jQuery111306942951976771379_1692875716815
字段,这样就不需要额外处理URL)
import os
import requests
import threading
from urllib import parse
from queue import Queue
from urllib import request
headers={
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.100 Safari/537.36',
'referer': 'https://pvp.qq.com/web201605/wallpaper.shtml'
}
# 提取每个Object中的sProdImgNo_{}标签指向的URL信息
def exact_url(data): # data就是json数据中的20个Object信息
image_url_lst=[]
for i in range(1,9): # 提取8个sProdImgNo_标签下的URL信息并解码替换
image_url=parse.unquote(data['sProdImgNo_{}'.format(i)]).replace('200','0')
image_url_lst.append(image_url)
return image_url_lst
#生产者线程,存储壁纸的名称和URL
class Producer(threading.Thread):
def __init__(self,page_queue,image_url_queue):
super().__init__()
self.page_queue=page_queue # 存储页面URL
self.image_url_queue=image_url_queue # 存储壁纸URL
def run(self):
while not self.page_queue.empty(): # 如果页面URL队列不为空,就获取壁纸URL
page_url=self.page_queue.get()
resp=requests.get(page_url,headers=headers)
json_data=resp.json()
d = {} # key和value分别是壁纸名和其URL
data_lst = json_data['List'] # 20个Object(壁纸)
for data in data_lst:
image_url_lst = exact_url(data) # 每张壁纸的8个URL
sProdName = parse.unquote(data['sProdName']) # 壁纸名称
d[sProdName] = image_url_lst
for key in d:
# 拼接路径,注意,路径不能有特殊符号
# 所以如果爬取到的壁纸名称有特殊符号,则需要处理。否则报错系统找不到指定的路径
dir_path = os.path.join('image', key.strip(' ').replace('·','').replace('1:1',''))
if not os.path.exists(dir_path):
os.mkdir(dir_path) # 创建每张壁纸的存储文件夹
for index, image_url in enumerate(d[key]):
#生产图片的名称和url放入队列
image_path=os.path.join(dir_path,f'{index+1}.jpg')
self.image_url_queue.put({'image_path':image_path,'image_url':image_url})
#消费者线程获取壁纸名称和URL,并进行本地下载
class Customer(threading.Thread):
def __init__(self,image_url_queue):
super().__init__()
self.image_url_queue=image_url_queue
def run(self):
while True:
try:
image=self.image_url_queue.get(timeout=20)
request.urlretrieve(image['image_url'],image['image_path'])
print(f'{image["image_path"]}下载完成')
except:
break
#定义一个启动线程的函数
def start():
page_queue=Queue(34) # page_queue用于存储每一页的URL,容量34
image_url_queue=Queue(200) # 用于存储网页中每张壁纸的URL
for i in range(0,34):
page_url=f'https://apps.game.qq.com/cgi-bin/ams/module/ishow/V1.0/query/workList_inc.cgi?activityId=2735&sVerifyCode=ABCD&sDataType=JSON&iListNum=20&totalpage=0&page={i}&iOrder=0&iSortNumClose=1&iAMSActivityId=51991&_everyRead=true&iTypeId=2&iFlowId=267733&iActId=2735&iModuleId=2735&_=1595215093279'
page_queue.put(page_url)
#创建生产者线程对象
for i in range(5):
t=Producer(page_queue,image_url_queue)
t.start()
#创建消费者线程对象
for i in range(10):
t=Customer(image_url_queue)
t.start()
if __name__ == '__main__':
start()
二、动态网页爬取(待续)
2.1 动态网页基础知识
2.1.1 动态网页和静态网页
动态网页和静态网页是两种不同类型的网页,它们在生成和呈现内容的方式上有所不同。
-
内容生成方式
- 静态网页的内容是在服务器上提前创建好的,是固定不变的,无论用户如何访问,都呈现相同的内容。
- 动态网页的内容是根据用户的请求或操作实时生成的,内容可以根据用户的请求、操作或其他因素而改变。
-
加载速度
- 静态网页通常是由 HTML、CSS 和少量 JavaScript 组成,不需要服务器端的处理,因此加载速度较快。
- 动态网页需要服务器在用户请求时动态生成内容,所以加载速度较慢。
-
互动性
- 动态网页具有更高的互动性,可以根据用户的输入、操作或其他条件来生成不同的内容,实现个性化的用户体验。
- 静态网页通常没有太多的互动性,用户只能浏览提前生成的内容。
-
更新和维护
- 静态网页的更新和维护较为简单,只需要替换文件即可。
- 动态网页可能需要更多的服务器端编程和数据库管理,因此在更新和维护上可能需要更多的工作。
总之,静态网页适用于内容相对固定、不需要频繁更新和个性化互动的情况,而动态网页适用于需要实时生成内容、提供个性化互动体验的场景(社交平台、电商平台、新闻/博客、在线游戏等)。
2.1.2 Ajax
Ajax(Asynchronous JavaScript and XML)是一种用于创建交互式、动态网页应用的技术。它允许在不刷新整个页面的情况下,通过在后台与服务器进行异步通信,更新页面的部分内容,为用户提供更好的体验。
Ajax 的核心思想是利用前端的 JavaScript 异步请求技术,将数据传输和处理与用户界面的呈现分离开来,从而实现更流畅的用户体验。传统上,在网页中,用户在与服务器进行通信时需要刷新整个页面,而 Ajax 可以在后台请求和处理数据,然后仅更新页面的特定部分,而不会影响其他内容。
Ajax 可以用于以下方面:
-
数据加载: 在页面加载后,使用 Ajax 可以异步加载数据,例如从服务器获取新闻、商品信息等,而不必等待整个页面加载完成。
-
表单提交: 使用 Ajax 可以在不刷新页面的情况下,将用户输入的数据发送到服务器进行处理,然后根据服务器响应更新页面内容。
-
实时更新: Ajax 可以用于实现实时更新功能,如实时聊天、社交媒体动态更新等。
-
用户反馈: 使用 Ajax 可以实现用户反馈功能,如点赞、评论等,无需刷新整个页面。
-
搜索建议: 在用户输入时,可以使用 Ajax 获取匹配的搜索建议,实现更好的用户体验。
-
动态表格: 可以使用 Ajax 在表格中动态加载数据,例如在分页中切换页面内容。
在之前的1.6章节中,点击王者荣耀壁纸的下一页按钮,可以发现地址栏的URL没有改变,但是壁纸的已经动态的更改了。另外在百度中搜索图片,随着我们鼠标的滑动,可以看到页面不停的加载进来更多的图片,而地址栏的地址也没有变化,这里也是使用到了Ajax 技术。
下面我们打开百度,搜索美女图片。在开发者模式中,选择Fetch/XHR就可以看到Ajax请求。
右侧的URL就是数据地址,将其在地址栏打开,显示的就是json格式的数据。复制之后在json.cn中粘贴,显示如下:
2.1.3 动态网页的爬取方式
静态网页的源代码都包含了完整的页面内容,所以可以使用基本的网络请求库(如requests
)来获取网页的源代码,然后使用解析库(如Beautiful Soup
)来提取所需的数据。
动态网页的内容是在用户请求时生成的,源代码可能并不包含所有的内容。比如动态网页的源代码中看不到通过Ajax加载的数据,只能看到地址栏URL加载的html代码。
对于动态网页的爬取,有三种方法:
-
分析 AJAX 请求: 动态网页通常通过 AJAX 请求获取额外的数据,你可以分析这些请求的 URL 和参数,然后使用 Python 的网络请求库来模拟这些请求,获取数据(例如1.6节中,我们分析出了壁纸数据的真实URL,然后在地址栏打开得到对应的json数据,再进行后续的解析)。
- 优点:可以直接请求到数据,解析难度小,代码量少,性能高。
- 缺点:分析接口比较复杂,众多request中,可能不知道哪一个包含真正的数据源,特别是一些经过JS混淆的接口(需要JS功底),而且容易被发现是爬虫程序。
-
模拟浏览器行为: 使用自动化测试工具或库(如
Selenium
)模拟浏览器行为,完整加载和执行页面的 JavaScript,然后获取完整的页面内容。- 优点:浏览器能请求到的,
Selenium
也能请求到,爬虫更稳定。 - 缺点:代码量多,性能低
- 优点:浏览器能请求到的,
-
API 调用: 如果网站提供 API 接口,你可以直接调用这些接口来获取数据,而无需解析整个网页。
2.2 selenium
2.2.1 selenium简介
下面是使用selenium操作谷歌浏览器,打开bing首页进入开发者模式,选择搜索框后可以看到,此处对应的源码是input_id这个标签,id属性为sb_form_q
,所以可以使用id来进行定位。
- 自动截图保存
- 获取网页源代码
- 在搜索栏中输入python
# coding:utf-8
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
driver=webdriver.Chrome() # 初始化驱动,构造浏览器
driver.get('https://cn.bing.com/')
driver.save_screenshot('bing.jpg') #自动进行网页截图
html=driver.page_source # 获取网页源代码
print(html)
# 定位搜索框并向搜索框中输入待搜索的数据,input_tag表示搜索框
input_tag=driver.find_element(by=By.ID,value='sb_form_q')
input_tag.send_keys('python') # 向bing搜索框中输入python
time.sleep(5)
driver.quit() #退出整个浏览器
2.2.2 selenium中常用的定位方法
driver.find_element()
可用于定位符合条件的第一个元素,如何要定位符合条件的所有元素,可使用driver.find_elements()
。
上一节的代码中,我们也可以使用这些列举的方法来定位搜索框:
# 使用name属性值定位搜索框
driver.find_element(by=By.NAME,value='q').send_keys('world')
# 使用XPath语法定位搜索框
driver.find_element(by=By.XPATH,value='//input[@class="sb_form_q"]').send_keys('hello')
# 通过CSS id选择器定位元素
driver.find_element(by=By.CSS_SELECTOR ,value='#sb_form_q').send_keys('world')
# 通过CSS 类选择器定位元素
driver.find_element(by=By.CSS_SELECTOR,value='.sb_form_q').send_keys('hello')
# 通过class名称定位元素
driver.find_element(by=By.CLASS_NAME,value='sb_form_q').send_keys('python')
# 根据标签名称定位有多少个input标签
input_list=driver.find_elements(by=By.TAG_NAME,value='input')
print(len(input_list))
driver.quit()
3
2.2.3 表单操作
- 点击按钮
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
driver=webdriver.Chrome()
driver.get('https://cn.bing.com/')
input_tag=driver.find_element(by=By.ID,value='sb_form_q')
input_tag.send_keys('python')
time.sleep(5)
# 定位搜索按钮
button_tag=driver.find_element(by=By.ID,value='search_icon')
# 表单元素操作,单击搜索按钮
button_tag.click()
# 获取源代码并输出
html=driver.page_source
print(html)
# 休眠10秒后退出浏览器
time.sleep(10)
driver.quit()
- 操作下拉列表和复选框
下面是一段打开12306网页,并操作注册页面的代码
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
from selenium.webdriver.support.ui import Select
driver=webdriver.Chrome()
driver.get('https://kyfw.12306.cn/otn/regist/init')
select=Select(driver.find_element(by=By.ID,value='passengerType')) # 定位到下接列表框
select.select_by_index(2) # 通过索引选择下拉列表框(索引2学生)
time.sleep(5)
select.select_by_value('2') # 通过value选择下拉列表框
time.sleep(5)
select.select_by_visible_text('成人') # 通过可见文本选择下拉列表项
time.sleep(5)
# 定位复选框并进行单击
checkbox_tag=driver.find_element(by=By.ID,value='checkAgree')
checkbox_tag.click()
time.sleep(5)
driver.quit()