详细介绍：Python入门学习三

一 异步编程

1. 协程

协程不是计算机提供的，是人员创造的；也可以称为微线程，是一种用户态上下文切换技术。简而言之，就是通过一个县程序实现代码相互切换执行。人为控制在一个函数之间来回切换

def func1():
    print(1)
    ...
    print(2)
def func2():
    print(3)
    ...
    pirnt(4)
func1()
func2()

实现协程有以下几种方式

• greenlet,早期模块
• yield关键字
• asyncio装饰器(py3.4)
• async, await关键字(py3.5)

2.协程的实现方式

2.1 greenlet

pip/pip3 install greenlet

实现

form greenlet import greenlet
def func1():
    print(1)
    gr2.switch()  #切换到func2函数
    print(2)
    gr2.switch()  #切换到func2函数，从上一次执行位置继续向后执行
def func2():
    print(3)
    gr1.switch() #切换到func1函数，从上一次执行位置继续向后执行
    print(4)
gr1 = greenlet(func1)
gr2 = greenlet(func2)
gr1.switch()  #执行func1函数
#输出顺序 -》 1,3,2,4

2.2 yield 关键字

def func1():
    yield 1
    yield from func2()
    yield 2
def func2():
    yield 3
    yield 4
f1 = func1()
for item in f1:
    print(item)

2.3 asyncio

python3.4 之后

@asyncio.coroutine
def func1():
    print(1)
    yield from asyncio.sleep(2) #遇到IO耗时操作，自动化切换到tasks的其他任务
    print(2)
@asyncio.coroutine
def func2():
    print(3)
    yield from asyncio.sleep(2) #遇到IO耗时操作，自动化切换到tasks的其他任务
    print(4)
tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2()),
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
#打印 出来也是1324

和前端js的宏任务，微任务一样，有点放在队列的意思

2.4 async await

python 3.5 及以后版本

async def func1():
    print(1)
    await asyncio.sleep(2)  # IO耗时操作时，自动切换到其他任务
    print(2)
async def func2():
    print(3)
    await asyncio.sleep(2)  # IO耗时操作时，自动切换到其他任务
    print(4)
# 主协程：所有异步逻辑的入口（必须用 async def 定义）
async def main():
    # 1. 用 create_task() 替代 ensure_future()（3.13 推荐创建任务的方式）
    task1 = asyncio.create_task(func1())
    task2 = asyncio.create_task(func2())
    # 2. 等待所有任务完成（两种方式任选，效果一致）
    # 方式一：逐个 await（适合任务数量少的情况）
    await task1
    await task2
    # 方式二：用 gather() 批量等待（适合任务多的情况，更简洁）
    # await asyncio.gather(task1, task2)
if __name__ == "__main__":
    # 3. 用 asyncio.run() 启动主协程（3.13 唯一推荐的启动方式）
    # 自动创建/管理/关闭事件循环，无需手动操作 loop
    asyncio.run(main())

3. 协程的意义

在一个线程中，如果遇到了io等待的时间，线程不会等待，会利用空闲的时候再去干点其他的事情

案例： 下载图片

3.1 传统方式(同步)

pip/pip3 install requests

import requests
def dowload_images(url):
    print("开始下载", url)
    response = requests.get(url)
    print("下载完成")
    print(response)
    file_name = url.split("/")[-1]
    # 以2进制的方式写入文件，直接下载到当前文件夹
    with open(file_name, mode="wb") as file_object:
        file_object.write(response.content)
url_list = [
    'https://car2.autoimg.cn/cardfs/series/g31/M07/74/F8/400x300_autohomecar__ChxoHWYU1RCAPDx5AAjYvgS1ZC8852.png.png',
    'https://car3.autoimg.cn/cardfs/series/g33/M06/AD/95/400x300_autohomecar__ChxpVWkRnliACHALAC3azVUgZSs382.png.png'
]
for item in url_list:
    dowload_images(item)
# 按照写法，假设一张图片需要下载2分钟，那么2张图就是4分钟

按照协程的写法(异步)

