Python中的简单爬虫

作者：q***5774日期：2025/11/21
文章目录
  • 一. 基于FastAPI之Web站点开发
    • 1. 基于FastAPI搭建Web服务器
    • 2. Web服务器和浏览器的通讯流程
    • 3. 浏览器访问Web服务器的通讯流程
    • 4. 加载图片资源代码
  • 二. 基于Web请求的FastAPI通用配置
    • 1. 目前Web服务器存在问题
    • 2. 基于Web请求的FastAPI通用配置
  • 三. Python爬虫介绍
    • 1. 什么是爬虫
    • 2. 爬虫的基本步骤
    • 3. 安装requests模块
    • 4. 爬取照片
      • ① 查看index.html
        • ② 爬取照片步骤
        • ③ 获取index.html代码
        • ④ 解析index.html代码获取图片url
        • ⑤ 通过图片url获取图片
  • 四. 使用Python爬取GDP数据
    • 1. gdp.html
    • 2. zip函数的使用
    • 3.爬取GDP数据
  • 五. 多任务爬虫实现
    • 1. 为什么用多任务
    • 2. 多任务爬取数据
    • 3. 多任务代码实现
  • 六. 数据可视化
    • 1. 什么是数据可视化
    • 2. pyecharts模块
    • 3. 通过pyecharts模块创建饼状图
    • 4. 完整代码
    • 5. 小结
  • 七. Logging日志模块
    • 1. logging日志的介绍
    • 2. logging日志级别介绍
    • 3. logging日志的使用
    • 4. logging日志在Web项目中应用
    • 5. 小结

一. 基于FastAPI之Web站点开发

1. 基于FastAPI搭建Web服务器
1# 导入FastAPI模块
2from fastapi import FastAPI
3# 导入响应报文Response模块
4from fastapi import Response
5# 导入服务器uvicorn模块
6import uvicorn
7
8# 创建FastAPI框架对象
9app = FastAPI()
10
11
12# 通过@app路由装饰器收发数据
13# @app.get(参数) : 按照get方式接受请求数据
14# 请求资源的 url 路径
15@app.get("/index.html")
16def main():
17    with open("source/html/index.html", "rb") as f:
18        data = f.read()
19    # return 返回响应数据
20    # Response(content=data, media_type="text/html"
21    # 参数1: 响应数据
22    # 参数2: 数据格式
23    return Response(content=data, media_type="text/html")
24
25
26# 运行服务器
27# 参数1: 框架对象
28# 参数2: IP地址
29# 参数3: 端口号
30uvicorn.run(app, host="127.0.0.1", port=8000)
31

2. Web服务器和浏览器的通讯流程

实际上Web服务器和浏览器的通讯流程过程并不是一次性完成的, 这里html代码中也会有访问服务器的代码, 比如请求图片资源。

那像0.jpg、1.jpg、2.jpg、3.jpg、4.jpg、5.jpg、6.jpg这些访问来自哪里呢
答：它们来自index.html

3. 浏览器访问Web服务器的通讯流程


浏览器访问Web服务器的通讯流程：

  1. 浏览器 (127.0.0.1/index.html) ==> 向Web服务器请求index.html
  2. Web服务器 (返回index.html) ==> 浏览器
  3. 浏览器解析index.html发现需要0.jpg ==>发送请求给 Web服务器请求0.jpg
  4. Web服务器 收到请求返回0.jpg ==> 浏览器 接受0.jpg

通讯过程能够成功的前提：

浏览器发送的0.jpg请求, Web服务器可以做出响应, 也就是代码如下

