芝士雾汐

如何读论文

Sat, 05 Sep 2026 00:00:00 +0000

1. 引子

做科研，读论文是必不可少的一环。但是，对于一个刚刚接触科研的学生来说，如何高效地读完一篇又长又晦涩的论文，并且真正有所收获，往往是一个棘手的问题。

在成为相关领域的泰斗之前，大多数时候，我们并不熟悉论文中涉及的知识。此时，如果像读教材一样从头读到尾，难免会被繁杂的公式所阻，或者为晦涩的术语所困；有时甚至会为了补充前置知识，循着参考文献一路读下去。折腾了许久，好不容易囫囵吞枣地读完一篇文章，回过头来却发现自己好像什么都没有学到。

读论文本身就是一件格外耗费时间和精力的事情。除了坚持下去的勇气，我们还需要掌握一些技巧，才能尽量达到事半功倍的效果。

于是乎，作为一名学术小白，笔者试图以李沐老师的《如何读论文》视频为蓝本，结合自己的一些经验，写出这样一篇文章，以供大家参考。视频中提到的“三遍阅读法”源自 S. Keshav 的短文 How to Read a Paper。笔者主要阅读机器学习领域的论文，不过其他学科的论文大抵也有相似之处，大家可以以此文为蓝本，再结合自己的学习经验进行调整哦。（PS：由于本人也起步不久，若有纰漏，欢迎指出 QAQ）

2. 论文结构

在了解如何读论文之前，我们需要先对论文的结构有一个简单的认识。

下图展示了论文的一般结构。不过，这种结构并非一成不变，而是会随学科、期刊和文章内容而调整。例如，有的论文会设置单独的 Discussion（讨论）章节，却不设置独立的 Conclusion（结论）；有的论文则会把 Limitations（局限性）单独列为一个章节。这些都不是重点，只要掌握大致的结构，知道去哪里寻找需要的信息即可。

按照这种方法，我们大致可以把阅读分为三遍。必须注意的是，并非每篇论文都值得完整读上三遍。究竟读到哪一遍，应当取决于论文与你的研究问题有多相关，以及你希望从中获得什么。越重要、越相关的论文，越值得投入更多时间。至于每一遍具体该怎样读，将在下文提到。

3. Pass 1

第一遍的目标不是“读懂”，而是快速建立对论文的整体印象。

我们可以先阅读标题和摘要。标题是对论文内容最精炼的概括，可以帮助我们粗略判断这篇论文与当前研究方向的关联程度；摘要则会告诉我们文章试图解决什么问题、使用了什么方法，以及得到了怎样的结果。随后，可以阅读引言、各级标题和结论，弄清楚作者为什么要研究这个问题，以及最终给出了怎样的回答。结论虽然常常与摘要相似，但通常会更具体地概括主要发现，也可能提到局限性和未来工作。

此外，我们还可以浏览方法和实验部分的图表，理解大致的流程与结果。例如，大名鼎鼎的 Attention Is All You Need，就可以先通过那张流传甚广的 Transformer 结构图了解整体框架，再在后面的阅读中逐渐补充细节。

完成第一遍后，我们至少应当能够回答几个问题：这篇论文在研究什么？它为什么值得研究？作者大致做了什么？它与我的研究有什么关系？此时，我们只能对论文的质量作出初步判断，但已经足以决定它是否值得继续读下去——这也是第一遍最重要的任务。

4. Pass 2

当我们认为这篇文章与自己的目标比较相关时，就可以开始第二遍阅读了。这一遍需要从头到尾了解作者的论述，但仍然不必困在所有细节里：一时难以理解的公式推导、复杂证明和实现细节，可以先做上标记，暂时跳过。

再次遇到图和表时，我们就要认真辨认它们的含义。例如，方法流程图中的每一个模块分别做了什么，实验图的横纵坐标和单位是什么，表格比较了哪些基线，最优结果是否显著，以及结果是否真的支持作者的结论。图表往往是理解整篇论文的关键，但也不要只盯着加粗的最佳数字哦。

同时，可以把重要的相关文献标注出来。如果文章太难，一时读不懂，与其沿着所有引用漫无目的地挖下去，不如优先寻找综述、教程，或者作者引用的奠基性工作。这些材料通常更适合补齐背景知识，但它们也未必一定更简单，因此最好始终带着具体问题去查阅。

完成第二遍后，我们应当能够比较清楚地复述：论文解决了什么问题，为什么采用这种方法，实验如何验证它，以及它还存在哪些局限。此时，即使还没有完全搞懂所有细节，也该能够决定是否值得继续精读。

5. Pass 3

当我们准备读第三遍时，基本已经确定这是一篇对自己非常重要的文章。此时，我们需要追踪它完整的论证链条：作者提出了什么问题，做出了哪些假设，用什么方法解决，实验又是否真正支持结论。

读到关键公式时，可以尝试自己推导；读到方法时，可以想象如何把它写成代码；读到实验时，则要留意数据集、评价指标、对比方法、消融实验和超参数是否足以支撑作者的主张。重点不是机械地背下每一句话，而是尽可能重建作者完成这项工作的过程。

此外，还可以换一个角度想象：如果这件事由我们来做，会采用什么方法和实验？作者的假设是否合理？有没有遗漏的对比？结论能否推广到其他数据或场景？哪些地方还有改进空间？到了这一步，我们已经不只是在接收论文中的信息，而是在尝试与作者对话。

重中之重，是在脑海里把整个研究过程重新走一遍，就如同自己又做了一次一样。至此，我们应当已经掌握了论文的大部分关键细节；即使关上文章，也能较为完整地复述它的研究问题、方法、证据与局限。

6. 补充

6.1 关于 Appendix（附录）

一般不需要一开始就把附录连着看完。附录通常放的是正文容纳不下的细节，例如完整的实验设置、更多消融实验、超参数、证明、数据集说明、额外结果和实现细节。有时附录甚至比正文还长，此时过早扎进细节，反而容易什么都记不住，还白白浪费时间。

可以按照这个原则判断：第一次读论文时先跳过附录；当准备复现、质疑结果、尝试改进，或者正文某处写着“details in Appendix”时，再去查阅对应部分。如果只是想理解“这篇论文做了什么”，正文通常已经足够；如果要真正开展研究，尤其是复现和比较实验，附录往往非常重要，因为许多关键的训练设置和额外实验只会出现在那里。

请注意：不要“读附录”，而要“查附录”。先在正文中发现问题，再带着问题去寻找对应章节，这样效率最高。

6.2 工具

有一款专门用于管理和阅读论文的软件，名为 Zotero。它可以方便地导入、整理文献和添加标注；阅读论文时，还可以直接预览文中引用的图、表和参考文献，不必频繁跳转。具体使用方法请自行探索，上手还是很快的。

我们阅读论文的全流程中都可能能使用到 AI 工具，例如查找有关文献、解释相关段落等等，学会使用 AI 可以帮助我们大幅度提高生产力和学习效率。读完论文后，也可以让 AI 生成一段文字或图片总结，提炼论文的重要内容，并将其记载在 Zotero 的笔记部分，帮助我们在下次复习时快速回忆内容。不过，不要忘记温故知新：这些总结只能作为辅助，仍然要定期回到论文原文复习和思考。请注意仔细辩驳 AI 产生的相关信息，有时它会给出虚假的参考文献或者不合主题的解释，请格外注意。

6.3 英语问题

我不了解其他专业是否经常需要阅读英文文献，但至少我的研究方向是需要的。这对我们这些非英语母语者提出了更高的要求。除了努力提高英文阅读能力之外，也可以借助一些小工具。例如，我常常会把难以理解的长难句或专业术语交给 ChatGPT，让它拆解句子结构、解释术语，并结合上下文说明含义。用好 AI 工具，确实可以大幅提高学习效率。

不过，AI 给出的解释也可能存在错误，尤其是涉及公式、实验设置和冷门术语时。因此，最好把它当作一位辅助讲解员，而不是论文作者本人；关键结论仍然应当回到原文、公式和实验中核对。

此外，我还会用到 Zotero 的翻译插件。开启划词翻译一类的功能后，选中不认识的词语或句子，通常就能直接看到常用含义，不必反复复制到浏览器中搜索。不过，这类工具往往只会给出词语最基础的释义。当一个词有多种含义时，仍然需要结合上下文仔细辨析。如果遇到专业术语，或者很难把握整个句子的准确含义，我还是更推荐让 AI 帮忙拆解，再回到原文核实。一举两得，但不能全盘托付。

当然——最好的办法还是努力学好英语咯～（学好英语这辈子都不可能了啦 QAQ）

7. 总结

说到底，读论文并不是一开始就应当埋头苦读，从第一页坚持爬到最后一页，而是一个不断筛选、不断深入的过程。第一遍，我们判断“它值不值得读”；第二遍，我们弄清楚“它究竟做了什么”；第三遍，我们追问“它为什么这样做，以及做得是否可靠”。每读完一遍，都应该留下一个更加清晰的答案，而不是只在文献阅读量上默默加一。

当然，三遍阅读法也不是必须严格执行的规章制度。无关紧要的论文，看完摘要和结论便可以潇洒离开；真正重要的论文，读上三遍之后也可能仍然需要反复查阅。最重要的始终不是“我今天读了几篇”，而是“这篇论文帮助我解决了什么问题，又给我留下了什么新的问题”。

希望我们都能少一点从头读到尾却一脸茫然的时刻，多一点关上~~李玲玲~~后恍然大悟的快乐。科研之路漫漫，论文也永远读不完，那就先从真正读懂眼前这一篇开始吧～

如果还有什么可以补充的内容，欢迎在评论区指出哦～

感谢你的阅读，希望这篇文章对即将踏上科研之旅的你有所裨益！

我做了一个交互式 Diffusion 学习网站

Wed, 29 Jul 2026 00:00:00 +0000

前段时间在学习扩散模型时，我发现自己经常处在一种“公式好像看懂了，但整个过程并没有真正连起来”的状态。

例如，我知道前向过程是在不断加噪，也见过下面这条公式：

\[x_t=\sqrt{\bar{\alpha}_t}x_0+\sqrt{1-\bar{\alpha}_t}\varepsilon, \qquad \varepsilon\sim\mathcal N(0,I)\]

但只看公式时，仍然很难直观回答一些问题：时间步增大时，信号究竟以多快的速度消失？Linear 和 Cosine 调度有什么区别？训练时为什么只需要随机抽一个时间步，生成时却要从 $T$ 一直走回 $1$？模型预测噪声和恢复 $x_0$ 又是怎样联系起来的？

于是我做了一个面向 DDPM 初学者的中文交互式学习网站，名字叫 扩散原野。

项目仓库：onnisama/Diffusion_field

一键跳转：扩散原野

为什么不是再写一份论文笔记

扩散模型的难点不只是公式多，而是同一个概念往往同时存在于几个不同层次：

直觉上，它是在逐渐破坏数据，再学习如何逆转这个过程；
概率上，它由前向马尔可夫链与参数化的反向条件分布组成；
数学上，它会经过高斯分布、后验、KL 散度和 ELBO；
训练时，网络通常学习预测加入到 $x_t$ 中的噪声；
写成代码后，还要处理时间步、张量 shape、调度器和采样循环。

如果只读其中一层，很容易出现“每一段都认识，合起来却不知道模型到底在做什么”的情况。

所以这个网站没有按照传统博客的方式连续堆放长篇文字，而是尽量让同一个概念在 直觉、公式、动画、代码和小测 之间来回对应。读者可以先拖动滑块观察现象，再回头看公式；也可以先展开推导，然后在 PyTorch 代码中找到同一项究竟落在了哪一行。

从一张图怎样变成噪声开始

首页和前向扩散章节都有一个可以直接操作的加噪实验。时间步、噪声调度、总步数和随机种子都可以调整，页面同时显示：

当前的 $x_0$、噪声 $\varepsilon$ 和 $x_t$；
$\beta_t$、$\alpha_t$ 与 $\bar{\alpha}_t$；
信号系数 $\sqrt{\bar{\alpha}_t}$；
噪声系数 $\sqrt{1-\bar{\alpha}_t}$；
当前时间步的 SNR。

这里的图像变化并不是用模糊、透明度或几张预先准备的图片拼出来的，而是对每个像素真实计算前向闭式公式。二维点云实验也使用同样的机制，因此可以看到月牙、圆环或高斯簇怎样逐渐失去原来的几何结构，最后接近标准高斯分布。