#aiohttp -Python 异步 HTTP 请求库，专门用于在异步程序中发送 HTTP/HTTPS 请求（对应同步的 requests 库）；
# 核心用途：支持异步请求，不会因为等待一个请求的响应而阻塞其他任务（这是并发下载的关键
import aiohttp
#导入 Python 内置的异步编程核心库 —— 负责管理事件循环、创建任务、调度协程等，是所有 Python 异步
#程序的 “发动机”。
import asyncio
# 返回一个协程对象
async def fetch(session, url):
        print("发送请求", url)
        async with session.get(url, verify_ssl=False) as response:
            print("请求成功")
            content = await response.content.read()
            file_name = url.split('_')[-1]
            with open(file_name, 'wb') as f:
                print("写入开始")
                f.write(content)
                print("写入成功")
async def main():
    async  with aiohttp.ClientSession() as session:
        url_list = [
            'https://car2.autoimg.cn/cardfs/series/g31/M07/74/F8/400x300_autohomecar__ChxoHWYU1RCAPDx5AAjYvgS1ZC8852.png.png',
            'https://car3.autoimg.cn/cardfs/series/g33/M06/AD/95/400x300_autohomecar__ChxpVWkRnliACHALAC3azVUgZSs382.png.png'
        ]
        tasks = [ asyncio.create_task(fetch(session, url)) for url in url_list]
        await  asyncio.wait(tasks)
if __name__ == '__main__':
    asyncio.run(main())
#可以看到打印，请求是一起发送的

4. 异步编程

4.1 事件循环

检测并执行某些代码

4.2 快速上手

协程函数： 定义函数的时候 async def 函数名

协程对象：执行协程函数得到的对象

async def func():
    pass
result = func()

注意：创建协程函数创建协程对象，函数内部不会执行

improt asyncio
async def func():
    pirnt("开始执行了")
result = func()
#获取事件循环，执行事件循环
# loop = asyncio.get_event_loop()
# loop.run_until_complete(result )
asyncio.run( result ) #pyhon3.7 后写法

4.3 await

await + 可等待对象(协程对象，Future, Task对象 -> IO等待)

import asyncio
async def func():
    print("执行1")
    respones = await asyncio.sleep(2)
    print("结束")
asyncio.run( func() )

import asyncio
async def others():
    print("others1")
    await asyncio.sleep(2)
    print("others2")
    return "返回值"
async def func():
    print("我是func1-1")
    r = await others()
    print(r)
    r1 = await others()
    print(r1)
    print("我是func1-2")
asyncio.run(func())

4.4 Task对象

帮助在事件循环中添加多个任务

import asyncio
async def func():
    print(1)
    await asyncio.sleep(1)
    print(2)
    return "返回值"
async def main():
    print("main开始")
    #创建task对象，将当前执行函数添加到事件循环中
    # task1 = asyncio.create_task(func())
    # task2 = asyncio.create_task(func())
    # ret1 = await task1
    # ret2 = await task2
    # name,加入队列的名称
    task_list = [
        asyncio.create_task(func(), name='task1'),
        asyncio.create_task(func(), name='task2')
    ]
    #timeout 是否延迟执行, 返回两种状态，done中是执行完成后的结果列表
    done ,pendding= await asyncio.wait(task_list, timeout=None)
    print(done)
# 创建事件循环队列，并将main添加在里面
asyncio.run(main())

4.5 asyncio.Future 对象

_state 维护了一个状态

Task继承了Future,Task内部await结果的处理基于Future对象来的

import asyncio
async def main():
    # 获取到当前事件循环对象
    loop = asyncio.get_event_loop()
    # 创建一个任务(Future对象) 这个任务什么都不干
    fut = loop.create_future()
    await fut
asyncio.run(main())

import asyncio
async def func(fut):
    print(1)
    await asyncio.sleep(1)
    fut.set_result(66)
async def main():
    # 获取到当前事件循环对象
    loop = asyncio.get_event_loop()
    # 创建一个任务(Future对象) 这个任务什么都不干
    fut = loop.create_future()
    #创建一个任务（task对象），绑定了func函数在1s后，会给fut赋值
    #即手动设置了future任务的最终结果
    await loop.create_task(func(fut))
    r = await fut
    print(r)
asyncio.run(main())

4.6 concurrent的Future对象

使用线程池，进程池实现异步操作时用到的对象

