- 博客(235)
- 资源 (1)
- 收藏
- 关注
RSS订阅
原创 Python实战：用Selenium爬取网页数据
Selenium是一个自动化测试工具，它可以模拟用户在浏览器中的操作，比如点击按钮、填写表单等。与常用的BeautifulSoup、requests等爬虫库不同，Selenium可以处理JavaScript动态加载的内容，因此对于那些需要模拟用户交互才能获取的数据，Selenium是一个非常合适的选择。
2023-04-30 17:27:53
6916
原创 Python 里 del x 到底删掉了什么？拆开引用计数、4294967295 和分代 GC 漏掉的那圈循环引用
del x热循环里手动→ 一次约 1.5ms，纯亏。确需调优改，别频繁全量回收。5.把清理逻辑写在__del__里等它立刻执行→ 循环场景下时机不可控，改用上下文管理器。## 九、小结del x的准确语义是「把名字x从当前作用域解绑，并让对象引用计数减一」。计数归零，对象当场消失；归不了零又成环，就等分代 GC 来收。中间还夹着 3.12 之后那批被钉在2**32-1的永生对象。
2026-11-07 09:46:36
124
原创 Python 的 __init__ 到底是不是构造函数？拆开 __new__ 先造对象、那次被跳过的初始化和必须返回 None 的规矩
时触发的，跟实例创建无关；别把它和。
2026-11-07 09:45:39
140
原创 Python 的 list[int] 为什么不是 list？拆开 __class_getitem__ 和那层 80 字节的薄包装
print(g.直接把参数转交给，也就是list(…)。方括号里的intlisttyping是另一套实现（），明确禁止实例化；内置的list[int]允许。list[int]是 Python 3.9 之前的老写法。## 三、为什么自定义类写 C[int] 会报错方括号这个动作，走的是协议；对类对象来说，特殊入口叫。内置容器（list / dict / tuple / set / type 等）在 C 层面实现了它，普通类没有，所以报错。不要求返回，它只是个钩子。标准库里list[int]返回。
2026-11-05 15:06:14
209
原创 Python 的 obj.x 到底按什么顺序找？拆开数据描述符、实例字典和 __getattr__ 那条优先级链
先看一组我在自己机器上跑出来的数（CPython 3.13.14，timeit同样一句obj.x，最慢和最快差了十倍。差别不在字典查得快不快，而在这一句背后有一条五层的优先级链，Python 得一层层往下试。更反直觉的是：我把值塞进了，取出来却可能不是它。
2026-11-05 15:05:17
195
原创 Python 的 assert 为什么不能用来校验参数？拆开 -O 模式与那行会被整段删掉的代码
用跑，传b=0会抛，看着挺稳妥。用跑，这一行。传b=0会抛，连那句提示都没了。如果这段代码负责的是校验用户输入、检查接口参数、判断权限，那么-O一开，校验就整段消失，而且不会有任何报错告诉你它消失了。这不是概率问题，是设计如此。
2026-11-04 09:26:37
171
原创 Python 的 async def 为什么能同时跑几千个任务？拆开协程对象、await 与事件循环那次让出
差了 626 倍。整个过程没开一个线程，没起一个进程，就是一个线程在那儿转。很多人把这件事理解成「asyncio 比线程快」，其实不对。快的是，不是代码跑得更快。要弄清这一点，得从async def到底造出了什么开始拆。## 一、async def 定义的是协程函数，不是普通函数。这个标记决定了调用它的时候，解释器不会立刻执行函数体。RuntimeWarning: coroutine ‘fetch’ was never awaited```协程对象自己不会跑，得有人它。这个人就是事件循环。
2026-11-04 09:25:20
140
原创 Python 的默认参数为什么不能用 []？拆开 __defaults__ 里那个被所有人共享的列表
每次都在往同一个对象里塞东西。这一行时，就会把默认参数的值求值出来，然后挂到函数对象上，之后再也不重新算。——跟我们前几期讲的引用语义完全一回事：变量是标签，不是盒子。默认参数里放的不是"每次新建一个空列表"的指令，而是一个。为 True，说明三次调用返回的。先看一段能让人怀疑人生。
2026-11-03 09:04:19
75
原创 Python 的 0.1 + 0.2 为什么不等于 0.3？拆开 IEEE 754 与那串死循环小数
python>>> float.hex(0.1)‘0x1.999999999999ap-4’>>> float.hex(0.2)‘0x1.999999999999ap-3’>>> struct.pack(‘>d’, 0.1).hex()几乎每个 Python ‘3fb999999999999a’round` 能救你。（实测环境：CPython 3.13，Windows；文中数字均可直接复现） == 0.3False。
2026-11-03 09:03:23
348
原创 Python 的 range 为什么能装下一亿个数还不卡？拆开惰性序列与懒计算
pythonr = range(100)len® # 100，可以随时问长度r[50] # 50，可以随机访问sum® # 遍历完了还能再来一遍sum® # 重复迭代，结果不变。pythonrange(100)[10:90:2] # range(10, 90, 2) —— 依然 48 字节```代价是它。——这就是惰性序列的本质。对比一下代价（CPython 3.13 实测）：| 写法 | 内存 ||—|—||要第 9999 个，也是现算。
2026-11-02 09:58:13
1072
原创 Python 的赋值为什么不会复制对象？拆开引用、浅拷贝与深拷贝
所谓"赋值"，本质上就是把 8 字节的指针抄了一遍——这也解释了为什么 Python 里赋值快得不像话。都指着它，当然一起变。CPython 里每个变量名都只是指向某个。对象本身一个字节都没动。操作的是那个唯一的列表对象，先看一段让新手崩溃的。
2026-11-02 09:57:14
577
原创 Python 的 list.append 为什么是 O(1)？拆开 CPython 扩容公式与 86 次搬内存
len=41 472 容量 52len=53 568 容量 64len=65 664 容量 76len=77 792 容量 92len=93 920 容量 108len=109 1080 容量 128c```翻译成人话：-newsize—— 这次需要的最小容量-—— 额外多给（除以 8）-+ 6—— 保底多给 6 个-& ~3——逐个验证上面的实测值，全中：| newsize | 计算 | & ~3 之后 | 实测容量 ||—|—|—|—|O(1)
2026-11-01 09:26:56
112
原创 Python 的函数调用到底慢在哪？拆开 PyFrameObject、字节码 CALL 与查找链
第 1 步和第 4 步的「建帧 + 拆帧」，才是开销的大头，不是函数体本身（本例函数体是空的）。## 二、本机实测（纳秒级）| 操作 | 每次耗时 ||—|—|| 内联常量。CPython 3.11 起帧被拆成「解释器栈帧 + 更轻的 PyFrameObject」，比老版本轻了不少，但「每次调用都要 new 一个」这件事没变。也就是说，一次空调用大约 45ns，其中真正属于「调用机制」的，就是建帧、拆帧加名字查找这几样。（局部化后） | 45.1 ns |环，习惯把函数调用尽量提| 方法调用。
2026-10-31 12:00:23
160
原创 Python 的 str 为什么设计成不可变？拆开字符串驻留、字符串池，以及 += 拼接到底慢在哪
先说不可变这件事本身。这是最实在的理由。Python 的dict和set依赖键的哈希值在生命周期内不变。如果字符串能原地改，{s: 1}的哈希就漂移了，整个哈希表会塌。你每天写的能成立，前提就是"name"不可变。同一个字面量只存一份，比较时甚至能直接比身份（is）而不比内容。这个后面实测。我第一次看不可变对象天生只读，多线程并发读取不需要加锁。这也是为什么 Python 标准库里大量用 str 传配置、路径、键名。
2026-10-31 11:59:24
78
原创 Python 的 GIL 到底锁住了什么？拆开线程调度与那段“串行化的 CPU“
很多人学 Python 多线程时都被泼过冷水："Python 的多线程是假的，因为有 GIL。"这句话流传很广，但真正被锁住的到底是什么，多数人讲不清。今天我把它拆开，再用一段实测告诉你：什么时候 GIL 在拖后腿，什么时候它其实无所谓。那它锁的是什么？一句话：任何时刻，只有一个线程能持有这把锁去执行 Python 字节码。它本质上就是一个操作系统级的互斥锁（在 Linux/Windows 上底层是 pthread mutex），谁拿到锁谁才能跑 Python 代码。## 二、GIL 怎么"轮流转"的CP
2026-10-30 09:15:57
152
原创 Python 的 with 语句到底做了什么？拆开 __enter__/__exit__ 与异常传播
很多人用用得很顺，但被问到"它到底比 try/finally 强在哪"就卡壳。其实with不是语法糖那么简单——它是 Python 用"协议"而非"约定"把资源管理焊死在语言层。今天拆开看 CPython 3.13 里with到底走了哪几步，以及它比手写 try/finally 慢多少。
2026-10-29 17:56:18
36
原创 Python 的 dict 为什么查询是 O(1)？拆开哈希表、扰动函数与扩容阈值
很多人背过一句话："Python 的字典查询是 O(1) 的。"但真到了面试或者调性能的时候，这句话经不起两问：凭什么是常数？常数就不是要算哈希吗？哈希不要时间？今天我们就把 CPython 3.13 的 dict 拆开，用实测把"O(1)"钉死。
2026-10-29 17:54:45
164
原创 Python 的 import 到底做了什么？首次 2 毫秒与缓存 1 微秒，中间隔着一个 sys.modules
同一个模块，。中间隔着的不是魔法，是这个全局缓存。所以"函数里写 import 会不会很慢"这类担心基本是多余的：实测函数内重复 import 10 万次，每次只要 193 纳秒。本文用实机数据把 import 的完整流程拆一遍，顺带讲清和循环导入这两个高频坑。
2026-10-28 11:03:09
181
原创 Python 的列表和元组到底差在哪？拆开 PyListObject 和 PyTupleObject，为什么一个能改一个不能
list 和 tuple 的差别不只是"能不能改"这么简单。（0.012s vs 0.078s，各 100 万次）、。代价只有一个：创建后不能改。本文用实机数据拆开两者的底层结构，告诉你什么时候该用哪个。
2026-10-28 11:02:10
115
原创 Python 列表推导比 for+append 快多少？实测 100 到 10 万，结论和你想的不一样
列表推导 ≈ 预分配循环 > 裸 append（慢一点点）
2026-10-27 10:12:52
132
原创 Python 里 is 和 == 到底差在哪？拆开小整数池、字符串驻留与 0ns 身份比较
很多人学 Python 第一个踩的坑就是is和==。一句话先说清：is==。下面用 CPython 3.13.14 实机跑出来的几组数据，把那些反直觉的地方拆开看。
2026-10-27 10:11:55
274
原创 Python 的 lru_cache 到底值不值？拆开命中 181ns、未命中 381ns 与 maxsize 的边界
lru_cache几乎是 Python 里最容易上手的优化：一行装饰器，函数结果就缓存了。但它不是免费的。本文用a + b这种极简函数做基准，把缓存的maxsizetyped全部实测出来，回答一个问题：什么样的函数才配得上lru_cache。## 一、结论先行-lru_cache不适合包在极廉价的函数上-：缓存没命中时，你付的是"查表 + 计算 + 写表"- maxsize=1：参数轮换时会反复淘汰，实测 1000 次调用 hits=0typed11.0typed=True11.0Truea + b。
2026-10-26 10:43:20
852
原创 Python 拼字符串为什么别在循环里用 +=？拆开 join 的两遍账：191.8 微秒与 6.8 微秒
=join这句话是对的，但很多文章只说结论，不告诉你贵在哪。本文用 1000 段字符串的实测，把+=和join的账拆到底，顺手验证一个常被说错的细节：CPython 对+=的"原地优化"到底在什么条件下失效。## 一、结论先行-+=joinjoin+=贵的根源是；join先扫一遍算总长，再一次性分配s += x+=joinjoinstr.formatjoin。
2026-10-26 10:42:23
977
原创 Python 的 try 为什么变免费了？拆开 3.11 零成本异常：异常表、562 纳秒与字典查找的反转
Python 3.11 有个少有人讲清的变化：try 块在正常路径上了。实测（CPython 3.13.14）带 try 的函数 147.8 ns/次，不带 try 的 151.7 ns/次——。与此同时，真正抛出一次异常要 562 ns，是正常路径的 3.8 倍。一文拆开这套「进入免费、使用昂贵」的新机制。
2026-10-25 15:30:29
162
原创 Python 的函数调用到底贵在哪？拆开一次 call：51 纳秒栈帧与 *args 的 40 纳秒罚单
c.m() 120.4 ns/次C.m© 202.8 ns/次```路径要内联」。可这个开销c.m()走的是 descriptor 协议预绑定的 method 对象，少一次「把 self 显式塞进参数表」；C.m(c)是普通函数调用加一次参数绑定。代码里热点路径的动态分发，付的就是这条链路。
2026-10-25 15:29:31
186
原创 Python 的 is 为什么时灵时不灵？拆开常量合并、小整数池与 intern 三层机制
几乎每个 Python 教程都会告诉你：「is比较身份，别用它比较数字，因为只有 -5 到 256 的小整数被驻留」。257 is 257返回。而返回。同一个 257，同一台机器，截然相反。这不是玄学，是三层不同的机制叠在一起造成的。本文用 CPython 3.13.14 实机数据，把「is 时灵时不灵」彻底拆开。## 一、先看现场：一组互相矛盾的结果如果「驻留池只到 256」是全部真相，第一行就该是 False。它却是 True。真相远比一句口诀复杂。
2026-10-23 16:13:22
204
原创 Python 的 for 到底怎么跑起来的？拆开迭代协议：GET_ITER 之后 FOR_ITER 在循环什么
写 Python 的人天天用 for，但多数人说不清在字节码层面到底发生了什么。for能遍历 list、str、dict、文件、生成器——这些类型八竿子打不着，凭什么for一视同仁？答案不在这些类型里，在它们共同遵守的那份里。本文用 CPython 3.13.14 实机数据，把这份协议拆开。
2026-10-23 16:12:23
176
原创 Python 的 GIL 到底是什么？拆开「一次一条字节码」：为什么多线程算数是负优化
选型表：| 任务类型 | 推荐 | 原因 ||—|—|—|| CPU 密集（计算、编解码、数据处理） | 多进程 / C 扩展 / numpy | 绕开 GIL || I/O 密集（网络、磁盘、爬虫） | 多线程 / asyncio | 等待期锁是放开的 || 混合型 | 进程池 + 线程池 | 各管一段 |写一个纯计算的活（200 万次循环累加），三种跑法：| 跑法 | 耗时 | 加速比 ||—|—|—|| 单线程跑 1 份 | 156 ms | — || 2 个线程各跑 1 份 | 312 ms |
2026-10-22 08:52:18
135
原创 Python 的 dict 为什么插入顺序不会乱？拆开 3.6 的紧凑布局：indices 与 entries 两张表
但坑在删除：**。**——。## 2. 底层：哈希表被劈成了两张表旧版 CPython（≤3.5）的 dict 是一张四元组大表，稀疏排布，遍历顺序就是哈希桶顺序——。什么插入顺序不会乱3.6 的重写（PEP 468 落地、Raymond Hettinger 主导）把这张表劈成两张：| 表 | 内容 | 特点 ||—|—|—||indices| 稀疏索引数组，存 entries 的下标 | 按哈希定位，只存 int ||entries| 紧凑条目数组，按插入序存| 顺序 = 插入顺序 |？
2026-10-22 08:51:20
193
原创 Python 的 with 到底在管什么？拆开上下文管理器：__exit__ 返回值决定生死，异常从 yield 灌进去
# P## 1. 两次调用：with 的全部秘密→ 块体 →。：块体炸了 →→ 返回真值就地吞掉，返回假值原样抛出。
2026-10-21 08:33:56
151
原创 Python 的 sort 为什么又稳又快？拆开 Timsort：run 检测、minrun 与 galloping 的三板斧
## 1. 第一板斧：run 检测——先投降，后作战。
2026-10-21 08:32:59
165
原创 Python 的 yield 到底暂停了什么？拆开 generator 的栈帧，看 192 字节怎么装下整个现场
## 1. 先看字节码：yield 前后是两套世界# Pyt把一个带 yield 的函数丢进。
2026-10-20 08:20:18
257
原创 Python 的 list append 为什么是均摊 O(1)？拆开过度分配那张表，看容量翻倍背后的暗账
# P## 1. 空 list 就有 56 字节，append 一个就跳到 88返回 56——这是 list 对象头加一个空指针数组的固定开销。ython 的 list 一次 append，容量从 0 直接跳到 4（56 + 4×8 = 88）。CPython 从不为「刚好够」买单——
2026-10-20 08:19:22
274
原创 Python 的 import 为什么第二次几乎不要钱？sys.modules 缓存与模块单例的代价
## 1. 第二次 import 只是一次字典查询实测 10 万次总共 23 毫秒——。这不是「重新加载了一遍 json」，而是 import 系统第一件事就是查字典，命中就直接返回。import 语句的编译结果里甚至没有文件 IO，只有一个字典查找加名字绑定。
2026-10-19 10:19:52
658
原创 Python 的闭包到底“包”住了什么？拆开 cell 对象看一眼
里有什么一个闭包函数身上挂着，里面是一个就是被"包"的那个值。记着自由变量的名字。对照实验：如果内层函数压根没用外层变量，直接是None不是看它嵌了几层，也不看它写在哪个函数里面。## 2. cell 是"引用"不是"拷贝"两次调用返回不同值，说明i没有被"拍照"进闭包。**cell 里装的是引用，外层变量活着，cell 就能改；外层函数早返回了，cell 就是那个变量唯一的家。**这就是nonlocal存在的原因：它改的不是外层函数栈上的某个格子（那个格子早没了），而是 cell 盒子里的内容。
2026-10-18 11:32:51
152
基于python的人员信息管理系统的设计与实现毕业论文
2023-06-08
基于Python+Django的人员管理系统源码
2023-05-04
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人