1# 当浏览器发出对图片 0.jpg 的请求时, 函数返回相应资源
2@app.get("/images/0.jpg")
3def func_01():
4    with open("source/images/0.jpg", "rb") as f:
5        data = f.read()
6        print(data)
7    return Response(content=data, media_type="jpg")
8
4. 加载图片资源代码
1# 导入FastAPI模块
2from fastapi import FastAPI
3# 导入响应报文Response模块
4from fastapi import Response
5# 导入服务器uvicorn模块
6import uvicorn
7
8# 创建FastAPI框架对象
9app = FastAPI()
10
11
12@app.get("/images/0.jpg")
13def func_01():
14    with open("source/images/0.jpg", "rb") as f:
15        data = f.read()
16        print(data)
17    return Response(content=data, media_type="jpg")
18
19
20@app.get("/images/1.jpg")
21def func_02():
22    with open("source/images/1.jpg", "rb") as f:
23        data = f.read()
24    return Response(content=data, media_type="jpg")
25
26
27@app.get("/images/2.jpg")
28def func_03():
29    with open("source/images/2.jpg", "rb") as f:
30        data = f.read()
31    return Response(content=data, media_type="jpg")
32
33
34@app.get("/images/3.jpg")
35def func_04():
36    with open("source/images/3.jpg", "rb") as f:
37        data = f.read()
38    return Response(content=data, media_type="jpg")
39
40
41@app.get("/images/4.jpg")
42def func_05():
43    with open("source/images/4.jpg", "rb") as f:
44        data = f.read()
45    return Response(content=data, media_type="jpg")
46
47
48@app.get("/images/5.jpg")
49def func_06():
50    with open("source/images/5.jpg", "rb") as f:
51        data = f.read()
52    return Response(content=data, media_type="jpg")
53
54
55@app.get("/images/6.jpg")
56def func_07():
57    with open("source/images/6.jpg", "rb") as f:
58        data = f.read()
59    return Response(content=data, media_type="jpg")
60
61
62@app.get("/index.html")
63def main():
64    with open("source/html/index.html", "rb") as f:
65        data = f.read()
66    # return 返回响应数据
67    # Response(content=data, media_type="text/source"
68    # 参数1: 响应数据
69    # 参数2: 数据格式
70    return Response(content=data, media_type="text/html")
71
72
73# 运行服务器
74# 参数1: 框架对象
75# 参数2: IP地址
76# 参数3: 端口号
77uvicorn.run(app, host="127.0.0.1", port=8000)
78

二. 基于Web请求的FastAPI通用配置

1. 目前Web服务器存在问题
1# 返回0.jpg
2@app.get("/images/0.jpg")
3def func_01():
4    with open("source/images/0.jpg", "rb") as f:
5        data = f.read()
6        print(data)
7    return Response(content=data, media_type="jpg")
8
9# 返回1.jpg
10@app.get("/images/1.jpg")
11def func_02():
12    with open("source/images/1.jpg", "rb") as f:
13        data = f.read()
14    return Response(content=data, media_type="jpg")
15
16# 返回2.jpg
17@app.get("/images/2.jpg")
18def func_03():
19    with open("source/images/2.jpg", "rb") as f:
20        data = f.read()
21    return Response(content=data, media_type="jpg")
22

对以上代码观察,会发现每一张图片0.jpg、1.jpg、2.jpg就需要一个函数对应, 如果我们需要1000张图片那就需要1000个函数对应, 显然这样做代码的重复太多了.

2. 基于Web请求的FastAPI通用配置
1# 当请求为 /images/0.jpg 时, path ==> 0.jpg
2@app.get("/images/{path}")
3# 注意这里的参数需要设置为 path
4# path : str ==> 指定path为字符串类型的数据
5def get_pic(path: str):
6    # 这里open()的路径就是 ==> f"source/images/0.jpg"
7    with open(f"source/images/{path}", "rb") as f:
8        data = f.read()
9    # return 返回响应数据
10    # Response(content=data, media_type="jpg")
11    # 参数1: 响应数据
12    # 参数2: 数据格式
13    return Response(content=data, media_type="jpg")
14

完整代码

1# 导入FastAPI模块
2from fastapi import FastAPI
3# 导入响应报文Response模块
4from fastapi import Response
5# 导入服务器uvicorn模块
6import uvicorn
7
8# 创建FastAPI框架对象
9app = FastAPI()
10
11
12# 当请求为 /images/0.jpg 时, path ==> 0.jpg
13@app.get("/images/{path}")
14# 注意这里的参数需要设置为 path
15# path : str ==> 指定path为字符串类型的数据
16def get_pic(path: str):
17    # 这里open()的路径就是 ==> f"source/images/0.jpg"
18    with open(f"source/images/{path}", "rb") as f:
19        data = f.read()
20    # return 返回响应数据
21    # Response(content=data, media_type="jpg")
22    # 参数1: 响应数据
23    # 参数2: 数据格式
24    return Response(content=data, media_type="jpg")
25
26
27@app.get("/{path}")
28def get_html(path: str):
29    with open(f"source/html/{path}", 'rb') as f:
30        data = f.read()
31    # return 返回响应数据
32    # Response(content=data, media_type="text/source"
33    # 参数1: 响应数据
34    # 参数2: 数据格式
35    return Response(content=data, media_type="text/html")
36
37
38# 运行服务器
39# 参数1: 框架对象
40# 参数2: IP地址
41# 参数3: 端口号
42uvicorn.run(app, host="127.0.0.1", port=8000)
43