这个实验也让我对 $\bar{\alpha}_t$ 有了更具体的认识。它不只是推导里经常出现的一串连乘，而是在回答：“到了第 $t$ 步，原始信号还保留了多少？”

把训练和采样彻底分开

刚开始学习 DDPM 时，我最容易混淆的是训练与生成。

训练一次 batch 时，并不需要真的把每张图片从第 $1$ 步循环加噪到第 $T$ 步。因为前向过程具有闭式形式，可以直接：

从数据集中取得 $x_0$；
为样本随机抽取时间步 $t$；
采样标准高斯噪声 $\varepsilon$；
一步构造对应的 $x_t$；
让网络预测 $\varepsilon_\theta(x_t,t)$；
计算噪声预测误差并反向传播。

而生成时没有真实的 $x_0$，只能先从

\[x_T\sim\mathcal N(0,I)\]

开始，再反复计算 $x_T,x_{T-1},\ldots,x_0$。因此网站分别做了训练流程播放器和采样代码播放器：当前执行步骤会高亮，旁边的状态也会同步变化。

把这两条流程放在一起看之后，“训练时随机抽一步，采样时逐步走完整条链”就不再只是需要背下来的结论了。

公式不能只负责看起来很厉害

从前向分布

\[q(x_t\mid x_{t-1}) = \mathcal N\left( x_t; \sqrt{1-\beta_t}x_{t-1}, \beta_tI \right)\]

到任意时间步的闭式采样，再到后验

\[q(x_{t-1}\mid x_t,x_0),\]

每一步都需要说明用了什么性质、每个符号表示什么，以及它最终怎样进入训练目标。复杂推导默认不会一次全部铺开，而是可以逐步展开，并标出这里使用的是高斯线性组合、重参数化、贝叶斯公式，还是 KL 分解。

网站还专门整理了原始 DDPM 论文公式 (1)–(16) 的阅读路线。希望读完之后，至少能分清以下几个容易混在一起的对象：

负 ELBO；
中间时刻的 KL 项；
论文公式 (12) 中带时间权重的噪声误差；
公式 (14) 的 $L_{\mathrm{simple}}$。

它们之间存在严格联系，但不能为了讲得简单就全部写成同一个东西。

从公式走到一份最小 PyTorch 实现

在代码章节中，我把一个最小 DDPM 拆成了若干小模块，包括：

Beta schedule 与各类系数预计算；
extract 和 q_sample；
正弦时间嵌入；
简化 U-Net；
噪声预测损失；
单步反向采样与完整采样循环；
checkpoint、随机种子和生成样本；
EMA 与混合精度训练的拓展位置。

每段代码都会标出输入、输出和张量 shape，并提供教学版与工程版的对照。默认学习路径选择 MNIST，是因为它能够把训练成本控制在比较容易接受的范围内，同时又足以跑通完整流程。

不把后续工作都算到 DDPM 头上

Diffusion 领域的发展很快，许多今天常见的内容并不属于 2020 年的原始 DDPM 论文。

网站中的论文地图把几条路线分开整理：

DDPM：离散时间扩散与噪声预测的核心路径；
Improved DDPM：Cosine schedule、方差学习等改进；
DDIM：不同的生成过程与更少步采样；
Score-SDE：连续时间的 SDE 统一视角；
Classifier Guidance 与 Classifier-Free Guidance：条件控制；
Latent Diffusion：把扩散过程转移到潜空间。

这样做主要是为了避免一个常见问题：学到 Stable Diffusion、CFG 或 $v$-prediction 后，再回头把它们全部归到 DDPM 原论文里。

目前完成的学习闭环

现在网站已经包含数学基础、DDPM 核心原理、交互实验室、PyTorch 实现、论文地图、术语表、测验和本地学习进度。

我给它安排的主线是：

数学基础 → 前向扩散 → 闭式采样 → 反向过程 → 噪声预测训练 → DDPM 采样 → PyTorch 实现 → 小测

测验不只是告诉读者选对还是选错，还会解释每个错误选项具体混淆了什么。学习进度保存在浏览器本地，不需要注册账号。

网站后面还会继续补充 DDIM、Score Matching、SDE 和条件生成等进阶内容哦~敬请关注！

Python 学习笔记 (8)：定制类、枚举与错误处理

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

定制类、枚举与错误处理

定制类

类有很多特殊变量函数，可以用于定制类的各种特殊用途

str 和 repr

__str__( ) 可以改变 print 实例的结果

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name: %s)' % self.name

>>> print(Student('Michael'))
Student object (name: Michael)

__repr__( ) 可以改变交互界面直接输入的结果

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name: %s)' % self.name
    __repr__ = __str__

>>> s = Student('Michael')
>>> s
Student object (name: Michael)

__str__( ) 返回用户看到的字符串，而 __repr__( ) 返回程序开发者看到的字符串

iter 和 next

如果一个类想被用于 for ... in 循环，必须实现一个 __iter__( ) 方法，该方法返回一个迭代对象，for循环会不断调用该迭代对象的 __next__( ) 方法拿到循环的下一个值，直到遇到 StopIteration 错误时退出循环

以斐波那契数列为例：

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值

>>> for n in Fib():
...     print(n)
1
1
2
3
5
...
46368
75025

getitem

需要按照下标取出对应的元素，需要实现 __getitem__( ) 方法

如果需要取出特殊切片内容，需要对括号内的内容进行判断，但尚未对 step 参数和负数作处理

class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice): # n是切片
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L

>>> f = Fib()
>>> f[0]
1
>>> f[1]
1
>>> f[2]
2
>>> f[3]
3
>>> f[10]
89
>>> f[100]
573147844013817084101
>>> f[0:5]
[1, 1, 2, 3, 5]
>>> f[:10]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

此外， __setitem__( ) 可以把对象视作 list 或 dict 来对集合赋值， __delitem__( ) 用于删除某个元素

getattr

当调用不存在的属性时， Python 会试图调用 __getattr__(self, '...') 来尝试获得属性，属性在调用时会获得并保持 return 的内容（可以是函数）

例如：

class Student(object):
    def __init__(self):
        self.name = 'Michael'

    def __getattr__(self, attr):
        if attr=='score':
            return 99
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99

只有在没有找到属性的情况下，才调用 __getattr__ ，已有的属性不会调用

一定检查完需要有 raise 报错信息，否则未定义新属性自动在 __getattr__ 中寻找，默认返回 None ，只需要一个 return 就可以处理所有属性

call

任何类，只需要定义一个 __call__ 方法，就可以直接对实例进行调用， __call__ 还可以定义参数

例如：

class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)

>>> s = Student('Michael')
>>> s() # self参数不要传入
My name is Michael.

add & radd

通过定义 __add__ 方法可以定制类的加法，而 __radd__ 定义的则是类位右侧的加法

例如：

class number(object):
    def __init__(self, n):
        self.num = n
    def __add__(self, other):
        if isinstance(other, int):
            return self.num + n
        if isinstance(other, number):
            return self.num + other.num
    __radd__ = __add__

>>> number(1) + 2
3
>>> number(1) + number(2)
3

枚举类

枚举类是用来定义一组固定常量的类型，比单纯用数字或字符串更安全、可读性更好

例如：

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)
Jan => Month.Jan , 1
Feb => Month.Feb , 2
Mar => Month.Mar , 3
Apr => Month.Apr , 4
May => Month.May , 5
Jun => Month.Jun , 6
Jul => Month.Jul , 7
Aug => Month.Aug , 8
Sep => Month.Sep , 9
Oct => Month.Oct , 10
Nov => Month.Nov , 11
Dec => Month.Dec , 12

value 自动赋予成员，默认从 1 开始

如要更精准地控制枚举类型：

from enum import Enum, unique

@unique		#@unique装饰器检查保证没有重复值
class Weekday(Enum):	#继承自Enum
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

>>> day1 = Weekday.Mon
>>> print(day1)
Weekday.Mon
>>> print(Weekday.Tue)
Weekday.Tue
>>> print(Weekday['Tue'])
Weekday.Tue
>>> print(Weekday.Tue.value)
2
>>> print(day1 == Weekday.Mon)
True
>>> print(day1 == Weekday.Tue)
False
>>> print(Weekday(1))
Weekday.Mon
>>> print(day1 == Weekday(1))
True
>>> Weekday(7)
Traceback (most recent call last):
  ...
ValueError: 7 is not a valid Weekday
>>> for name, member in Weekday.__members__.items():
...     print(name, '=>', member)
...
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat

既可以用成员名称引用枚举常量，又可以直接根据value的值获得枚举常量

错误处理

BaseException类的继承和派生

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ExceptionGroup [BaseExceptionGroup]
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── BrokenPipeError
      │    │    ├── ConnectionAbortedError
      │    │    ├── ConnectionRefusedError
      │    │    └── ConnectionResetError
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    ├── PythonFinalizationError
      │    └── RecursionError
      ├── StopAsyncIteration
      ├── StopIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── BytesWarning
           ├── DeprecationWarning
           ├── EncodingWarning
           ├── FutureWarning
           ├── ImportWarning
           ├── PendingDeprecationWarning
           ├── ResourceWarning
           ├── RuntimeWarning
           ├── SyntaxWarning
           ├── UnicodeWarning
           └── UserWarning

Python 学习笔记 (7)：对象属性、slots 与 property

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

对象属性与类约束

dir 函数

dir(x) 可以获取一个对象的所有属性和方法，即该数据的类型可用的前缀和后缀

例如：

x=list()
dir(x)

>>>['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

其中格式为 __...__ 的为前缀，意为特殊变量，可写作 ...(x) 或 x.__...__() ；格式为 ... 的为后缀，意为普通属性或方法，可写作 x. ...()

如果自定的类也想使用特殊变量，可以自定义特殊变量的方法

class MyDog(object):
	def __len__(self):
        return 100

>>> dog = MyDog()
>>> len(dog)
100

使用 getattr() 、 setattr() 以及 hasattr() ，可以直接操作一个对象的状态

例如：

class MyObject(object):
    def __init__(self):
        self.x = 9
    def power(self):
        return self.x * self.x

>>> obj = MyObject()
>>> hasattr(obj, 'x') # 有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19
>>> getattr(obj, 'z') # 获取属性'z'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyObject' object has no attribute 'z'
>>> getattr(obj, 'z', 404) # 获取属性'z'，如果不存在，返回默认值404
404
#获取对象的方法
>>> hasattr(obj, 'power') # 有属性'power'吗？
True
>>> getattr(obj, 'power') # 获取属性'power'
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
>>> fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn
>>> fn # fn指向obj.power
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
>>> fn() # 调用fn()与调用obj.power()是一样的
81

只有在不知道对象信息的时候，才会去获取对象信息

例如：

def readImage(fp):
    if hasattr(fp, 'read'):	#判断该fp对象是否存在read方法
        return readData(fp)
    return None

类属性

可以通过实例变量或者 self 变量给实例绑定属性。如果需要给整个类绑定属性，可以直接在 class 里定义。属性归类所有，而且类的所有实例都可以访问

class Student(object):
    name = 'Student'

>>> s = Student() # 创建实例s
>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
Student
>>> print(Student.name) # 打印类的name属性
Student
>>> s.name = 'Michael' # 给实例绑定name属性
>>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
Michael
>>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
Student
>>> del s.name # 如果删除实例的name属性
>>> print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
Student

相同名称的实例属性将屏蔽类属性。删除实例属性后，再使用相同的名称，访问到的将是类属性

作用

统计学生人数：

class Student(object):
    count = 0

    def __init__(self, name):
        self.name = name
        Student.count += 1

slots 属性

Python是动态语言，对于普通的类，可以为类实例赋值任何属性，这些属性会存储在 __dict__ 中：

>>> class Student(object):
...     pass
...
>>> Abey = Student()
>>> Abey.name = 'Abey'
>>> Abey.__dict__
{'name': 'Abey'}

这样的特性带来两个问题：

1、数据通过字典(Hash)存储所占用的空间较大

2、随意生成类属性（有可能是拼写错误）

示例：

class Vehicle:
    __slots__ = ('id_number', 'make', 'model')

# 注意看下面的书写：
#
# 这是属性的"随意生成"所引发的问题：
# 如果不使用"__slots__"，就会创建一个新的实例属性"id_nubmer"，
# 而代码不会报错。

auto = Vehicle()
auto.id_nubmer = 'VYE483814LQEX'

Traceback (most recent call last):
    ...
AttributeError: 'Vehicle' object has no attribute 'id_nubmer'

slots 就是为了解决这两个问题而设立。通过 slots 属性限定类属性的创建。所以，在应用中，我们只需要记住一个要点：

要用 slots ，父类声明 slots ，子类必须声明 slots ，并且不与父类的 slots 中的属性重复。子类通过继承，它的 slots 为：“自身+父类”

@property 装饰器

由于直接暴露属性无法检查参数是否合法，分别需要 get 和 set 函数来获取和设置合法的属性

例如：

class Student(object):
    def get_score(self):
         return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score()
60
>>> s.set_score(9999)
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

上面的调用方法略显复杂，没有直接用属性这么直接简单，可以使用 @property 装饰器以及配套的 @xxx.setter 装饰器，其负责把一个方法变成属性调用

若不定义 setter 就是一个只读属性

例如：

class Student(object):
    @property
    def score(self):
        return self._score	#属性不能与函数同名，可以在前面加个_

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.score(60)
>>> s.score # OK，实际转化为s.score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

Python 学习笔记 (6)：面向对象基础、继承与 Mixin

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

Object-Oriented Programming

类和示例

class Student(object):	#object表明为基类
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):	#需要self，相当于this指针
        print('%s: %s' % (self.name, self.score))