4.7 异步可迭代对象

可在async for 语句中被使用的对象。

创建一个异步迭代对象，循环生成 1~99 的数字，直到生成第 100 次时停止迭代

import asyncio
class Reader(object):
    def __init__(self):
        self.count = 0
    async def readline(self):
        self.count += 1
        if self.count == 100:
            return None
        return self.count
    def __aiter__(self):
        return self
    async def __anext__(self):
        val = await self.readline()
        if val is None:
            raise StopAsyncIteration
        return val
async def func():
    obj = Reader()
    async for item in obj:
        print(item)
asyncio.run(func())

5. 详细讲解 async await

5.1. 定义协程函数：async def

要创建一个 “能异步执行的函数”，必须用 async def 开头（不能用普通 def）：

# 这是一个协程函数（注意 async def）
async def my_coroutine():
    print("协程开始执行")
    return "协程执行完成"

注意：协程函数不能直接调用！

如果像普通函数一样调用 my_coroutine()，不会执行函数内部代码，只会返回一个 “协程对象”：

result = my_coroutine()  # 不会打印任何内容
print(type(result))       # 输出：（是协程对象，不是返回值）

5.2. 运行协程：asyncio.run()

要真正执行协程函数，必须通过 asyncio.run()（Python 3.7+ 内置，最简单的启动方式）：

import asyncio  # 必须导入异步库
async def my_coroutine():
    print("协程开始执行")
    return "协程执行完成"
# 用 asyncio.run() 启动协程（这是异步程序的入口）
final_result = asyncio.run(my_coroutine())
print(final_result)  # 输出：协程执行完成

执行流程：

1. asyncio.run() 会创建一个 “事件循环”（可以理解为 “任务调度中心”，负责安排协程执行）；
2. 事件循环运行 my_coroutine 协程，执行函数内部代码；
3. 协程执行完后，asyncio.run() 会返回协程的返回值；
4. 最后关闭事件循环。

5.3. 暂停协程：await

await 是 “等待” 的意思，只能用在 协程函数内部，作用是：

• 暂停当前协程的执行，去执行其他协程或异步操作；
• 等被等待的操作完成后，再恢复当前协程的执行。

语法格式：

async def 协程A():
    # 等待 协程B 执行完成，拿到返回值后再继续
    result = await 协程B()
    print(result)

示例：用 await 等待另一个协程

import asyncio
# 定义一个需要“耗时”的协程（模拟 IO 操作，比如网络请求）
async def fake_io_operation():
    print("开始执行耗时操作（比如下载文件）")
    await asyncio.sleep(2)  # 模拟 2 秒耗时（注意：必须用 asyncio.sleep，不能用 time.sleep！）
    return "耗时操作完成"
# 主协程
async def main():
    print("主协程开始")
    # 等待 fake_io_operation 完成，拿到返回值
    result = await fake_io_operation()
    print("主协程继续执行，拿到结果：", result)
# 启动主协程
asyncio.run(main())

执行结果（会等待 2 秒）：

plaintext

主协程开始
开始执行耗时操作（比如下载文件）
# 此处暂停 2 秒（期间事件循环可以安排其他任务，但这个例子只有一个任务）
主协程继续执行，拿到结果： 耗时操作完成

关键提醒：

• await 后面必须跟 “可等待对象”（常见的是：协程对象、asyncio.Task、asyncio.Future 等）；
• 绝对不能在普通 def 函数里用 await；
• 不能用 time.sleep(2) 模拟耗时！time.sleep 是 “同步阻塞”，会让整个事件循环卡住；asyncio.sleep 是 “异步非阻塞”，会让当前协程暂停，事件循环可以去做其他事。

5.4 案例

5.4.1 为什么要用异步

“为什么要用异步？同步不是挺好吗？” 看这个对比案例就懂了！

场景：模拟 3 个耗时任务（比如下载 3 个文件，每个任务耗时 2 秒）

1. 同步版本（普通 def + time.sleep）

import time
# 同步函数：每个任务耗时 2 秒
def sync_task(name):
    print(f"同步任务 {name} 开始")
    time.sleep(2)  # 同步阻塞，整个程序都要等
    print(f"同步任务 {name} 结束")