运行结果

三. Python爬虫介绍

1. 什么是爬虫

网络爬虫:

又被称为网页蜘蛛，网络机器人，是一种按照一定的规则，自动地抓取网络信息的程序或者脚本，另外一些不常使用的名字还有蚂蚁、自动索引、模拟程序或者蠕虫。

通俗理解:

简单来讲，爬虫就是一个探测机器，它的基本操作就是模拟人的行为去各个网站溜达，点点按钮，查查数据，或者把看到的信息背回来. 就像一只虫子在一幢楼里不知疲倦地爬来爬去.

你可以简单地想象： 每个爬虫都是你的「分身」。就像孙悟空拔了一撮汗毛，吹出一堆猴子一样

**百度:**其实就是利用了这种爬虫技术, 每天放出无数爬虫到各个网站，把他们的信息抓回来，然后化好淡妆排着小队等你来检索。

有了这样的特性, 对于一些自己公司数据量不足的小公司, 这个时候还想做数据分析就可以通过爬虫获取同行业的数据然后进行分析, 进而指导公司的策略指定。

2. 爬虫的基本步骤

基本步骤：

  • 起始URL地址
  • 发出请求获取响应数据
  • 对响应数据解析
  • 数据入库
3. 安装requests模块

快速入门（requests三步走）：

1# 导入模块
2import requests
3# 通过requests.get()发送请求
4# data保存返回的响应数据(这里的响应数据不是单纯的html,需要通过content获取html代码)
5data = requests.get("http://www.baidu.com")
6# 通过data.content获取html代码
7data = data.content.decode("utf-8")
8
4. 爬取照片
① 查看index.html

② 爬取照片步骤
  1. 获取index.html代码
  2. 解析index.html代码获取图片url
  3. 通过图片url获取图片