def print_score2(std):	#可供任何含有name和score属性的实例使用
    print('%s: %s' % (std.name, std.score))

>>> bart = Student('Bart Simpson', 59)
>>> lisa = Student('Lisa Simpson', 87)
>>> bart.name
'Bart Simpson'
>>> bart.score
59
>>> bart.print_score()
Bart Simpson: 59
>>> print_score2(bart)
Bart Simpson: 59

>>> bart.age = 8
>>> bart.age	#可以自定义实例的新属性
8
>>> lisa.age	#同一类的不同实例所拥有的属性可以不一致
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

访问限制

python并不强制约定变量的访问权限，而是用一些约定俗成的命名规则来限制使用。在属性前加上 __ 一般可以视为 private 变量，无法直接从外部访问

可以用于对输入的参数做检查，例如：

class Student(object):
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')

实际上， __ 意为改名，只是将原属性的名称加了个类名前缀

例如将外部的 __name 改为 _Student__name 限制外部的直接访问

写法	含义	是否能访问
`x`	public	随便
`_x`	protected(约定)	可以，但不该
`__x`	private(改名)	强烈不建议

继承和多态

可以让某个类在定义时使其继承某个基类的函数、属性等。判断一个变量是否是某个类型可以用 isinstance() ，判断内容可以使用括号实现多选一为真

可以在括号内写入多个父类可以完成多重继承，子类包含所有父类的属性和功能

例如：

class Animal(object):
    def run(self):
        print('Animal is running...')

class Dog(Animal):	#继承自Animal类
    def run(self):	#重写run函数
        print('Dog is running...')

class Cat(Animal):
    pass	#不重写

>>dog = Dog()
>>dog.run()
Dog is running...

>>cat = Cat()
>>cat.run()
Animal is running...

>>> isinstance(dog, Animal)	#子类的实例也属于基类的类型
True
>>> isinstance(dog, Dog)
True

Mixin

MixIn 是一种设计模式，用于在不使用多重继承的全部复杂性的情况下，为类添加额外功能。本质上是一个专门用于 “被继承” 的类，提供一些通用方法，但自身通常不单独实例化

MixIn 的核心思想

功能复用：将多个类可能共用的功能提取到 MixIn 类中，避免代码重复
职责单一：每个 MixIn 只专注于实现某一类特定功能（如日志记录、序列化等）
组合灵活：通过 “继承” 多个 MixIn 类，一个类可以灵活组合多种功能

为什么需要 MixIn？

Python 支持多重继承，但过度使用可能导致菱形继承问题（多个父类最终继承自同一个基类，引发方法调用歧义）。 MixIn 通过约定（而非强制）解决这个问题： MixIn 类不单独使用，仅作为 “功能补充” 被继承。 MixIn 类通常不定义 init 方法（或设计为可安全继承），避免初始化逻辑冲突。示例：用 MixIn 实现功能组合假设我们需要给不同的类添加 “日志记录” 和 “JSON 序列化” 功能，可以用 MixIn 实现：

# 1. 日志功能 MixIn
class LoggingMixin:
    def log(self, message):
        """打印带时间戳的日志"""
        from datetime import datetime
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] {self.__class__.__name__}: {message}")


# 2. JSON 序列化 MixIn
import json
class JsonSerializableMixin:
    def to_json(self):
        """将对象属性转换为 JSON 字符串"""
        # 假设对象的属性都在 __dict__ 中
        return json.dumps(self.__dict__)


# 3. 业务类：组合多个 MixIn
class User(LoggingMixin, JsonSerializableMixin):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        self.log(f"用户 {self.name} 打招呼")  # 使用 LoggingMixin 的方法
        return f"你好，我是 {self.name}，今年 {self.age} 岁"


# 使用示例
user = User("小明", 18)
print(user.greet())  # 触发日志输出
print(user.to_json())  # 调用序列化方法

输出：

[2023-10-01 12:00:00] User: 用户 小明 打招呼
你好，我是 小明，今年 18 岁
{"name": "小明", "age": 18}

MixIn 的命名约定

为了明确区分普通类和 MixIn 类，通常会在类名后加 Mixin 后缀（如 LoggingMixin、JsonSerializableMixin），让其他开发者一眼看出这是用于混入的功能类

MixIn 与普通继承的区别

特性	普通继承	MixIn 继承
目的	表示 “是一个”（is-a）关系	表示 “具有某种功能”（has-a）
实例化	可单独实例化	通常不单独实例化
方法设计	完整的类逻辑	仅提供特定功能的方法
多重继承风险	高（易引发菱形问题）	低（功能单一，约定明确）

总结

MixIn 是 Python 中实现功能复用和组合的优雅方式，它通过 “混入” 特定功能类，让主类在不增加复杂性的前提下获得多种能力。合理使用 MixIn 可以显著提高代码的复用性和灵活性，尤其适合为不同类添加通用功能（如日志、缓存、序列化等）

Python 学习笔记 (5)：高级特性、模块与常用库

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

高级特性

切片

如果想取 list 或 tuple 的部分元素可以使用切片，所得出的结果依旧是 list 或 tuple

区间范围为 左闭右开 ，同时也可以指定步长

list = [1,2,3,4]
print(list[1:3])
print(list[:2])
print(list[2:])
print(list[0:-1])
print(list[:])
print(list[::2])
print(list[::-1])

>>>[2, 3]
>>>[1, 2]
>>>[3, 4]
>>>[1, 2, 3]
>>>[1, 2, 3, 4]
>>>[1, 3]
>>>[4, 3, 2, 1]

列表生成式

在列表的生成时，可以使用条件和迭代来对生成的内容进行调整

例如生成 1-10 中偶数的平方数：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

其中 for 后面的 if 是对 x 的过滤条件，不可以带 else

下面的用法中 for 前面的 if ... else 是表达式，必须含有 else ，意为满足 if 则执行 if 前的表达式，否则执行 else 后的表达式

[!CAUTION]

不能使用 elif ，当使用嵌套 if ... else 结构

>>> [2 * x if x % 2 == 0 else -x for x in range(1, 11)]
[-1, 4, -3, 8, -5, 12, -7, 16, -9, 20]

生成器（generator）

用于在循环的过程中计算出后续元素，而非直接构造整个列表，节省空间

生成器有两种构造方法：

1. 直接构造

只需把列表生成式的 [ ] 改为 ( ) 即可

例如：

g = (x * x for x in range(10))

2. 函数构造

函数的返回值改为 yield ，且每次调用都从上次的 yeild 处继续

下面是斐波那契数列构造生成器：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

g = fib(6)

[!WARNING]

调用generator函数会创建一个generator对象，多次调用generator函数会创建多个相互独立的generator

因此需要给生成器指定一个变量名，确保每次调用都经由同一个变量名

生成器的元素也有两种迭代方法：

1. `next` 函数

t = triangles()
results = []
for _ in range(10):
    results.append(next(t))

for t in results:
    print(t)


[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

2. `for` 循环

n = 0
results = []
for t in triangles():
    results.append(t)
    n = n + 1
    if n == 10:
        break

for t in results:
    print(t)

#结果同上

杨辉三角构造生成器：

def triangles():
    row = [1]
    while True:
        yield row
        row = [1] + [row[i] + row[i+1] for i in range(len(row) - 1)] + [1]

附录：`Iterable` 和 `Iterator` 的比较

对比点	Iterable	Iterator
能否 for 遍历	✅	✅
能否 next()	❌	✅
是否保存遍历状态	❌	✅
是否一次性	❌	✅
iter(x) 返回	iterator	iterator
记忆点	能“被遍历”的东西	正在“遍历中”的东西

可以使用下面方法判断是否是 iterable 及 iterator ：

from collections.abc import Iterable, Iterator	#注意大写
print(isinstance(..., Iterable))
print(isinstance(..., Iterator))

Modules

编写模块

自己编写模块并放置在不同的 .py 文件中可以有效提高代码的可维护性，避免冲突

可以设置包来管理目录，注意每一个包的目录都需要一个 __init.py__ 文件，可以没有内容

例如：

mycompany
├─ web
│  ├─ __init__.py
│  ├─ utils.py
│  └─ www.py
├─ __init__.py
├─ abc.py
└─ utils.py

可以使用

mycompany.utils
mycompany.web.utils

来代表不同的包

[!WARNING]

自己创建模块时要注意命名，不能和Python自带的模块名称冲突

导入模块

使用 import 可以导入存在的模块，不需要写模块的 .py 后缀

例如：

import module
module.function()

from module import function
function()

前者导入整个模块的所有函数，需要加模块前缀；后者仅导入某个或某些函数，可以直接使用

以具体包的编写为例：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

#文档注释
' a test module '

#作者
__author__ = 'Michael Liao'

import sys

def test():
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')

if __name__=='__main__':	#为主函数时为真
    test()

作用域

变量种类	普通变量	private变量	特殊变量
被外部引用	√	×	√
格式	无	`_` 或 `__` 开头	`__xx__`
例子	`abc`,`x123`,`PI`	`_private1`,`__private2`	`__author__`,`__doc__`,`__name__`

安装第三方模块

在 pypi 官网搜索库的名称，使用 pip install ... 即可

常用库

time

time.time()

获取当前时间戳（秒）

>>> import time
>>> print(time.time())

1713181234.123

含义：

从 1970-01-01 到现在的秒数

time.sleep()

让程序暂停

>>> import time
>>> time.sleep(2)

暂停 2 秒

常用场景：

模拟延迟
控制循环速度
爬虫限速

time.perf_counter()

高精度计时

>>> import time
>>> start = time.perf_counter()
>>> for i in range(1000000):
    pass
>>> end = time.perf_counter()
>>> print(end - start)

28.99913320000087	# 单位为 s

用于：

性能测试
算法计时

time.ctime()

把时间戳转成人类可读格式

>>> import time
>>> print(time.ctime())

Wed Apr 15 20:00:00 2026

time.localtime()

>>> import time
>>> t = time.localtime()
>>> print(t)

time.struct_time(tm_year=2026, tm_mon=4, tm_mday=15, ...)

# 可以拆年月日
>>> print(t.tm_year)
>>> print(t.tm_mon)
>>> print(t.tm_mday)

time.strftime()

把时间变成你想要的格式

>>> import time
>>> print(time.strftime("%Y-%m-%d %H:%M:%S"))

2026-04-15 20:10:00

time.strptime()

把字符串转时间

>>> import time
>>> t = time.strptime("2026-04-15", "%Y-%m-%d")
>>> print(t)

random

random.random()

生成 0 ~ 1 之间的随机小数

>>> import random
>>> print(random.random())

0.3729183	# 范围为 [0.0, 1.0)

random.randint(a, b)

生成整数（包含两端）

>>> import random
>>> random.randint(1, 10)

1 ~ 10（包括10）

random.randrange()

类似 range()

>>> import random
>>> random.randrange(0, 10, 2)	# 区间和步长

0, 2, 4, 6, 8

random.choice(seq)

从列表随机选一个

>>> import time
>>> random.choice(["A", "B", "C"])

"A" 或 "B" 或 "C"

random.choices(seq, k=n)

可重复抽样

>>> import random
>>> random.choices(["A", "B", "C"], k=3)

['A', 'C', 'C']

random.sample(seq, k=n)

不重复抽样

>>> import random
>>> random.sample([1,2,3,4,5], 3)

[2, 5, 1]

random.shuffle(list)

打乱列表

>>> import random
>>> lst = [1,2,3,4,5]
>>> random.shuffle(lst)
>>> print(lst)

[3, 1, 5, 2, 4]

random.uniform(a, b)

生成浮点数范围

>>> import random
>>> random.uniform(1, 10)

3.14159

Python 学习笔记 (4)：列表、字典、集合与元组

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

Lists

列表

列表可以表示为任何结构的集合，如：

整数：[1,2,3]
浮点数：[1.1,1.2,1.3]
字符串：['Peter','Linda','Tom']
混合：[1,1.1,'Peter']
嵌套列表：[1,[2,3],4]
空列表：[] 即为 list()

for 常用于处理列表变量，不论是普通列表，还是字符串或文件句柄

若要表示具体某个元素，可以在列表后加上 [] （从0开始），类似于 C 语言的数组。但是可以直接使用 -1 , -2 等表示倒数第几个元素

+ 和 * 运算符的作用

与字符串类似， + 也可以连接两个列表

* 可以表示重复

例如：

list1 = [1,2]
list2 = [3,4]
list = list1 + list2
print(list)
list *= 2
print(list)

>>>[1, 2, 3, 4]
>>>[1, 2, 3, 4, 1, 2, 3, 4]

迭代

如果想要在列表迭代同时迭代索引，可以使用 enumerate 函数把一个 list 变成索引-元素对，这样就可以在 for 循环中同时迭代索引和元素本身

for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)