# 同步执行3个任务
def sync_main():
    start_time = time.time()
    sync_task("A")
    sync_task("B")
    sync_task("C")
    end_time = time.time()
    print(f"同步总耗时：{end_time - start_time:.2f} 秒")
sync_main()

执行结果（总耗时～6 秒）：

同步任务 A 开始
同步任务 A 结束
同步任务 B 开始
同步任务 B 结束
同步任务 C 开始
同步任务 C 结束
同步总耗时：6.01 秒

→ 问题：任务 A、B、C 按顺序执行，每个都要等前一个完成，总耗时是 2+2+2=6 秒。

2. 异步版本（async def + await + asyncio.sleep）

import asyncio
import time
# 异步任务：每个任务“耗时”2秒（非阻塞）
async def async_task(name):
    print(f"异步任务 {name} 开始")
    await asyncio.sleep(2)  # 异步暂停，事件循环可以去执行其他任务
    print(f"异步任务 {name} 结束")
# 异步执行3个任务
async def async_main():
    start_time = time.time()
    # 同时启动3个异步任务（关键：不是顺序执行，是并发执行）
    await asyncio.gather(
        async_task("A"),
        async_task("B"),
        async_task("C")
    )
    end_time = time.time()
    print(f"异步总耗时：{end_time - start_time:.2f} 秒")
# 启动异步主协程
asyncio.run(async_main())

执行结果（总耗时～2 秒）：

异步任务 A 开始
异步任务 B 开始
异步任务 C 开始
异步任务 A 结束
异步任务 B 结束
异步任务 C 结束
异步总耗时：2.01 秒

→ 奇迹：3 个任务 “同时执行”，总耗时只有 2 秒！

关键解释：

• asyncio.gather(task1, task2, task3)：让多个协程 “并发执行”（同时启动，不用等前一个开始）；
• 当 async_task(A) 执行到 await asyncio.sleep(2) 时，会暂停自己，事件循环立刻去执行 async_task(B)；
• async_task(B) 暂停后，再去执行 async_task(C)；
• 2 秒后，3 个任务的 sleep 都完成，各自恢复执行，打印 “结束”。

这就是异步的核心价值：在等待某个耗时操作时，不闲着，去处理其他任务，大幅节省总时间。

5.4.2 异步获取网页

实际开发中，async/await 常用在 “网络请求”“数据库操作” 等耗时 IO 场景。下面用 aiohttp（异步 HTTP 库）模拟批量获取网页内容：

步骤 1：安装依赖

pip install aiohttp  # 异步 HTTP 库，支持 await

步骤 2：异步批量请求网页

import asyncio
import aiohttp  # 异步 HTTP 客户端
# 要请求的网页地址列表
URLS = [
    "https://www.baidu.com",
    "https://www.taobao.com",
    "https://www.jd.com",
    "https://www.zhihu.com"
]
# 异步请求单个网页
async def fetch_url(session, url):
    async with session.get(url) as response:  # 异步发送 GET 请求
        return f"{url}：状态码 {response.status}"  # 返回响应状态码
# 主协程：批量请求所有网页
async def main():
    # 创建一个异步 HTTP 会话（类似 requests.Session，但支持异步）
    async with aiohttp.ClientSession() as session:
        # 创建所有要执行的异步任务
        tasks = [fetch_url(session, url) for url in URLS]
        # 并发执行所有任务，等待全部完成后返回结果列表
        results = await asyncio.gather(*tasks)  # * 是解包列表
    # 打印所有结果
    for result in results:
        print(result)
# 启动程序
asyncio.run(main())

执行效果：

4 个网页请求 “同时进行”，总耗时≈单个网页的请求时间（比如 1~2 秒）；如果用同步的 requests 库，总耗时≈4 个网页请求时间之和（比如 4~8 秒）。

常见误区

1. 误区 1：用 time.sleep 模拟异步耗时→ 错！time.sleep 是同步阻塞，会让整个事件循环卡住，异步变同步。→ 正确：用 asyncio.sleep()。

2. 误区 2：在普通 def 函数里用 await→ 错！await 只能在 async def 定义的协程函数内部使用。→ 正确：如果需要用 await，必须把函数改成 async def。