③ 获取index.html代码
1# 通过爬虫向index.html发送请求
2# requests.get(网址): 向一个网址发送请求,和在浏览器中输入网址是一样的
3data = requests.get("http://127.0.0.1:8000/index.html")
4# content可以把requests.get()获取的返回值中的html内容获取到
5data = data.content.decode("utf-8")
6
④ 解析index.html代码获取图片url
1# 获取图片的请求url
2def get_pic_url():
3    # 通过爬虫向index.html发送请求
4    # requests.get(网址): 向一个网址发送请求,和在浏览器中输入网址是一样的
5    data = requests.get("http://127.0.0.1:8000/index.html")
6    # content可以把requests.get()获取的返回值中的html内容获取到
7    data = data.content.decode("utf-8")
8    # html每一行都有"
9", 对html进行分割获得一个列表
10    data = data.split("
11")
12    # 创建一个列表存储所有图片的url地址(也就是图片网址)
13    url_list = []
14    for url in data:
15        # 通过正则解析出所有的图片url
16        result = re.match('.*src="(.*)" width.*', url)
17        if result is not None:
18            # 把解析出来的图片url添加到url_list中
19            url_list.append(result.group(1))
20
21    return url_list
22
⑤ 通过图片url获取图片
1# 把爬取到的图片保存到本地
2def save_pic(url_list):
3    # 通过num给照片起名字 例如:0.jpg 1.jpg 2.jpg
4    num = 0
5    for url in url_list:
6        # 通过requests.get()获取每一张图片
7        pic = requests.get(f"http://127.0.0.1:8000{url[1:]}")
8        # 保存每一张图片
9        with open(f"./source/spyder/{num}.jpg", "wb") as f:
10            f.write(pic.content)
11            num += 1
12

完整代码

1# 把爬取到的图片保存到本地
2def save_pic(url_list):
3    # 通过num给照片起名字 例如:0.jpg 1.jpg 2.jpg
4    num = 0
5    for url in url_list:
6        # 通过requests.get()获取每一张图片
7        pic = requests.get(f"http://127.0.0.1:8000{url[1:]}")
8        # 保存每一张图片
9        with open(f"./source/spyder/{num}.jpg", "wb") as f:
10            f.write(pic.content)
11            num += 1
12

四. 使用Python爬取GDP数据

1. gdp.html


通过访问 http://127.0.0.1:8080/gdp.html 可以获取2020年世界GDP排名. 在这里我们通过和爬取照片一样的流程步骤获取GDP数据。

2. zip函数的使用

zip() 函数: 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表.

1a = [1, 2, 3]
2b = [4, 5, 6]
3c = [4, 5, 6, 7, 8]
4# 打包为元组的列表
5zipped = zip(a, b)
6# 注意使用的时候需要list转化
7print(list(zipped))
8>>> [(1, 4), (2, 5), (3, 6)]
9
10# 元素个数与最短的列表一致
11zipped = zip(a, c)
12# 注意使用的时候需要list转化
13print(list(zipped))
14>>> [(1, 4), (2, 5), (3, 6)]
15
3.爬取GDP数据
1import requests
2import re
3
4# 存储爬取到的国家的名字
5country_list = []
6# 存储爬取到的国家gdp的数据
7gdp_list = []
8
9
10# 获取gdp数据
11def get_gdp_data():
12    global country_list
13    global gdp_list
14
15    # 获取gdp的html数据
16    data = requests.get("http://localhost:8000/gdp.html")
17    # 对获取数据进行解码
18    data = data.content.decode("utf8")
19    # 对gdp的html数据进行按行分割
20    data_list = data.split("
21")
22
23    for i in data_list:
24        # 对html进行解析获取<国家名字>
25        country_result = re.match('.*<a href=""><font>(.*)</font></a>', i)
26        # 匹配成功就存放到列表中
27        if country_result is not None:
28            country_list.append(country_result.group(1))
29        # 对html进行解析获取<gdp数据>
30        gdp_result = re.match(".*￥(.*)亿元", i)
31        # 匹配成功就存储到列表中
32        if gdp_result is not None:
33            gdp_list.append(gdp_result.group(1))
34    # 把两个列表融合成一个列表
35    gdp_data = list(zip(country_list, gdp_list))
36    print(gdp_data)
37
38
39if __name__ == '__main__':
40    get_gdp_data()
41

五. 多任务爬虫实现

1. 为什么用多任务

在我们的案例中, 我们只是爬取了2个非常简单的页面, 这两个页面的数据爬取并不会使用太多的时间, 所以我们也没有太多的考虑效率问题.

但是在真正的工作环境中, 我们爬取的数据可能非常的多, 如果还是使用单任务实现, 这时候就会让我们爬取数据的时间很长, 那么显然使用多任务可以大大提升我们爬取数据的效率

2. 多任务爬取数据

实际上实现多任务并不难, 只需要使用多任务就可以了

3. 多任务代码实现
1# 获取gdp
2def get_gdp_data():
3    pass
4
5
6# 获取照片
7def get_pic():
8    pass
9
10
11if __name__ == '__main__':
12    p1 = multiprocessing.Process(target=get_pic
13    p2 = multiprocessing.Process(target=get_gdp_data)
14
15    p1.start()
16    p2.start()
17

六. 数据可视化

1. 什么是数据可视化


数据可视化：顾名思义就是让数据看的到, 他的作用也很明显, 让人们不用再去阅读枯燥无味的数据, 一眼看去就可以明白数据是什么, 数据间的关系是什么, 更好的让我们通过数据发现潜在的规律进而进行商业决策。

2. pyecharts模块


概况 :

Echarts 是个由百度开源的数据可视化，凭借着良好的交互性，精巧的图表设计，得到了众多开发者的认可. 而 Python 是门富有表达力的语言，很适合用于数据处理. 当数据分析遇上数据可视化时pyecharts 诞生了.

特性 :

  1. 简洁的API设计，使用如丝滑般流畅，支持链式调用
  2. 囊括了**30+**种常见图表，应有尽有
  3. 支持主流Notebook 环境，Jupyter Notebook 和JupyterLab
  4. 可轻松集成至Flask, Django等主流Web框架
  5. 高度灵活的配置项，可轻松搭配出精美的图表
  6. 详细的文档和示例，帮助开发者更快的上手项目
  7. 多达400+地图文件以及原生的百度地图，为地理数据可视化提供强有力的支持
3. 通过pyecharts模块创建饼状图

导入模块

1# 导入饼图模块
2from pyecharts.charts import Pie
3# 导入配置选项模块
4import pyecharts.options as opts
5

初始化饼状图:

Pie()函数: 创建饼图

opts.InitOpts参数: Pie(init_opts=opts.InitOpts(width=“1400px”, height=“800px”))

init_opts: 指定参数名

opts.InitOpts: 配置选项

**width=“1400px” height=“800px” *界面的宽度和高度

1# 创建饼图并设置这个界面的长和高 
2# px:像素单位
3pie = Pie(init_opts=opts.InitOpts(width="1400px", height="800px"))
4

给饼图添加数据:

add()函数:

参数1: 名称

参数2: 具体数据, 数据类型为==>[(a,b),(a,b),(a,b)]==>a为数据名称,b为数据大小

参数3: 标签设置 label_opts=opts.LabelOpts(formatter=‘{b}:{d}%’) 符合百分比的形式

1# 给饼图添加数据
2pie.add(
3  "GDP",
4  data,
5  label_opts=opts.LabelOpts(formatter='{b}:{d}%')
6)
7

给饼图添设置标题:

set_global_opts()函数 :

title_opts=opts.TitleOpts : 设置标题

title=“2020年世界GDP排名”, subtitle=“美元” : 设置主标题和副标题

1# 给饼图设置标题
2pie.set_global_opts(title_opts=opts.TitleOpts(title="2020年世界GDP排名", subtitle="美元"))
3

保存数据:

1# 保存结果
2pie.render()
3
4. 完整代码
1import requests
2import re
3# 导入饼图模块
4from pyecharts.charts import Pie
5# 导入配置选项模块
6import pyecharts.options as opts
7
8# 存储爬取到的国家的名字
9country_list = []
10# 春初爬取到的国家gdp的数据
11gdp_list = []
12
13
14def get_gdp_data():
15    global country_list
16    global gdp_list
17
18    # 获取gdp的html数据
19    data = requests.get("http://localhost:8000/gdp.html")
20    # 对获取数据进行解码
21    data = data.content.decode("utf8")
22    # 对gdp的html数据进行按行分割
23    data_list = data.split("
24")
25
26    for i in data_list:
27        # 对html进行解析获取<国家名字>
28        country_result = re.match('.*<a href=""><font>(.*)</font></a>', i)
29        # 匹配成功就存放到列表中
30        if country_result is not None:
31            country_list.append(country_result.group(1))
32        # 对html进行解析获取<gdp数据>
33        gdp_result = re.match(".*￥(.*)亿元", i)
34        # 匹配成功就存储到列表中
35        if gdp_result is not None:
36            gdp_list.append(gdp_result.group(1))
37
38
39# 创建一个饼状图显示GDP前十的国家
40def data_view_pie():
41    # 获取前十的过的GDP数据, 同时让数据符合[(),()...]的形式
42    data = list(zip(country_list[:10], gdp_list[:10]))
43    # 创建饼图
44    pie = Pie(init_opts=opts.InitOpts(width="1400px", height="800px"))
45    # 给饼图添加数据
46    pie.add(
47        "GDP",
48        data,
49        label_opts=opts.LabelOpts(formatter='{b}:{d}%')
50    )
51    # 给饼图设置标题
52    pie.set_global_opts(title_opts=opts.TitleOpts(title="2020年世界GDP排名", subtitle="美元"))
53    # 保存结果
54    pie.render()
55
56
57if __name__ == '__main__':
58    # 获取GDP数据
59    get_gdp_data()
60    # 生成可视化饼图
61    data_view_pie()
62
5. 小结

可视化

  • Pie()函数 : 创建饼图
  • add()函数 : 添加数据
  • set_global_opts()函数 : 设置标题
  • render()函数 : 保存数据

七. Logging日志模块

1. logging日志的介绍

在现实生活中，记录日志非常重要，比如:银行转账时会有转账记录；飞机飞行过程中，会有个黑盒子（飞行数据记录器）记录着飞机的飞行过程，那在咱们python程序中想要记录程序在运行时所产生的日志信息，怎么做呢

可以使用 logging 这个包来完成

记录程序日志信息的目的是:

  1. 可以很方便的了解程序的运行情况
  2. 可以分析用户的操作行为、喜好等信息
  3. 方便开发人员检查bug
2. logging日志级别介绍

日志等级可以分为5个，从低到高分别是:

  1. DEBUG
  2. INFO
  3. WARNING
  4. ERROR
  5. CRITICAL

日志等级说明:

  • DEBUG：程序调试bug时使用
  • INFO：程序正常运行时使用
  • WARNING：程序未按预期运行时使用，但并不是错误，如:用户登录密码错误
  • ERROR：程序出错误时使用，如:IO操作失败
  • CRITICAL：特别严重的问题，导致程序不能再继续运行时使用，如:磁盘空间为空，一般很少使用
  • 默认的是WARNING等级，当在WARNING或WARNING之上等级的才记录日志信息。
  • 日志等级从低到高的顺序是: DEBUG < INFO < WARNING < ERROR < CRITICAL
3. logging日志的使用

在 logging 包中记录日志的方式有两种:

  1. 输出到控制台
  2. 保存到日志文件

日志信息输出到控制台的示例代码:

1import logging
2
3logging.debug('这是一个debug级别的日志信息')
4logging.info('这是一个info级别的日志信息')
5logging.warning('这是一个warning级别的日志信息')
6logging.error('这是一个error级别的日志信息')
7logging.critical('这是一个critical级别的日志信息')
8

运行结果:

1WARNING:root:这是一个warning级别的日志信息
2ERROR:root:这是一个error级别的日志信息
3CRITICAL:root:这是一个critical级别的日志信息
4

说明:

  • 日志信息只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING
    logging日志等级和输出格式的设置:
    import logging

设置日志等级和输出日志格式

logging.basicConfig(level=logging.DEBUG,
format=‘%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s’)
logging.debug(‘这是一个debug级别的日志信息’)
logging.info(‘这是一个info级别的日志信息’)
logging.warning(‘这是一个warning级别的日志信息’)
logging.error(‘这是一个error级别的日志信息’)
logging.critical(‘这是一个critical级别的日志信息’)

运行结果:

12019-02-13 20:41:33,080 - hello.py[line:6] - DEBUG: 这是一个debug级别的日志信息
22019-02-13 20:41:33,080 - hello.py[line:7] - INFO: 这是一个info级别的日志信息
32019-02-13 20:41:33,080 - hello.py[line:8] - WARNING: 这是一个warning级别的日志信息
42019-02-13 20:41:33,080 - hello.py[line:9] - ERROR: 这是一个error级别的日志信息
52019-02-13 20:41:33,080 - hello.py[line:10] - CRITICAL: 这是一个critical级别的日志信息
6

代码说明:

  • level 表示设置的日志等级
  • format 表示日志的输出格式, 参数说明:
    • %(levelname)s: 打印日志级别名称
    • %(filename)s: 打印当前执行程序名
    • %(lineno)d: 打印日志的当前行号
    • %(asctime)s: 打印日志的时间
    • %(message)s: 打印日志信息

日志信息保存到日志文件的示例代码:

1 import logging
2
3logging.basicConfig(level=logging.DEBUG,
4                    format='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s',
5                    filename="log.txt",
6                    filemode="w")
7
8logging.debug('这是一个debug级别的日志信息')
9logging.info('这是一个info级别的日志信息')
10logging.warning('这是一个warning级别的日志信息')
11logging.error('这是一个error级别的日志信息')
12logging.critical('这是一个critical级别的日志信息')
13

运行结果:

4. logging日志在Web项目中应用

使用logging日志示例:

  1. 程序入口模块设置logging日志的设置

导入FastAPI模块

from fastapi import FastAPI

导入响应报文Response模块

from fastapi import Response

导入服务器uvicorn模块

import uvicorn

导入日志模块

import logging

配置日志

logging.basicConfig(level=logging.INFO,
format=‘%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s’,
filename=“log.txt”,
filemode=“w”) 2. 访问index.html时进行日志输出，示例代码:

当请求为 /images/0.jpg 时, path ==> 0.jpg

@app.get(“/images/{path}”)

注意这里的参数需要设置为 path

path : str ==> 指定path为字符串类型的数据

def get_pic(path: str):
# 这里open()的路径就是 ==> f"source/images/0.jpg"
with open(f"source/images/{path}", “rb”) as f:
data = f.read()
# 打log
logging.info(“访问了” + path)
# return 返回响应数据
# Response(content=data, media_type=“jpg”)
# 参数1: 响应数据
# 参数2: 数据格式
return Response(content=data, media_type=“jpg”) 3. 访问gdp.html时进行日志输出，示例代码:
@app.get(“/{path}”)
def get_html(path: str):
with open(f"source/html/{path}") as f:
data = f.read()
# 打log
logging.info(“访问了” + path)
# return 返回响应数据
# Response(content=data, media_type=“text/source”
# 参数1: 响应数据
# 参数2: 数据格式
return Response(content=data, media_type=“text/html”)

logging日志:

通过日志信息我们得知, index.html被访问了2次, gdp.html被访问了2次.

说明:

  • logging日志配置信息在程序入口模块设置一次，整个程序都可以生效。
    • logging.basicConfig 表示 logging 日志配置操作
5. 小结
  • 记录python程序中日志信息使用 logging 包来完成
  • logging日志等级有5个:
    1. DEBUG
    2. INFO
    3. WARNING
    4. ERROR
    5. CRITICAL
  • 打印(记录)日志的函数有5个:
    1. logging.debug函数, 表示: 打印(记录)DEBUG级别的日志信息
    2. logging.info函数, 表示: 打印(记录)INFO级别的日志信息
    3. logging.warning函数, 表示: 打印(记录)WARNING级别的日志信息
    4. logging.error函数, 表示: 打印(记录)ERROR级别的日志信息
    5. logging.critical函数, 表示: 打印(记录)CRITICAL级别的日志信息

《Python中的简单爬虫》 是转载文章，点击查看原文。

上一篇：Python与C#：从哲学到细节的全面对比

下一篇：LangChain v1 重大更新讲解⚠⚠⚠

相关推荐

Fastadmin切换英文，部分新增菜单没有切换原因
JSON_L2025/11/19

在使用Fastadmin开启多语言后，切换为英文时，部分新增菜单没有切换问题及解决。 目录 开启多语言 开启多语言 部分菜单没有变化 原因 添加菜单规则 语言包解析 其他标题或提示语解析 总结   开启多语言 开启多语言 首先介绍一下fastadmin中如何开启多语言配置， 在application/config.php中把lang_switch_on改为true。 默认情况下是关闭的，如下： 开启后，在后台会多一个切换语言的入口，默认就是中英

GitHub 热榜项目 - 日榜(2025-11-16)
CoderJia_2025/11/19

GitHub 热榜项目 - 日榜(2025-11-16) 生成于：2025-11-16 统计摘要 共发现热门项目： 18 个 榜单类型：日榜 本期热点趋势总结 本期GitHub热榜显示AI应用开发依然是绝对焦点，开发者正致力于将前沿AI技术转化为开箱即用的解决方案。舆情监控工具TrendRadar和谷歌的AI工具包adk-go引领了这股潮流，它们强调用AI解决信息过载和复杂流程自动化等实际问题。同时，轻量化RAG框架LightRAG和大模型记忆引擎Memori的流行，反映出社区

【深度学习新浪潮】算法工程师如何入门芯片硬软件设计工作？
Andrew-国星宇航2025/11/17

在AI与边缘计算爆发的当下，“算法落地难”逐渐成为行业痛点——很多时候不是算法不够优，而是缺乏匹配算法需求的芯片硬件支撑，或是算法与硬件“脱节”导致部署后性能打折扣。这也让越来越多算法工程师开始关注芯片硬软件设计：既能更深刻地理解算法的硬件适配性，又能参与到“算法-芯片”协同优化的核心环节，成为跨领域的复合型人才。 但算法工程师转型芯片设计，常面临“软件思维 vs 硬件思维”的鸿沟：习惯了软件的灵活性，却对硬件的并行性、时序约束、资源限制感到陌生；熟悉模型训练与推理优化，却不懂EDA工具、数字

python爬虫入门案例day05:Pexels
自学互联网2025/11/16

python爬虫入门案例day05:Pexels 目标网站 Pexels 目标网址 https://www.pexels.com/zh-cn/search/%E6%97%A5%E8%90%BD/ 开发环境 1、window11 2、python3.7 3、PyCharm Community Edition 2021.2.1 4、双核浏览器 5、浏览器自带开发者工具 网站分析 在下拉网页的过程中发现，会不断加载出新的图片，说明该网页为动态网页，那我们可以初步猜想图片的链接存放在通过Ajax请求的网

Python 的内置函数 map
IMPYLH2025/11/15

Python 内建函数列表 > Python 的内置函数 map Python 的内置函数 map() 是一个高阶函数，它允许对一个可迭代对象（如列表、元组等）的所有元素应用指定的函数，并返回一个 map 对象（可迭代对象）。其基本语法是： map(function, iterable, ...) 主要特点： 惰性计算（Lazy Evaluation）：map 对象不会立即执行计算，只有在需要时才会真正处理数据多参数支持：可以同时处理多个可迭代对象函数式编程特性：配合 lambda 表

2.登录页测试用例
Sunlightʊə2025/11/14

用例ID测试标题测试类型测试场景测试步骤预期结果实际结果其他要素Login-001核心登录功能测试功能测试正常登录流程1.输入正确的用户名 2.输入正确的密码 3.点击登录按钮登录成功，跳转至主页面符合预期　Login-002用户名为空1.用户名为空 2.输入任意密码 3.点击登录按钮提示“请输入用户名”，用户名输入框变红符合预期　Login-003密码为空1.输入正确用户名 2.密码为空 3.点击登录按钮提示“请输入密码”，密码输入框变红符合预期　Login

Webpack Loader 和 Plugin 实现原理详解
阿珊和她的猫2025/11/12

🤍 前端开发工程师、技术日更博主、已过CET6 🍨 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 🕠 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》、《前端求职突破计划》 🍚 蓝桥云课签约作者、上架课程《Vue.js 和 Egg.js 开发企业级健康管理项目》、《带你从入门到实战全面掌握 uni-app》 文章目录 一、Webpack Loader 实现原理（一）Loader 的概念（二）Loader 的生命周期（三）Loade

📘 全面解析：JavaScript 时间格式化 API 实战指南
excel2025/11/11

——从 toUTCString() 到 Intl.DateTimeFormat 的深度理解 时间与日期，是前端开发中最容易“踩坑”的部分。不同浏览器、不同区域、甚至不同系统语言，都会造成输出不一致。 本文将系统解析 JavaScript 提供的时间格式化方法，帮你彻底搞懂它们的差异、用途与正确使用方式。 一、背景：为什么会有这么多时间格式化方法？ JavaScript 的时间系统基于 ECMAScript 时间标准，时间点以 UTC 为基准（Unix Epoch：1970-01-01 00:0

JUC篇——核心、进程、线程
不穿格子的程序员2025/11/9

一、三者的层次关系 核心：cpu的大脑 进程： 程序的运行状态 线程：对共享变量进行操作的变量 二、线程的六种状态 三、创建线程的四种方式（咖啡店比喻理解） 具体参考：https://blog.csdn.net/m0_59624833/article/details/151891492?spm=1001.2014.3001.5501 继承Thread类（老板亲自做咖啡）实现Runnable接口（雇佣服务员做咖啡）实现Callable接口结合FutureTask，适用于执行有

RabbitMQ 实战：理解“不公平分发（Unfair Dispatching）”机制
sg_knight2025/11/6

一、前言        在使用 RabbitMQ 构建消息队列系统时，很多人都知道它有“轮询分发（Round-Robin Dispatching）”机制。 也就是说： 如果有多个消费者同时订阅同一个队列，RabbitMQ 会尽量让每个消费者轮流接收相同数量的消息。 听起来很“公平”，但实际运行中你可能会发现—— 有的消费者几乎“忙不过来”，而另一些消费者却“闲得发慌”。 这，就是所谓的 不公平分发（Unfair Dispatching） 现象。 二、为什么会出现“不公平分发”？ Rabbi

上一篇：Python与C#：从哲学到细节的全面对比

下一篇：LangChain v1 重大更新讲解⚠⚠⚠

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2025 聚合阅读