>>>0 A
>>>1 B
>>>2 C

Dictionaries

字典

包括键（key）和值（value），用于表示某个键的值，用 {( )} 表示

例如：

cabinet = dict()
cabinet('summer') = 12
cabinet('fall') = 3
cabinet('spring') = 75
print(cabinet)
print(cabinet['fall'])

>>>{'summer': 12, 'fall': 3, 'spring': 75}
>>>3

get 函数

常用 dict_name.get(name,n) （n 为初始值），来对一个列表中出现的键计数

例如：

counts = dict()
names = ['a','b','a','c','b','a']
for name in names:
    counts[name] = counts.get(name,0) + 1
print(counts)

>>>{'a': 3, 'b': 2, 'c': 1}

这段代码的 counts[name] = counts.get(name,0) + 1 可以替换成如下实现方式：

old value = 0
if name in counts :
    oldvalue = counts[name]
counts[name] = oldvalue + 1

编译后可以得出相同结果

key , value 和 items

key 为键，value 为值，item 为项

可以分别使用函数列表提取某一元素

直接输出字典的列表时输出的是键

输出 items 则会出现元组

例如：

jjj = {'a': 3, 'b': 2, 'c': 1}
print(list(jjj))
print(list(jjj.keys()))
print(list(jjj.values()))
print(list(jjj.items()))
for k, v in jjj.items():
    print(k, v)

>>>['a', 'b', 'c']
>>>['a', 'b', 'c']
>>>[3, 2, 1]
>>>[('a', 3), ('b', 2), ('c', 1)]
>>>a 3
>>>b 2
>>>c 1

可以使用两个变量与 item 的键和值一一对应

迭代时不能直接使用 dict ，否则是乱序，需要使用 dict.items、dict.keys、dict.values

Sets

集合

类似 dict 和数学上的集合的结合体，用 { } 表示

可以表示一组 key 的集合，但不储存 value ，而且是无序的

key 如果重复则会重合，不会添加新元素

元素处理

可以使用 add 和 remove 做加减元素的处理

s = {1, 2, 3}
s.add(4)
print(s)
s.remove(4)
print(s)

>>>{1, 2, 3, 4}
>>>{1, 2, 3}

数学性质

set 可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1 & s2)
print(s1 | s2)

>>>{2, 3}
>>>{1, 2, 3, 4}

Tuples

元组

与列表相似，但是赋值后无法修改，占用更小的存储空间，用 ( ) 表示

如果只存储一个列表，且查看完即丢弃不需修改可以创建元组

若元组内存在诸如 list 之类的可变数组，则可改变其中的 list 等

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)

>>>('a', 'b', ['X', 'Y'])

这意味着 tuple 的元素指向不变

只有1个元素的 tuple 定义时必须加一个逗号 , 来消除歧义

例如：

t = (1,)
print(t)

>>>(1,)

可比较性

元组间可以比较大小，比较方式是从左到右依次比较

例如：

print((1,2,3) < (5,2,3))

>>>True

于是可以使用 sorted(dictname.items()) 来进行根据键升序排序，与值无关

附带 reverse=True 可以降序排序

例如：

d = dict()
d['c'] = 3
d['a'] = 7
d['b'] = 2
print(d.items())
print(sorted(d.items()))
print(sorted(d.items(), reverse=True))

>>>dict_items([('c', 3), ('a', 7), ('b', 2)])
>>>[('a', 7), ('b', 2), ('c', 3)]
>>>[('c', 3), ('b', 2), ('a', 7)]

附录：几种储存方式的比较

特性	列表 (List)	元组 (Tuple)	集合 (Set)	字典 (Dictionary)
可变性	可变	不可变	可变	可变
元素类型	任意类型（可包含可变/不可变对象）	任意类型（可包含可变/不可变对象）	必须为不可变对象（可哈希）	键必须为不可变对象，值可为任意类型
有序性	有序	有序	无序	有序
允许重复元素	是	是	否	键唯一，值可重复
语法示例	`[1, 'a', [2]]`	`(1, 'a', [2])`	`{1, 2, 3}`	`{'key1': 10, 'key2': 20}`
适用场景	动态数据集合，需频繁增删改查	固定数据集合（如配置项、常量）	去重、快速成员检查、集合运算（交并差）	键值对映射，快速通过键查找值
是否支持索引	是（`list[0]`）	是（`tuple[0]`）	否	通过键访问（`dict['key']`）
内存占用	较高（因预留空间）	较低（不可变，存储紧凑）	高（哈希表实现）	高（哈希表实现）
底层实现	动态数组	静态数组	哈希表	哈希表

Python 学习笔记 (3)：函数进阶、字符串与文件

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

函数进阶

高阶函数

python 的变量可以指向函数，如 f = abs 即可将 f 指向绝对值函数本身，调用 f( ) 与 abs( ) 并无区别

同样函数名也是变量，若将 abs = 10 ，则无法通过 abs(...) 来调用绝对值函数，因为其指向整数 10

一个函数通过变量名接收另一个函数作为参数，这种函数就称之为高阶函数

例如：

def add(x, y, f):
    return f(x) + f(y)

add(-5, 6, abs)
>>>11

编写高阶函数，就是让函数的参数能够接收别的函数

1. `map( )` 函数

将一个列表内的所有函数经过函数运算后形成新的 iterator ，可以使用 list( ) 直接查看，也可以使用 next( ) 遍历

例如：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

def f(x):
     return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

2. `reduce( )` 函数（需调用 `functools` 模块）

将列表中元素经函数运算的结果继续和序列的下一个元素做累积计算

例如：

from functools import reduce
def fn(x, y):
     return x * 10 + y

>>> reduce(fn, [1, 3, 5, 7, 9])
13579

配合 map( ) 可以完成 str -> int 的转换：

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))

3. `filter( )`

用于筛选处出序列中满足函数值为真的元素

例如：

def is_odd(n):
    return n % 2 == 1

>>>list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
[1, 5, 9, 15]

再如把一个序列中的空字符串删掉：

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
['A', 'B', 'C']

‘A’ -> s 为真，执行 s.strip() 为真值 ‘A‘ ，返回

’’ -> s 为假，短路不返回

None -> s 为假，短路不返回

’ ‘ -> s 为真，执行 s.strip() 为假值空字符串，不返回

可以使用 filter( ) 求素数：

def _odd_iter():
    n = 1
    while True:
        n += 2
        yield n

def _not_divisible(n):
    return lambda x : x % n > 0

def primes():
    yield 2
    it = _odd_iter()
    while True:
        n = next(it)
        yield n
        it = filter(_not_divisible(n), it)	#清除生成器中所有因素含有n的元素

for n in primes():
    if n < 10000:
        print(n)
    else:
        break

4. `sorted( )`

用于排序，可以接收一个关键字为 key 的函数实现自定义排序

排序默认为升序，如需降序排序则需添加 reverse = True 参数

例如：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

闭包

指 函数在定义时捕获并保存其外部作用域中的变量 ，即使外层函数已经执行结束，这些变量仍然可以被访问

def outer(x):
    def inner():
        return x + 1
    return inner
f = outer(10)
print(f())

>>>11

inner 引用了 x

Python 会把 x 保留下来

和 inner 这个函数 一起打包返回

闭包需要满足三点：

有嵌套函数
内层函数使用了外层函数的变量
外层函数返回了内层函数

闭包的用处

1. 延迟计算

def power(n):
    return lambda x: x ** n

#根据实际需要定义几次方的运算
square = power(2)
cube = power(3)

print(square(5))  # 25
print(cube(5))    # 125

2. 保存状态

def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

c = counter()
print(c())  # 1
print(c())  # 2

使用 nonlocal 表明我们要修改的是外层 outer 的 count 变量，而不是在 inner 内部创建一个新的局部变量 count

3. 装饰器

匿名函数

有时候比起显式定义函数，传入匿名函数更加方便

例如：

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

这里的 lambda x: x * x 相当于：

def f(x):
    return x * x

匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f(5)
25

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y	#闭包，与return x * x + y * y相比需再次使用()调用函数才显示结果

装饰器

在函数前通过 @ 调用装饰器，可以使用 func.__name__ 来获取函数的名称

import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