3. 误区 3：直接调用协程函数就能执行→ 错！async def 函数调用后返回协程对象，不会执行内部代码。→ 正确：用 asyncio.run() 或事件循环（loop.run_until_complete()）启动。

4. 误区 4：异步一定比同步快→ 错！只有在 “有耗时 IO 操作”（网络、文件、数据库）时，异步才快；如果是 CPU 密集型任务（比如计算），异步反而可能更慢（因为事件循环有调度开销）。

总结（核心知识点浓缩）

1. async def：定义协程函数，返回协程对象（不能直接执行）；
2. asyncio.run(coro)：启动协程的入口，自动管理事件循环；
3. await：暂停当前协程，等待其他异步操作完成后恢复，只能用在协程函数内；
4. 核心价值：IO 密集型场景下，通过 “并发执行” 减少等待时间，提高程序效率；
5. 常用工具：asyncio.gather()（并发执行多个协程）、aiohttp（异步网络请求）、asyncpg（异步操作 PostgreSQL）等。

二  python三大http请求库

1. requests

1. 基本介绍

requests的官方文档：https://requests.readthedocs.io/en/latest/user/quickstart/#make-a-request

w3c 学习文档：https://www.w3cschool.cn/requests2/requests2-fu433fja.html

Requests 是 Python 最流行的 HTTP 请求库，功能强大且用法简洁，能轻松实现网页爬取、接口调用、数据提交等需求。本教程从环境搭建到实战案例，循序渐进带你掌握核心用法，学完即可上手开发。

2. 安装

pip|pip3 install requests

3. 核心基础：Requests 核心方法与语法

Requests 最常用的 5 个方法，对应 HTTP 协议的核心请求类型：

方法	作用	场景示例
requests.get()	发送 GET 请求（获取数据）	爬取网页、获取接口数据
requests.post()	发送 POST 请求（提交数据）	登录、表单提交、上传文件
requests.put()	发送 PUT 请求（全量更新数据）	接口更新资源（如修改用户信息）
requests.delete()	发送 DELETE 请求（删除数据）	接口删除资源（如删除订单）
requests.session()	创建会话（保持登录状态）	需登录后才能访问的页面 / 接口

3.1 GET 请求（获取数据）

3.1.1 简单请求

import requests  # 导入 requests 库
# 1. 发送 GET 请求到目标 URL
response = requests.get("https://www.baidu.com")  # response 是响应对象，包含服务器返回的所有信息
# 2. 查看响应结果
print("响应状态码：", response.status_code)  # 状态码：200 表示成功，4xx 客户端错误，5xx 服务器错误
print("响应内容（前100字符）：", response.text[:100])  # response.text：以字符串形式返回响应内容（网页源码）

3.1.2 核心响应对象属性

属性 / 方法	说明	示例输出
response.status_code	响应状态码（判断请求是否成功）	200（成功）、404（未找到）
response.text	以字符串返回响应内容（自动解码）	网页 HTML 源码、接口 JSON 字符串
response.content	以字节流返回响应内容（二进制数据）	图片、文件、未解码的文本
response.json()	自动解析 JSON 格式的响应内容（返回字典）	{"name": "张三", "age": 20}
response.headers	响应头（服务器返回的 metadata）	{'Content-Type': 'text/html'}
response.url	实际请求的 URL（处理重定向后）	https://www.baidu.com/

3.1.3 GET 请求带参数

很多时候需要在 URL 后拼接参数（如 https://search.baidu.com/s?wd=python 中 wd=python 是搜索参数），用 params 参数传递更简洁（无需手动拼接 URL）：

import requests
# 定义要传递的参数（字典格式）
params = {
    "wd": "Python Requests 教程",  # 搜索关键词
    "pn": 0  # 分页参数（第 0 页，即第一页）
}
# 发送带参数的 GET 请求（params 参数自动拼接 URL）
response = requests.get(
    url="https://search.baidu.com/s",  # 基础 URL（不含参数）
    params=params  # 传递参数
)
print("实际请求的 URL：", response.url)  # 输出拼接后的完整 URL
print("响应状态码：", response.status_code)

3.2 POST 请求

POST 请求用于向服务器提交数据（如登录、注册、提交表单），数据放在请求体中（而非 URL 上），更安全。

3.2.1 提交表单数据（data 参数）

适用于 Content-Type: application/x-www-form-urlencoded 格式（最常见的表单提交格式）：

import requests
# 1. 定义要提交的表单数据（字典格式）
form_data = {
    "username": "test_user",
    "password": "123456"
}
# 2. 发送 POST 请求（data 参数传递表单数据）
response = requests.post(
    url="https://example.com/login",  # 目标接口 URL（示例，需替换为实际接口）
    data=form_data  # 提交表单数据
)
# 3. 解析响应（假设接口返回 JSON 格式）
if response.status_code == 200:
    result = response.json()  # 自动解析 JSON
    print("登录结果：", result)
else:
    print("请求失败，状态码：", response.status_code)

3.2.2 提交 JSON 数据（json 参数）

适用于 Content-Type: application/json 格式（现代接口常用，如 RESTful API）：

import requests
# 1. 定义 JSON 数据（字典格式，requests 会自动序列化为 JSON 字符串）
json_data = {
    "name": "张三",
    "age": 25,
    "hobbies": ["编程", "阅读"]
}
# 2. 发送 POST 请求（json 参数传递 JSON 数据）
response = requests.post(
    url="https://example.com/api/user",
    json=json_data  # 自动设置 Content-Type: application/json
)
# 3. 处理响应
print("响应结果：", response.json())

3.3 配置：请求头、超时、代理

3.3.1 设置请求头（headers）

模拟浏览器请求（避免被服务器识别为爬虫），最常用的是 User-Agent（标识客户端类型）：

import requests
# 定义请求头（模拟 Chrome 浏览器）
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
}
# 发送带请求头的 GET 请求
response = requests.get(
    url="https://www.baidu.com",
    headers=headers
)
print("响应状态码：", response.status_code)

3.3.2 设置超时（timeout）

避免请求因网络问题一直阻塞，timeout 表示最大等待时间（单位：秒）：

import requests
try:
    response = requests.get(
        url="https://www.baidu.com",
        timeout=5  # 5 秒内未响应则抛出超时异常
    )
except requests.exceptions.Timeout:
    print("请求超时，请检查网络！")

3.3.3 处理 SSL 证书验证（verify）

访问 HTTPS 网站时，requests 会自动验证 SSL 证书，若证书无效（如自签名证书），可关闭验证：

import requests
# verify=False 关闭 SSL 证书验证（仅用于测试/内部网站）
response = requests.get(
    url="https://xxx.com",  # 示例：证书无效的 HTTPS 网站
    verify=False
)

3.4 会话保持（requests.Session()）

用于需要维持登录状态的场景（如登录后访问个人中心），会话会自动保存 cookies：

import requests
# 1. 创建会话对象（自动保存 cookies）
session = requests.Session()
# 2. 第一步：发送登录请求（会话会保存登录后的 cookies）
login_data = {"username": "test", "password": "123"}
session.post("https://example.com/login", data=login_data)
# 3. 第二步：访问需要登录的页面（会话携带 cookies，无需再次登录）
response = session.get("https://example.com/user/center")
print("个人中心内容：", response.text[:200])  # 成功获取登录后的内容

4. 实战案例：

4.1：爬取网页内容（百度首页标题）

场景：获取百度首页的 HTML 源码，并提取页面标题（基础爬虫入门）。

import requests
from bs4 import BeautifulSoup  # 用于解析 HTML（需安装：pip install beautifulsoup4）
def crawl_baidu_title():
    # 1. 目标 URL（百度首页）
    url = "https://www.baidu.com"
    # 2. 设置请求头（模拟浏览器，避免被反爬）
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
    }
    try:
        # 3. 发送 GET 请求（设置超时 5 秒）
        response = requests.get(
            url=url,
            headers=headers,
            timeout=5
        )
        # 4. 检查请求是否成功（200 表示成功）
        if response.status_code == 200:
            # 5. 解析 HTML 源码（用 BeautifulSoup）
            soup = BeautifulSoup(response.text, "html.parser")  # html.parser 是 Python 内置解析器
            title = soup.find("title").text  # 查找