#自定义参数需要多一层嵌套
def log2(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log	#相当于print1 = log(print1)
def print1():
    print('1')

@log2('execute')	#相当于print2 = log('execute')(print2)
def print2():
    print('2')

>>> print1()
call print1():
1
>>> print2()
execute print2():
2

[!TIP]

functools.wraps 用于防止经过 decorator 装饰后的函数的 __name__ 变为 wrapper

偏函数

可以用于定义原函数部分参数固定的新函数

创建偏函数时，可以接收函数对象、*args和**kw这3种参数

以下为接收 *args 和 **kw 的例子：

import functools
max2 = functools.partial(max, 10)	#将10置于函数左端，相当于max(10, *args)

>>> max2(5, 6, 7)	#max(10, 5, 6, 7)
10

import functools
int2 = functools.partial(int, base=2)	#固定int为二进制转换

>>> int2('1000000')
64
>>> int2('1010101')
85

Strings

[ ] 的作用

[ ] 可以直接对 string 的某个元素进行操作（从 0 开始）

例如：

fruit = 'banana'
letter = fruit[1]
print(letter)

>>>a

使用 : 可以表示从某个序号到某个序号（左闭右开）

例如：

fruit = 'banana'
print(fruit[0:4])

>>>bana

: 前面省略为开头（0），后面省略为结尾（len - 1）

Strings 和 for 循环

字符串自身可以作为一个 for 循环的范围，运行时会遍历所有字符元素

例如：

fruit = 'banana'
for letter in fruit :
    print(letter)

>>>b
>>>a
>>>n
>>>a
>>>n
>>>a

+ 运算符的作用

+ 可以连接不同字符串形成新的字符串

例如：

a = 'Hello'
b = a + ' ' + 'world'
print(b)

>>>Hello world

lower 和 upper

我们使用 面向对象 的方式来改变大小写

例如：

str = 'Hello World'
upper = str.upper()
lower = str.lower()
print(upper)
print(lower)

>>>HELLO WORLD
>>>hello world

类似的 string 面向对象用法可参见：

https://docs.python.org/3/library/stdtypes.html#string-methods

列表的等价

当使用 b 列表 = a 列表时，它们代表同一个列表

一个修改后另一个也会变动

a = [1, 2, 3, 4, 5]
b = a
print(a is b)
a[0] = 6
print(b)

>>>True
>>>[6, 2, 3, 4, 5]

f-string

在字符串前加上 f 可以使得引号内部的 { } 可以自动求值，并且输出值的 str( ) 形式

例如：

from fractions import Fraction
half = Fraction(1, 2)

>>> print(f'{half}')
1/2
>>> print(f'2 + 2 = {2 + 2}')
2 + 2 = 4

Files

open 函数

调用 open 函数不会直接读取文件，而是返回文件句柄

例如：

fhand = open('1.txt')	#文件名需要写成字符串形式，或者直接 input 输入，返回值为文件句柄
inp = fhand.read()	#将整个文件写在一个字符串中
for line in fhand :
    #line = line.rstrip()
    print(line)

>>>1
>>>
>>>2
>>>

print 函数会在输出行后再加一行空行，如果不需要该空行可以加上注释中的表达式，意为删去右边的空白内容

在文件中寻找语句

可以用以下方法查找符合某种条件的语句（其中 if 语句和对应的 if not 语句等价）：

fhand = open('1.txt')
for line in fhand :
    if line.startswith('string') :
        ...
    if not line.startswith('string') :
        continue
    if 'string' in line :
        ...
    if not 'string' in line :
        continue

Python 学习笔记 (2)：函数基础与常用内置能力

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

Functions

函数的定义

使用 def 函数名 + :

注意函数的内容要缩进

没有返回值时默认返回 None ，若要提前返回可以 return 或 return None

以下为无参函数例子：

def printsomething() :
    print('Hello,world!')

printsomething()

以下为含参函数例子：

def greet(lang,yes):
    if yes == 1 :
        if lang == 'es' :
            print('Hola')
        elif lang == 'fr' :
            print('Bonjour')
        else :
            print('Hello')
    else :
        print('你好')

greet('es',1)
greet('fr',1)
greet('en',1)
greet('es',0)
greet('fr',0)
greet('en',0)

以下为含返回值函数例子：

def greet() :
    return 'Hello'

print(greet(), 'Peter')

函数名类似于指向一个函数对象的引用，可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”

例如：

a = abs # 变量a指向abs函数
print(a(-1)) # 所以也可以通过a调用abs函数

>>>1

若尚未想好如何写函数的具体代码，可以使用 pass 作为占位符

函数可以返回多个值，返回值是 tuple

返回一个 tuple 可以省略括号，而多个变量同时接收一个tuple，则按位置赋给对应的值

调用外部库函数

在外部库定义的函数可以使用 import 引用该函数

例如：

#file_test.py
def my_abs (x):
    if not isinstance(x, (int, float)):			#可以用内置的isinstance函数对函数接收的数据类型作限定
        raise TypeError('bad operand type')		#raise写入报错内容
    if x >= 0:
        return x
    else:
        return -x

#main.py
from file_test import my_abs	#这是从模块引入某函数的写法
print(my_abs(-99))

import file_test	#这是引入整个模块的写法
print(file_test.my_abs(-99))	#需要模块名前缀

>>>99

函数的默认参数

和 C 语言一样，函数的形参可以默认，但是请注意：

[!WARNING]

默认参数必须指向不变对象

如使用可变对象列表会发生以下问题：

def add_end(L=[]):
    L.append('END')
    return L

>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

这是由于函数调用时会改变 L 自身的内容

此时，可以用 None 这个不变对象来实现：

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

>>> add_end()
['END']
>>> add_end()
['END']

可变参数

在函数的参数前加上 * 可以自主控制输入参数的数量，此时参数接收到的是一个 tuple ，可以使用元组的规则进行数据加工处理

例如求未知数量参数的平方和函数：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

如果可变参数的实参是 list 或者 tuple ，可以在实参前添加 * 使其变为可变参数传入

如：

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

关键字参数

前面的可变参数传入的是元组，如果需要传入含有关键字的参数形成字典，可以使用 ** 开头的关键字参数

同样，若实参输入是字典的话，可以加上 ** 变为关键词参数输入

例如：

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Adam', 45, gender='M',job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

命名关键词参数

只能用关键字传，不能靠位置传的参数

def connect(host, port, timeout, retry):
    pass

调用时很容易看不懂，如 connect("localhost", 3306, 5, 3)

只需要在需要关键字的参数前加上 * 即可强制函数在输入参数时指定关键词

def func(a, b, *, c, d):
    print(a, b, c, d)

func(1,2,c = 3,d = 4)

[!CAUTION]

*args 之后的参数，天然是命名关键字参数

def func(a, *args, b, c):
    print(a, args, b, c)

a：位置参数

args：可变位置参数

b, c：命名关键字参数

type 函数

type(x) 可以获取数据类型

例如：

sval = '123'
type(sval)

>>> <class 'str'>

eval 函数

类似于 f("{ }") ，eval(" ") 可以做到解析字符串，表达式算出结果，变量直接翻译成值

例如：

>>> hello = 'h'
>>> eval("hello")
'h'
>>> eval('1+1')
2

random numbers

需要引入 random 库，然后调用多种函数完成提供伪随机数操作

如 random() 函数随机生成 [0,1) 范围内的数，randint(a,b) 函数随机生成 [a,b] 范围内的整数，choice(listname) 函数随机生成列表范围内的一个数

例如：

import random

for i in range(10):
    print(random.random())
    print(random.randint(5.0,10.0))
    t = range(3)
    print(random.choice(t))

>>>0.25213676975219756
>>>9
>>>1
>>>0.8501875820493452
>>>6
>>>0
>>>0.2062370414825051
>>>9
>>>1

String 类型函数

print 函数

输出函数，注意逗号会直接转换成空格，输出完自动换行

若字符串前含有 r 则表示默认不转移

例如：

print('Hello,','world')
print(r'you')

>>>Hello, world
>>>you

input 函数

输入函数，返回值为字符串，如果需要输入数字，则需要使用类型转换

例如：

name = input('Who are you?')
print('Welcome', name)

len 函数

输出字符串或列表的长度

例如：

fruit = 'banana'
print(len(fruit))

>>>6

replace 函数

可以生成一个将字符串内所有字符转化成别的字符的新字符串

注意！！！原字符串不会发生改变，而是生成一个新的字符串且指定变量指向

例如：

a = 'abc'
b = a.replace('a', 'A')
print(b)
print(a)

>>>'Abc'
>>>'abc'

format 函数

string.format() 是一个字符串格式化函数，用于把变量“填进”字符串里，比拼接字符串更清晰、灵活。

一、基本用法

>>> "Hello, {}".format("Alice")
Hello, Alice

{} 是占位符，format() 里的参数会按顺序填进去。

二、多个参数

>>> "{} is {} years old".format("Alice", 20)
Alice is 20 years old

三、指定位置（索引）

>>> "{1} is {0} years old".format(20, "Alice")
Alice is 20 years old

说明：

{0} → 第一个参数
{1} → 第二个参数

四、使用关键字参数

>>> "{name} is {age} years old".format(name="Alice", age=20)
Alice is 20 years old

五、格式控制

1. 保留小数

>>> "pi = {:.2f}".format(3.14159)
pi = 3.14

2. 对齐

"{:<10}".format("hi")   # 左对齐
"{:>10}".format("hi")   # 右对齐
"{:^10}".format("hi")   # 居中

3. 补零

>>> "{:05d}".format(42)
00042

4. 百分比

>>> "{:.2%}".format(0.256)
25.60%

六、访问数据结构

1. 列表

>>> "{0[0]} {0[1]}".format([1, 2])
1 2

2. 字典

"{name} is {age}".format(**{"name": "Alice", "age": 20})

列表类型函数

可以使用一些函数对列表进行处理

1. 添加元素

append 用于在列表后添加元素

stuff = list()
stuff.append('book')
stuff.append(99)
print(stuff)

['book',99]

insert 用于将元素插到指定位置

classmates = ['Michael', 'Bob', 'Tracy']
classmates.insert(1, 'Jack')
print(classmates)

>>>['Michael', 'Jack', 'Bob', 'Tracy']

2. 删除元素

pop 用于根据序号删除指定元素并返回删除元素
del 用于根据序号删除指定元素
remove 用于根据元素内容删除指定元素（只删除首元素）

list = [1, 2, 3, 4, 3, 4]
pop = list.pop(0)
print(pop)
print(list)
del list[:2]
print(list)
list.remove(4)
print(list)

>>>1
>>>[2, 3, 4, 3, 4]
>>>[4, 3, 4]
>>>[3, 4]

3. sort 用于排列列表

friends = ['Peter','Linda','Tom']
friends.sort()
print(friends)

>>>['Linda', 'Peter', 'Tom']

4. sum , max , min 分别表示总和，最大值和最小值

格式为

sum([], start)	#表示从start开始对list中的内容求和
max([], key = func)	#找到list中使func取最大值时的取值
min([], key = func)	#找到list中使func取最小值时的取值

例如：

>>> max(range(10), key = lambda x: 7-(x-4)*(x-2))
3

5. split 用于分隔字符串生成列表，默认以空格 / 回车为界限分隔，也可备注其他的分隔符号

str = 'Hello world you'
str1 = 'Hello@world@you'
stuff = str.split()
stuff1 = str1.split('@')
print(stuff)
print(stuff1)

>>>['Hello', 'world', 'you']
>>>['Hello', 'world', 'you']

6. join 相当于 split 的反函数，用于将列表元素用分界符连接成字符串

list = ['Hello', 'world', 'you']
delimiter = '-'
result = delimiter.join(list)
print(result)

>>>Hello-world-you

7. all 在 list 中所有值为真时取 True

例如：

>>> all([x < 5 for i in range(5)])
True
>>> all(range(5))
False

Python 学习笔记 (1)：基础语法、条件与循环

Mon, 06 Jul 2026 00:00:00 +0000

返回 Python 学习笔记总目录

Introduction and Elements

Constants(常量)

数字常量即为本身，字符常量需要加 '' 或者 ""

Reserved words (保留字)

Python 自带的一些保留字不能直接作为变量名、函数名或类名。可以先按用途粗略记忆：

类型	常见关键词
布尔与空值	`True`、`False`、`None`
条件与循环	`if`、`elif`、`else`、`for`、`while`、`break`、`continue`
函数与类	`def`、`return`、`lambda`、`class`、`yield`
异常处理	`try`、`except`、`finally`、`raise`、`assert`
导入与作用域	`import`、`from`、`as`、`global`、`nonlocal`
逻辑与成员判断	`and`、`or`、`not`、`is`、`in`
上下文与异步	`with`、`async`、`await`

另外，match 和 case 是模式匹配语法中的软关键字，只在特定语境下具有特殊含义。

Sentences or Lines (语句或行)

语句 x = 2 非数学表达式，意为把常数2存到内存中某个位置并命名为x

Numeric Expressions (数学符号)

+ Addition
- Subtraction
* Multiplication
/ Division
// Quotient
** Power (次方)
% Remainder

None 变量

类似于空变量，在变量无法提前赋值时使用

下例便是利用空变量寻找列表最小值的实现方式：

smallest = None			# 因不确定初始最小值的设置范围，先设为 None 变量
for value in [9,41,12,3,74,15] :
    if smallest is None :		# 使用条件语句讨论为 None 情况并初始化为第一个值
        smallest = value
    elif value < smallest :
        smallest = value
print('最小值为', smallest)

is 的作用

is 的判断要求高于 ==，== 仅要求数值相等，is 同时要求两者指向同一个对象

例如：

0 和 0.0

故在使用时，is 尽量仅用于 None 变量和 Bool 变量，其余均使用 ==

in 的作用

与 for 搭配时可作为循环范围
与 if 搭配时可作为运算符，比如检验某元素是否属于某个列表

布尔逻辑运算符的作用

not 表示否定，常与保留字连用，例如 if not , is not
and 表示和
or 表示或

PS：Python中为明确声明为 global 或 nonlocal 的变量默认为局部变量，例如函数内无法直接调用未显式声明的全局变量

例如：

n = 0
def fun():
	global n	#缺少此句会报错
    n += 1
    return n

复数

用 complex(_ + _j) 来表示一个复数

例如：

a = complex(1 + 2j)
>>> b = 2 * a
>>> b
(2+4j)

Conditionals

if 结构

与C/C++差异的地方为：

缩进代替{ }包含内容
条件语句无括号
条件语句末需要加 :
else if简写为 elif

例如：

if x < 5 :
    if x < 3 :
        print('Too small')
    else:
        print('Small')
elif x < 10 :
    print('Medium')
else :
    print('Large')

match 结构

match 结构类似于 C 语言的 switch 结构

区别如下：

可以按一定格式表示一个区间
表示例外情况使用 case _ （ C 语言为 default ）

例如：

age = 15

match age:
    case x if x < 10:
        print(f'< 10 years old: {x}')
    case 10:
        print('10 years old.')
    case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18:	#case x if x <= 18 and x >= 11:
        print('11~18 years old.')
    case 19:
        print('19 years old.')
    case _:
        print('not sure.')

此外还可以匹配列表

例如：

args = ['gcc', 'hello.c', 'world.c']	#仅匹配gcc开头且含有文件名的列表
# args = ['clean']
# args = ['gcc']

match args:
    # 如果仅出现gcc，报错:
    case ['gcc']:
        print('gcc: missing source file(s).')
    # 出现gcc，且至少指定了一个文件:
    case ['gcc', file1, *files]:
        print('gcc compile: ' + file1 + ', ' + ', '.join(files))
    # 仅出现clean:
    case ['clean']:
        print('clean')
    case _:
        print('invalid command.')

try / except 结构

用于检测结果是否正确，若 try 语句正确执行，则忽略 except 语句。否则将会执行 except 语句

例如：

num = 'Bob'
try :
    num = int(num)
except :
    num = -1
print('First', num)

num = '123'
try :
    num = int(num)
except :
    num = -1
print('Second', num)

>>>First -1
>>>Second 123

由于执行到错误语句后直接转而执行 except 语句，因此错误语句后的正确语句可能造成短路

一个常见应用：

rawstr = input('Enter a number:')
try :
    ival = int(rawstr)
except :
    ival = -1

if ival > 0 :
    print('Nice work!')
else :
    print('Not a number！')

Loops and Iteration

while 循环

条件语句格式与 python 中的 if 语句类似

break 和 continue 的用法与 C 类似

恒为真时使用 True （非0数值均为 True ），反之使用 False

例如:

while True :
    line = input('>')
    if line[0] == '#' :
        continue
    if line == 'done' :
        break
    print(line)
print('Done!')

>>hello
>>>hello
>>#don't print it
>>done
>>>Done!

for 循环

可以设定一个列表为 for 的循环变量范围

如此 for 语句就会依次遍历所有变量然后结束

例如：

for friend in ['Peter', 'Alice', 'Kate'] :
    print("Hello", friend)

也可以提前设置一个列表来作为循环变量范围

例如：

friends = ['Peter', 'Alice', 'Kate']
for friend in friends :
    print("Hello", friend)

range 函数

可以使用 range() 函数实现 for 遍历（左闭右开）

range(stop)	#0 -- stop-1
range(start, stop)	#strat -- stop-1
range(start, stop, step)	#步长为step
range(start, stop, -1)	#可以实现倒数

for _ in range(n):	#不需要使用参数，只需要计数
for i in range(n):	#需要使用参数

Python 数据分析学习笔记

Mon, 06 Jul 2026 00:00:00 +0000

Pandas

Python 的 Pandas 库是用于数据分析的一个常用库，取名自 panel data （即面板数据）的首字母。它可以处理各种文件格式的数据，例如： CSV , JSON, SQL 等等。

常用导入方式：

import pandas as pd

Series 和 DataFrame

Series 类似于表格的一个列，常常只包含一组数据属性和与之相关联的索引。

DataFrame 类似于一个标准的二维表格，既有行索引又有列索引，可以用于选择、过滤、合并等操作。

二者可以这样区分：

类型	数据形态	典型用途
`Series`	一维带索引数据	存放单列数据、标签序列或统计结果
`DataFrame`	二维表格，包含行索引和列索引	存放完整数据集，进行筛选、合并、统计和导出

可以这样创建 Series 和 DataFrame 示例：

import pandas as pd

# 直接用列表来创建 Series
series1 = pd.Series([1,3,5,7])
series2 = pd.Series([2,4,6,8])

# 将两个 Series 组合成 DataFrame，用键值格式指定列的名称
df = pd.DataFrame({ 'Series1': series1, 'Series2': series2 })

print(df)

输出为：

   Series1  Series2
      1        2
      3        4
      5        6
      7        8

Series 在创建时可以使用一些关键字参数来规范，例如 name 可用于命名、index 为列表时可以显式指定索引（若未指定则默认从 0 开始），也可以用字典的方式显式指定索引，例如：

import pandas as pd

data = {
    'x': 'apple',
    'y': 'banana',
    'z': 'cherry'
}

series = pd.Series(data)
print(series)

结果如下：

x     apple
y    banana
z    cherry

DataFrame 也可以使用列表和字典创建：

import pandas as pd

# 二维列表初始化数据，每个子列表都是一个元组
data1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 字典初始化数据，其中键为列名，值为列表
data2 = {
    'x': [1, 2, 3],
    'y': [4, 5, 6],
    'z': [7, 8, 9]
}

# 需要指定列名
dataframe1 = pd.DataFrame(data1, columns=['x', 'y', 'z'])
dataframe2 = pd.DataFrame(data2)

print(dataframe1)
print(dataframe2)

结果均为：

也可以使用关键字参数 name 和 index 来指定名称和索引。

可以使用 set_index 来为 DataFrame 指定某一列为索引：

dataframe.set_index('ID')

下面会主要讨论 DataFrame，但是 Series 也能找到一些共通的方法。

测试时可以选择 head()，内部可以填入想要展示的行数，缺省为 5。

查找元素

对于一个 DataFrame 若要查找指定列的数据，可以用两种方式：

dataframe.attribute
dataframe['attribute']

其后可以加上索引号（如 [0]）来指定取哪行数据。

[!TIP]

更推荐使用后者，以避免属性内部有空格时需要转码。

更标准和多功能的查找方式需要使用 iloc 和 loc，前者主要用于查找位置，后者主要用于查找索引和标签。

[!CAUTION]

这是一个很需要辨析的概念，例如对于下面名为 data 的 DataFrame，使用 loc 和 iloc 会得到不同的结果：

data = {
    'x': [1, 3],
    'y': [2, 4],
}

dataframe = pd.DataFrame(data, index=[1, 0])

print(dataframe.loc[0])  # 按照索引标签获取行，即查找索引为 0 的行
print(dataframe.iloc[0])  # 按照行号获取行，即查找第 0 行

结果为：

x    3
y    4
Name: 0, dtype: int64
x    1
y    2
Name: 1, dtype: int64

二者都可以包含两个参数，其中前者为行，后者为列，而且参数均可以为值或列表（以及切片）：

dataframe.iloc[:, 0]			# 取所有行第 0 列
dataframe.iloc[[0, 1, 2], 0]	# 取前三行第 0 列
dataframe.loc[0, 'country']		# 取索引标签为 0 的行的 country 属性
dataframe.loc[:, ['x', 'y']]	# 取所有行的 x,y 属性列

[!CAUTION]

索引切片和位置切片存在区别，例如 loc 中 0:10 包括 10，但 iloc 中 0:10 只到 9

条件选择：可以使用条件关系式子以及 & 和 | 来选择想要的元组。

dataframe.x == 1 可以单纯输出一个包含索引的布尔 Series，每一行都是 True 或 False，我们可以利用这个特性来完成筛选。

dataframe.loc[(dataframe.x == 1) | (dataframe.x == 2)] 可筛出 x 属性为 1 或 2 的行。

也可以使用 isin 函数进行筛选，例如 dataframe.loc[dataframe.x.isin([1, 2])]。

isnull() 和 notnull() 可以筛选出属性值为空和非空的元组。

Summary Functions

pandas 向我们提供了一些 Summary Functions 来帮助我们重新组织数据。

dataframe.x.describe() 可以给出该列的所有属性。

对于数值属性，可以为总数 count、平均值 mean、最大值 max、中位数 median等等；对于字符属性，可以为总数 count、去重总数 unique、频率最高 top

我们也可以调用具体的函数来获得列的具体属性值，dataframe.x.mean() 直接获取 x 列的平均值，dataframe.y.unique() 和 dataframe.y.nunique() 分别可以得到字符属性的去重后的列表以及去重总数，dataframe.y.value_counts() 可以得到每个值的数目。

Maps

map 和 apply 可以用于对整个 DataFrame 进行某种函数作用，区别是前者的作用对象是其中某一个 Series，生成结果也是 Series；而后者则作用于整个 DataFrame，而且可以在函数中指定一些属性，生成的结果也是 DataFrame。

例如：

x_mean = dataframe.x.mean()

# 作用于 Series
newSeries = dataframe.x.map(lambda p: p - x_mean)

def remean_x(row):
    row.x = row.x - x_mean
    return row	# 也可以 return 具体数值，此时可能结果为 Series

dataframe.apply(remean_x, axis='columns')	# 指定为列，若 axis 为 index，则可以转换索引

数据读写

核心 I/O 函数如下：

读取函数	写入函数	支持格式	典型场景
`pd.read_csv()`	`to_csv()`	CSV、TSV	日志文件、表格数据
`pd.read_excel()`	`to_excel()`	Excel（.xlsx, .xls）	业务报表、财务数据
`pd.read_sql()`	`to_sql()`	SQL 数据库	企业数据库交互
`pd.read_html()`	-	HTML 表格	网页数据抓取
`pd.read_parquet()`	`to_parquet()`	Apache Parquet	大数据分析、存储
`pd.read_feather()`	`to_feather()`	Feather 格式	快速读写、内存数据
`pd.read_json()`	`to_json()`	JSON	API 数据、Web 服务
`pd.read_pickle()`	`to_pickle()`	Python pickle	序列化 Python 对象

后续会继续补充可视化、缺失值处理和分组聚合等内容。

Python 学习笔记目录

Mon, 06 Jul 2026 00:00:00 +0000

(1) 基础语法、条件与循环 常量、保留字、表达式、None、逻辑判断、if、match、异常捕获、while、for 和 range。 (2) 函数基础与常用内置能力 函数定义、模块导入、默认参数、可变参数、关键字参数、type、eval、random、字符串与列表常用函数。 (3) 函数进阶、字符串与文件 高阶函数、map、reduce、filter、sorted、闭包、匿名函数、装饰器、偏函数、字符串操作和文件读取。 (4) 列表、字典、集合与元组 列表操作、迭代、字典 get/items、集合处理、集合数学性质、元组和几种储存方式比较。 (5) 高级特性、模块与常用库 切片、列表生成式、生成器、Iterable/Iterator、模块编写与导入、作用域、第三方模块、time 和 random。 (6) 面向对象基础、继承与 Mixin 类和实例、访问限制、继承、多态，以及用 Mixin 组合可复用功能。 (7) 对象属性、slots 与 property dir、hasattr、getattr、setattr、类属性、__slots__ 和 @property 的用法。 (8) 定制类、枚举与错误处理 __str__、__repr__、__iter__、__getitem__、__getattr__、__call__、枚举类和异常体系。

合肥城墙

Wed, 17 Jun 2026 00:00:00 +0000

这是本人大一上「中国近代史纲要」家乡历史调研论文，现经过一些编排后公布于此，供各位参考 (・ω・)ノ

虽然写的也不好，但现在想起来当时还是比较认真的，可惜现在写的论文能水则水QAQ

合肥城墙

——贯彻近现代的城市防线与历史记忆

合肥，作为安徽省的省会，自古以来便是军事要地，发生过数不胜数的战争，比较著名的便是曹魏同孙吴之间的合肥之战。近代以来，合肥城墙同样在抵御外侮、保护城内居民等方面发挥了重要作用。纵然和平稳定、歌舞升平的现代社会已经使得以战略防御为目的的城墙基本失去了使用价值，然而它们仍旧作为历史不曾泯灭的遗迹屹立在合肥人民的记忆中，雄风不减当年。笔者认为，合肥的城墙不仅是一道物理防线——用于城市防御的重要军事设施，更是一块见证着近现代合肥历史的活化石——承载着合肥记忆的文化符号，在这早已不见其踪影的现代依旧演绎着其不同寻常的时代价值。

合肥最早的城墙可追溯至东汉初年，史称“汉城”。三国时期，魏国大将满宠筑“新城”抵御东吴。唐贞观年间，尉迟恭筑第三座城墙，至宋时基本定型。经过明清两代的修缮和扩建，形成了较为完善的防御体系。

在近代战争中，合肥城墙多次成为抵御外敌的关键设施。其实，合肥古城墙原本共有八个城门，但到了后来只剩下了“威武门”、“时雍门”、“南熏门”、“德胜门”、“西平门”、“水西门”、“拱辰门”这七座城门，本来除此之外还有一座“金斗门”，但后来它是怎么消失的呢？1853年，太平天国军队围攻合肥，城墙发挥了重要作用。据《合肥市志》记载，当时合肥城墙坚固，守将曹银山一度站在城墙之上，用掷地有声的言语鼓舞将士：“城墙在，合肥就在！我们誓与城墙共存亡！”，守军顽强抵抗，使得太平军未能攻破城池，保护了城内居民的生命财产安全。^[1]合肥是军事要地，太平军久攻不下，后来竟然将地道挖到了“金斗门”下，用炸药炸毁了“金斗门”，后人用泥土把那段城门封堵了起来，自此合肥古城墙的“八门”只剩下“七门”了。于是也就有了“庐州城周二十六里，为堞四千五百七十有奇，总七门”的记载了。^[2]

历史的车轮滚滚向前，历史的陈迹也难以抵御近代社会的冲击。随着中华大地上西方火器的普及，传统城墙的战略防御功能逐渐式微，合肥城墙在这一时期同样也经历了由盛转衰的过程。1900年，庚子国变期间，合肥当时的城墙已经无法抵御现代火器的攻击，部分城垛和城楼被毁。^[3]国难之下，侧卧江南大地的合肥城墙又怎能独善其身呢？

抗日战争期间，合肥城墙再次成为抵御外敌的重要防线。1938年，日军进攻合肥，城墙成为守军抵抗日军的重要据点。在合肥保卫战中，守军依托城墙，与日军展开了激烈的战斗。据《安徽抗日战争史》记载，合肥城墙在战斗中多处受损，但它仍然坚守至日军撤退。^[4]在这场可歌可泣的战争史诗中，军民同心和舍生取义的民族精神在历史的竹简上留下了浓墨重彩的一笔：于合肥抗击日军的国民党高级军官张自忠一度在城墙上指挥战斗，面对日军的狂轰滥炸，他发出了铿锵誓言：“即使粉身碎骨，也要保卫家园！”，并号召爱国军民死守合肥城。^[5]战火不仅吞噬了战士，也波及了普通百姓。年仅16岁的合肥少年陈文礼，在抗日战争期间，积极参与城墙的防御工作。在合肥保卫战中，他不顾个人安危，帮助守军搬运弹药和传递情报。在一次日军试图攀越城墙的战斗中，陈文礼勇敢地投掷手榴弹，打退了敌军。他的英勇行为，深深地鼓舞了守军的士气，也成为了合肥城墙上不朽的少年英雄传说。^[6]诸如此类，不可胜数，军民同心御敌的勇气和决心怎能不说是合肥的第二座城墙呢？

然而呢，这座屹立长达千年不倒的坚挺城墙却在建国初期寿终正寝。20世纪50年代，为了新中国的建设，全国范围内大兴拆除古城墙之风，合肥的古城墙也难以幸免，化为一块块砖块淹没在历史的长河中。然而，厚重的城墙一直镌刻在合肥人民的记忆中，代代相传。2024年8月，88岁的老人陈德年捐献了一块古城墙砖给合肥市博物馆。这位老人年轻时曾作为学生参加拆除合肥北城墙的社会劳动，也曾在2019年手绘了一幅“昔日北门双城门”图，对于他来说这块砖和这幅画不仅承载着自己的青春，更承载着合肥的回忆。^[7]

而今，昔日的古城墙已经成为当今在合肥家喻户晓的环城公园，也难怪如今的老合肥人见此情景也未免笑吟一句“昔日环城，郭也；今日环城，公园也！”据称，目前合肥市有关部门正在研究修复古城墙，以期恢复历史风貌。就合肥而言，虽已不具备大规模复建古城墙的基础，也并无必要全盘复古，但恢复部分城墙，再现历史风貌，增添城市景观，忆往昔古风古韵，品陈年风云岁月，也不失为明智之举。

统而言之，合肥城墙不仅是战争的防御工事，更是合肥历史的见证者。它不仅具备战略防御功能，在多次战争中保护了城内居民，展现一位城池守护者的担当；还是一种文化象征，作为合肥的地标，承载着合肥人民的集体记忆，是城市文化的重要组成部分；更起到了历史教育的作用，为后人提供了生动的爱国主义教育素材，激励人们铭记历史、珍爱和平。

若探讨近现代的合肥，为何不从微观视角的一隅城墙开始研究，探究其历史变迁和历史意义，来从宏观上探索整个合肥近现代变迁的奥秘。通过对合肥城墙的研究，我们可以更加深刻地理解合肥在近现代历史中的角色与地位，以及战争与和平对城市和人民生活的深远影响。

📚 参考资料

《合肥市志》，黄山书社，1999 年版
《庐州战守记》，徐子苓（清）
《合肥通史》，安徽人民出版社，2014 年版
《安徽抗日战争史》，安徽人民出版社，2005 年版
《安徽抗日战争史》，安徽人民出版社，2005 年版
《合肥抗战记忆》，安徽人民出版社，2015 年版
《新安晚报》，第 A03 版，2024 年 8 月 8 日

—— 雾汐

✧ 附：AI 蒸馏——鲁迅笔下的合肥城墙 ✧

以下是以鲁迅先生的文风，对上述合肥城墙史料进行文学蒸馏后的再创作。鲁迅杂文特有的冷峭反讽、对”国民性”的洞察以及对历史循环的审视，与城墙这一意象天然契合。此文由 AI 根据原文素材模拟鲁迅笔法生成，仅作风格实验与文学赏玩之用。

合肥城墙

——鲁迅（蒸馏版）

合肥我是去过的，但城墙早已没有了。据说是五十年代拆的，为着建设的缘故。这倒是很合乎逻辑的事——既然要建设新的，旧的便该拆去。然而拆去之后，忽又觉得可惜起来，于是有人主张修复，有人忙着考证，有人在记忆里寻出它的雄姿来。这便是一种精神胜利法罢：亲手毁掉的，偏要在文字里重建，还要说它”雄风不减当年”。

合肥的城墙是有些年头的。从东汉的”汉城”，到三国满宠的”新城”，再到唐尉迟恭的第三座城，历经修修补补，到了明清，总算成了个样子。但样子的意义究竟是什么呢？我疑心古人筑墙，大抵不是为了后人写文章用的。然而后人偏要写，写得还不少。

太平军打合肥的那一回，倒有几分意思。守将曹银山站在城墙上，说：”城墙在，合肥就在！我们誓与城墙共存亡！”这话是掷地有声的，然而后来呢？太平军挖了地道，炸了金斗门——城墙并没有亡，亡的是金斗门。于是八个门剩了七个，史书上便有了”庐州城周二十六里，为堞四千五百七十有奇，总七门”的记载。可见中国的历史，向来是不缺数字的，缺的是问一问这些数字背后究竟发生了什么。

到了庚子年，火器愈发厉害，城墙便开始失去它原本的意义。这原是无可奈何的事——再厚的砖墙，也挡不住炮弹。日本人的飞机来了，张自忠在城墙上指挥，说”即使粉身碎骨，也要保卫家园”。这话也是真的，但城墙并没有粉身碎骨——粉身碎骨的是人。城墙挨了些炮弹，多处受损，然而”坚守至日军撤退”。我于是想，这城墙究竟保护了谁呢？是城里的居民，还是城墙上那些后来被人记在文章里的名字？

还有一位十六岁的少年，叫陈文礼，帮着搬弹药、传情报，还投掷手榴弹打退了攀墙的敌军。文章里说他是”不朽的少年英雄传说”。但我想，他倘若活了下来，后来亲眼看见自己守过的城墙在和平年月里被拆去造了房子，不知道会作何感想。

建国后，城墙终于走到了头。五十年代，全国拆墙，合肥也不能免俗。千年不倒的东西，在和平年代倒了，倒也干脆。拆下的砖去了哪里呢？大抵是砌了别的什么墙，或者铺了路，也未可知。到了2024年，竟有一位八十八岁的老人捐了一块砖给博物馆。他年轻时参加过拆墙的劳动，后来又手绘了一幅城门图。一块砖，一幅画——这便是合肥城墙最后的遗物了。

如今的环城公园，据说就是当年的城墙所在。老合肥人见了，也只好笑笑：”昔日环城，郭也；今日环城，公园也！”这笑里大约有些苦涩，但更多的是无所谓罢。有关部门正在研究”修复部分城墙，再现历史风貌”。拆的时候是为了进步，修的时候是为了文化——两边的理都占尽了。然而修复出来的城墙，还是城墙么？我想大约不过是一件展品罢了。

统而言之——我是不大喜欢”统而言之”的——城墙的事，说来说去，无非是筑墙的人在墙上死了，拆墙的人在墙下老了，后来的人花钱造一座假的，然后拍照留念。这便是历史罢。

然而合肥人自己大约并不觉得。他们走在环城公园里，吹着晚风，偶尔想起这里曾经有过一道墙，但终于也没有多想。

这就很好。

—— 鲁迅（蒸馏版）

Git 常用命令与工作流笔记

Thu, 26 Mar 2026 00:00:00 +0000

git init

初始化仓库

git config --global user.name "..." 
git config --global user.email ...

配置 git 的名称和邮箱

git add <file>

暂存，一键全部暂存时用 .（不推荐）

git commit -m "message"

提交，message 可以规范格式如

[类型] 简短描述

[Feature]：新功能
[Fix]：修补 Bug
[Docs]：仅修改文档/注释
[Refactor]：代码重构（无新功能）
[Art]：美术资源更新

git commit --amend

可以用于修改上一次的 commit

git commit --amend -m ""

写错 message 时可以修改

git add <file>
git commit --amend

git status

查看哪些文件被修改，可以看到工作区修改，也可以看到未提交的暂存区

工作区&暂存区  git diff <file>
工作区&版本库  git diff HEAD <file>
暂存区&版本库  git diff --cached <file>

查看修改的位置

git log (--pretty=oneline)

查看最近三次提交， oneline 简化输出信息

git reflog

可以记录每一次命令及其哈希值

git reset (--hard) (...)

回退版本

--hard：回退到上个版本的已提交状态
--soft：回退到上个版本的未提交状态
--mixed：回退到上个版本的未添加状态
缺省 + <file>：把文件的暂存状态去除

... 可以为哈希值，也可以为 HEAD 的相对地址

HEAD^ 为上一个版本

HEAD~n 为前 n 个版本

git checkout <file>

取消工作区的修改，不论之前是暂存区还是版本库

如果要撤销已暂存的更改可以使用

git checkout <file>
git reset <file>

git checkout -b <branch>
git switch -c <branch>

创建并切换分支

git checkout <branch>
git switch <branch>

切换分支

git branch

查看所有分支

git branch -d(-D) <branch>

删除分支，-D 强制删除，用于删除还没合并的分支

git merge (--no-ff -m "message") <branch>

把 <branch> 分支合并到当前分支，若发生冲突就修改后 add 再 commit

不使用 fastforward 可以使工作流更清晰（推荐）

merge 后可以生成新的 commit，-m 输入信息

git log --graph --pretty=oneline --abbrev-commit

可以可视化分支的提交与合并

git stash

当出现发现前面出现 bug 但当前不方便提交时，可以暂存当前记录

git stash list

可以查看之前暂存的记录

git stash apply stash@{number}

可以恢复该记录

git stash drop stash@{number}

可以删除该暂存记录

git stash pop stash@{number}

上面二者合一，即恢复与删除

git cherry-pick <hash>

可以把某个哈希值做的小修改拿来

git rebase <branch>

使合成到 <branch> 时保持线形

git remote add origin <ssh>

本地关联远程 repo

git clone <ssh>

克隆远程仓库

git fetch

抓取远程分支决定是否合并，可以后面接 rebase

git pull (--rebase)

抓取远程分支，产生 merge 记录

有 rebase 会把提交“放置”在远程拉取的提交之后

解决冲突后需要 git rebase --continue

git push -u origin <branch>

本地库的内容推送到远程，建立新分支，后面只需

git push origin <branch>

git remote -v

查看远程库信息

git remote rm <branch>

可以删除绑定的远程库的分支

[!TIP]

冲突暂停时：

–continue:继续

–abort:放弃整个操作

–skip:跳过有问题的，继续工作

ssh

先在Git Bash / VS Code 终端页面输入指令设置密钥

ssh-keygen -t rsa -b 4096 -C "~~"

绑定到 GitHub 账户 - Settings - ssh

输入 ssh -T git@github.com 查看是否连接上

若连接上即已完成

选择一个合适的文件夹存放远程仓库

远程仓库克隆(clone)

git clone git@gitee.com:username/repositoryname.git [--depth 10]  # 巨型仓库可加深度参数

clone 成功后可以选择需要的分支

设定个人的 email & name

git config --global user.email "~~"
git config --global user.name "~~"

在某个分支上创造新的分支(checkout)并命名

git checkout -b ~~

修改源代码可看到更改

点击暂存

输入消息名称后提交(commit)

发送到云端(push)

回退上次提交代码

git reset --soft HEAD^

强制提交

git push -f

查看当前仓库

git remote -v

添加远程仓库并查看目前所有可用库

git remote add branchname git@gitee.com:username/repositoryname.git  # 建立名为 branchname 的远程别名
git remote -v

提取添加的库

git fetch branchname

git merge 和 git rebase 的区别

场景	推荐命令
自己开发的本地分支想和主分支同步	`git rebase main`
团队多人协作的公共分支	`git merge`
准备提交 PR 前想让历史干净	`git rebase`
保留合并痕迹、完整历史	`git merge`

项目	`cherry-pick`	`squash`
作用	挑出某个提交到当前分支	压缩多个提交为一个
影响范围	跨分支复制提交	当前分支的提交
是否创建新 commit	✅ 是	✅ 是（旧的被合并）
常见用途	热修复、移植单个功能	整理历史、减少提交数
是否保留历史	部分保留（复制）	不保留（被合并）

随笔——简单的 Markdown 学习教程

Wed, 05 Nov 2025 00:00:00 +0000

一、序言

由于本人最近被一些作业折磨得不成人样（也可能单纯是我菜），于是乎，就偷来一些闲暇时光，写了这个简单的教程，当然也是为了让我自己加深记忆啦。

本人曾经发布过一个 Markdown 的自学文档，但那个文档主要是出于本人遗忘某些功能时的参考，并没有任何教学内容，发出来也仅仅是为了做本博客的文章测试。所以现在偷闲写一篇，尝试给看到这篇文档的大家一些小小的收获，由于我也是个小白，难免会有纰漏，如果发现的话可以在评论区向我指出哦，请大佬勿喷（哦捏噶依=w=）。

Markdown 格式的文档，若非经常与电脑打交道的朋友可能不甚了解，但是这丝毫无法掩盖其作为一个语法简单、排版方便、观感美观的格式被大家所使用。相比起更广为人知的 Word 等其他文本格式，Markdown 可能因为其功能的语法导向和非可视化，在刚上手和某些格式的控制功能上有些许的困难。然而其又比 Word 的精通，以及更严谨的 LaTeX 语言的操作上更为便利，对于简单的文档写作任务比如做笔记、写技术文档、做清单、给他人评论等工作性价比相对较高。所以，学习一门门槛不高的语言并不需要耗费太多时间，但益处还是不小的，你说呢？

所以，不论你是一位刚入门 CS 的计算机小白，还是一位仅仅想将其作为一项写作技能的朋友，如果你有意向学习这门轻量级标记语言，可以耐心地把这篇文档看完（我相信它不会很长QAQ），你一定可以入门这门语言！

出于排版的需要，我会给大家拓展一些简单的 HTML 语法来完成更多的一些功能，大家有需要可以学习，如果已有的语法功能已足以胜任，那就可以跳过相关内容哦。

本文档演示的内容主要使用 Typora 和 Visual Studio Code 写成，但会考虑到兼容性，让大家见到较为通用的 Markdown 文本语法。不同的 Markdown 编辑器支持的功能会有所差异，所以我会比较推荐大家使用 Typora。Typora 是一个较为通用的 Markdown 编辑器，支持 Windows、Mac、Linux 平台，有良好的兼容性，并且支持很多拓展语法。大家初学的时候可以尝试下载 Typora 作为入门，相信很快就可以熟悉操作！

那么，让我们入门 Markdown 的世界吧！

二、字体格式

首先我们从字体格式的控制开始，我们在做笔记的时候难免会有需要着重强调某些内容的需求，此刻我们根据美观和需求可能会选择几种标记字体的样式，比如加粗、斜体、下划线等。那么在 Markdown 中，我们如何实现这些字体格式的控制呢？

斜体和加粗

在 Markdown 中，我们使用不同数量的 * 来完成斜体和加粗等操作，比如：

*斜体内容* 效果 -> 斜体内容
**加粗内容** 效果 -> 加粗内容
***斜体加粗内容*** 效果 -> 斜体加粗内容

当你输入四个 * 时就不会有任何作用啦。

线型标注

当你需要使用下划线划重点时，你会发现 Markdown 并不存在相关的原生语法。那么我们是不是就望而却步了呢？

这就不得不提 Markdown 的另一个重要优势了——支持多种 HTML 语法。HTML 是一种用途极为广泛的标记语言，我们所见到的大多数网站的框架基本都是通过 HTML 构建的。

所以，我们可以通过 HTML 标签来实现下划线标注，HTML 下划线标签的语法是：

<u>请把下划线内容夹在中间</u>

例如：

<u>这里需要下划线=w=</u>

效果如下:

这里需要下划线=w=

是不是很简单呢？恭喜你也学会了 HTML 标签的使用，很多的 HTML 样式都类似于这种格式！

Markdown 不存在下划线原生语法，但是幸运的是，它支持删除线的语法，语法如下：

~~删除线内容~~

例如：

~~这里需要删除线=w=~~

效果如下：

~~这里需要删除线=w=~~

其他字体格式

Markdown 还支持其他字体格式，我们可以用高亮（仅限一些编辑器支持，如 Typora）来做强调：

==高亮内容==

例如：

==这里需要高亮=w===

效果如下：

这里需要高亮=w=

在排版数学公式和化学式中，我们需要用到上标和下标，语法如下：

这是^上标^

例如：

4\^2^=16

效果如下：

4²=16

如果你查看此处源码的话，会发现此处我使用的是 HTML 的写法，实际上 Markdown 也支持这种写法。由于 ^ 这种符号并非所有地方均适用，比如在博客展示的页面，所以这里用 HTML 写法来保证效果。

同样的，我们也可以使用下标：

这是~下标~

例如:

水的化学式为H~2~O

效果如下：

水的化学式为H₂O

至此，你已经学习了相当一部分 Markdown 字体控制的格式啦！赶快去实战试试吧！

三、列表和表格

Markdown 的列表按照实际用途可以分为三种：无序列表、有序列表和任务列表。

应该不需对各种列表进行说明，大家看看效果自然就知道用在什么地方了。

无序列表

无序列表格式只要在每个前面加上 + 、 - 或 * 均可，如果没有转化可以再加一个空格，例如：

+ 无序列表1
+ 无序列表2
+ 无序列表3
- 无序列表4
* 无序列表5

效果如下：

无序列表1
无序列表2
无序列表3
无序列表4
无序列表5

你应该发现了，使用不同符号会被判定成不同的无序列表哦，使用时需要注意一下。一般来说，我们可以一致使用 + 作为同一个无序列表的符号，因为 - 不易区分，而 * 也容易与斜体弄混。

有序列表

有序列表格式则需要在每个前面加上数字和一个英文句号加空格 . ,例如：

1. 有序列表1
2. 有序列表2

效果如下：

有序列表1
有序列表1

任务列表

任务列表则需要在每个前面加上 - [ ] 或 - [x] 来表示未完成和已完成的任务，例如：

- [ ] 未完成1
- [ ] 未完成2
- [x] 已完成
- [ ] 未完成3

效果如下：

未完成1
未完成2
已完成
未完成3

任务列表有个很有趣的点，当你点一下预览模式或者 Typora 的未完成的框，它会自动将未完成的任务前面加上一个勾，方便你跟踪任务进度。同理，已完成的任务也可以点击取消。

自动目录

Typora 有个功能可以快速实现目录来清晰地显示多级标题，通过输入 [TOC] 来实现。大家可以在 Typora 中尝试，请注意这个功能并不是任何编辑器均支持。

表格

Markdown 也支持表格的语法，语法如下：

| 表头1 | 表头2 | 表头3 |
| --- | --- | --- |
| 单元格1 | 单元格2 | 单元格3 |
| 单元格4 | 单元格5 | 单元格6 |

效果如下：

表头1	表头2	表头3
单元格1	单元格2	单元格3
单元格4	单元格5	单元格6

表格的语法比较复杂，这里只是举个例子。标准 Markdown 表格不支持合并单元格、跨行跨列；这些复杂样式通常需要借助 HTML 表格或编辑器扩展来实现。如果你使用的是 Typora，你会发现有更简单的方法创建表格。

四、引用

如果你在做笔记时，觉得某句话很有道理，想把它引用到自己的笔记中，但是害怕和别的内容搞混，想保持原文的特殊性。Markdown 贴心地提供了特殊的引用方式。用法很简单，只需要在引用的内容前加上 > 即可，例如：

长风破浪会有时，直挂云帆济沧海。

引用也可以完成嵌套操作，只要在 > 中再输入一个 > 即可。

特殊标签

GitHub、Obsidian 等 Markdown 环境支持一些提示鲜明的特殊标签效果，其格式基本一致，为 > [!XXXX]，XXXX 内容为你所要使用的特殊标签的全字母大写形式，例如：

提醒

[!NOTE]

> [!NOTE]

警告

[!WARNING]

> [!WARNING]

注意

[!CAUTION]

> [!CAUTION]

提示

[!TIP]

> [!TIP]

重要

[!Important]

> [!Important]

通过这些标签的运用，可以使排版更加好看，也能让你写的文章的读者更容易地抓住重点和细节。

五、代码和公式

Markdown 的一大优势就是它支持了最基本的程序和数学排版需求。在不那么严格的排版要求下，不仅学习门槛极低，还可以给读者良好的阅读体验。

行内代码

如果你想在一句话中插入一句代码或者一些特殊的名词，可以尝试使用一对反引号 ` `（位于 Esc 键下方、Tab 键上方）来包裹行内需要引用的代码，例如：

你可以尝试在 python 解释器中输入 print('Hello, world!') 来完成你的第一个程序。

代码块

如果想要引用大量代码，肯定无法再行内完成。这时，可以尝试使用代码块。代码块不仅能够排版代码，还能够适应不同的编程语言给予高亮。而使用方法也很简单，在代码前后各放一行三个反引号 ``` 即可；如果想要定制特定编程语言的高亮风格，可以在第一行 ``` 后写上相应的语言名称。例如：

python：

print('Hello, world!')

C：

#include <stdio.h>

int main(){
    printf("Hello, world!");
}

C++：

#include <iostream>
using namespace std;

int main(){
    cout << "Hello, world!" << endl;
}

Java：

public class main{
    public static void main(String[] args){
        System.out.println("Hello, world!");
    }
}

诸如此类，Markdown 还支持各种各样的编程语言，甚至于你还可以尝试输入 bash、text！

诞日漫步览雪感怀

Sat, 03 Feb 2024 00:00:00 +0000

诞日漫步览雪感怀

by 雾汐（低配版）

年辰故迹久临门，殆烦青简辗时轮。
细细妍灵娇娇舞，纷纷袅玉清清吟。
横霄容与霜浥襟，倚柯流眄芳拢心。
相识何必初雪日，风撩絮撒更思君。

芝士雾汐

如何读论文

1. 引子

2. 论文结构

3. Pass 1

4. Pass 2

5. Pass 3

6. 补充

6.1 关于 Appendix（附录）

6.2 工具

6.3 英语问题

7. 总结

我做了一个交互式 Diffusion 学习网站

为什么不是再写一份论文笔记

从一张图怎样变成噪声开始

把训练和采样彻底分开

公式不能只负责看起来很厉害

从公式走到一份最小 PyTorch 实现

不把后续工作都算到 DDPM 头上

目前完成的学习闭环

Python 学习笔记 (8)：定制类、枚举与错误处理

定制类、枚举与错误处理

定制类

__str__ 和 __repr__

__iter__ 和 __next__

__getitem__

__getattr__

__call__

__add__ & __radd__

枚举类

错误处理

Python 学习笔记 (7)：对象属性、slots 与 property

对象属性与类约束

dir 函数

类属性

__slots__ 属性

@property 装饰器

Python 学习笔记 (6)：面向对象基础、继承与 Mixin

Object-Oriented Programming

类和示例

访问限制

继承和多态

Mixin

Python 学习笔记 (5)：高级特性、模块与常用库

高级特性

切片

列表生成式

生成器（generator）

1. 直接构造

2. 函数构造

1. next 函数

2. for 循环

杨辉三角构造生成器：

附录：Iterable 和 Iterator 的比较

Modules

编写模块

导入模块

作用域

安装第三方模块

常用库

time

time.time()

time.sleep()

time.perf_counter()

time.ctime()

time.localtime()

time.strftime()

time.strptime()

random

random.random()

random.randint(a, b)

random.randrange()

random.choice(seq)

random.choices(seq, k=n)

random.sample(seq, k=n)

random.shuffle(list)

random.uniform(a, b)

Python 学习笔记 (4)：列表、字典、集合与元组

Lists

列表

str 和 repr

iter 和 next

getitem

getattr

call

add & radd

slots 属性

1. `next` 函数

2. `for` 循环

附录：`Iterable` 和 `Iterator` 的比较

1. `map( )` 函数

2. `reduce( )` 函数（需调用 `functools` 模块）

3. `filter( )`

4. `sorted( )`