浅析递归“经典”框架，领略递归优雅秀气。看到有“递归算法优化”的操作，余试剖之。

【学习的细节是欢悦的历程】

Python 官网：https://www.python.org/
Free：大咖免费“圣经”教程《 python 完全自学教程》，不仅仅是基础那么简单……
地址：https://lqpybook.readthedocs.io/

自学并不是什么神秘的东西，一个人一辈子自学的时间总是比在学校学习的时间长，没有老师的时候总是比有老师的时候多。
—— 华罗庚

My CSDN主页、My HOT博、My Python 学习个人备忘录
好文力荐、老齐教室

浅析递归“经典”框架，领略递归优雅秀气 “递归三要素”寻踪 (看到有“递归算法优化”的操作，余试剖之。)

本文质量分：

【 91 】本文地址： https://blog.csdn.net/m0_57158496/article/details/130371068

CSDN质量分查询入口：http://www.csdn.net/qc

目录

◆ “递归三要素”寻踪
- 1、“递归要素”概念
- - 1.1 百科词条中的“递归要素”
  - 1.2 题目中的“递归要素”
  - 1.3 博文中的“递归要素”
  - 1.4 “递归已死”？递归没有死！！
- 2、递归的“经典”案例
- - 2.1 阶乘
  - - 2.1.1 阶乘概念
    - 2.1.2 递归代码
    - 2.1.3 炼码
  - 2.2 裴波拉契数列
  - - 2.2.1 概念
    - 2.2.2 递归代码
    - 2.2.3 炼码
  - 2.3 1～n 的自然数序列求和
  - - 2.3.1 求和代码
    - 2.3.2 炼码
- 3、图解递归算法
- 4、递归的“优化”
- - 4.1 “算法优化”
  - 4.2 “代码优化”
  - 4.3 循环改写递归
  - 4.4 递归“优化”感悟
- 5、完整源码

◆ “递归三要素”寻踪

1、“递归要素”概念

1.1 百科词条中的“递归要素”

递归百科词条描述：

“递归”是程序调用自身的编程技巧。
程序调用自身的编程技巧称为递归_{( recursion )}。递归作为一种算法在程序设计语言中广泛应用。
一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

_{(点击递归蓝色文字跳转百科词条，了解更多)}

回页目录

1.2 题目中的“递归要素”

一、选择题

递归三要素包括 ( )
A. 递归前进段 B. 递归中间段
C. 递归出口 D. 递归返回段

答案：A、C、D

二、填空题

递归的要素：________ 是递归的重要组成部分，________ ，她保证递归能在 ________ 的计算后得出结果，而不会产生 ________ 的情况。

【解析】本题考查递归思想。
程序调用自身的编程技巧称为递归(recursion)。递归作为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。递推关系是递归的重要组成部分，边界条件，她保证递归能在有限的计算后得出结果，而不会产生无限循环的情况。

解答：递推关系、边界条件、有限、无限循环

----=== 以上题目来自“夸克搜题” ===----

回页目录

1.3 博文中的“递归要素”

1、确定递归函数的参数和返回值
确定递归过程中需要处理的参数，明确每次递归的返回值，进而确定递归函数的返回类型。

2、确定递归终止条件_{(即函数 return 的出口)}
终止条件写的不对，操作系统的内存栈一定会溢出，毕竟递归深度也是有限制的_{( Python 3.11 的递归深度限制默认是 1000 ，可以在程序中用指令重置)}。

3、确定单层递归的逻辑
明确每次递归要进行什么操作。

博文地址：https://blog.csdn.net/weixin_44484715/article/details/113461398

第一要素：明确函数作用

第二要素：递归结束条件

第三要素：函数等价关系

博文地址：https://blog.csdn.net/feng8403000/article/details/121797194

第一要素：明确你这个函数想要干什么
这个不言而喻，要是连函数要干啥子都不晓得，还写啥子代码哦。😊

第二要素：寻找递归结束条件
所谓递归，就是会在函数内部代码中，调用这个函数本身。所以，我们必须要找出递归的结束条件。不然的话，会一直调用自己，进入“无限循环”的深渊。也就是说，我们需要找出当参数为啥时，递归结束，然后返回结果。请注意，这个时候我们一定是可以根据这个参数的值，能够直接知道函数的结果是什么的。_{(只要你觉得参数是什么时，你能够直接知道函数的结果，那么你就可以把这个参数作为结束的条件)}

第三要素：找出函数的等价关系式
我们要不断缩小参数的范围，缩小之后，我们可以通过一些辅助的变量或者操作，使原函数的结果不变。

博文地址：https://blog.csdn.net/weixin_42112224/article/details/119416330

回页目录

1.4 “递归已死”？递归没有死！！

齐伟老师在他的开源🆓教程《 python 完全自学教程》中，对递归有其独到之观点。

递归，不是代码程序的必需，通常可以被循环替换

其实，在大多数情况下，编程中可以不用递归，即递归通常是不必须的——所以会有“递归已死”的观点。

教程截屏图片
在程序代码中要谨慎使用递归

用简短的语言概括递归：对自身的调用。

最后要强调，递归并非对所有的任务都适用。如果递归能够让程序的可读性非常好，这时应该毫不犹豫地使用——递归没有死。如果与循环等相比较，递归并没有显示出很高的可读性，那么就要谨慎从事了，它毕竟牺牲了执行速度并占用了更多内存。

教程截屏图片

🆓地址：https://lqpybook.readthedocs.io/

齐老师此教程虽言“ Python 基础教程”，但却不仅仅是“基础”哦！😊

回页目录

2、递归的“经典”案例

递归之要素，即是递归之特征——递推关系、边界条件——没有对任务提炼出一步步缩小任务问题范围得出结果的递推关系，就无法通过不断调用自身完成任务；代码中不设定递归结束的边界条件，“调用自身”的工作将“无限”重复，直到程序编译环境设置的递归深度限制，抛出报错信息。程序有其特征，才是“递归”；“项目”有其特征，才适用“递归算法”。

据其特征要素，编排递归算法之代码，事半功倍减少差错，降低 bug 出现机率，轻松愉悦敲代码。

下面我将用“阶乘”、“裴波拉契数列”和“正整数序列求和”三个递归“经典案例”浅析递归代码“生成”步骤，让我们共识之。

2.1 阶乘

2.1.1 阶乘概念

阶乘_{( factorial )}概念

阶乘是基斯顿·卡曼( Christian Kramp，1760～1826 )于 1808 年发明的运算符号，是数学术语。一个正整数的阶乘_{( factorial )}是所有小于及等于该数的正整数的积，并且 0 的阶乘为 1 。自然数 n 的阶乘写作 n! 。1808年，基斯顿·卡曼引进这个表示法。任何大于等于1 的自然数n 阶乘表示方法：

n! = 1 × 2 × 3 × … × (n - 1) × n
或
n! = n × (n - 1)!

0 的阶乘：0! = 1

定义的必要性：由于正整数的阶乘是一种连乘运算，而 0 与任何实数相乘的结果都是 0 。所以用正整数阶乘的定义是无法推广或推导出 0! = 1 的。即在连乘意义下无法解释“ 0! = 1 ”。

给“ 0! ”下定义只是为了相关公式的表述及运算更方便。

2.1.2 递归代码

我们严格按“递归框架”来：

一、递归函数作用——代码要干啥—— 求 n! 。

二、递归结束条件——“边界条件”—— n = 1 时 n! = 1 。

三、递归函数等价关系——“递推关系”—— n × (n - 1)! —— n 乘以 (n - 1) 的阶乘。

根据“框架”出代码：


def factorial_n(num: int) -> int:''' 递归 计算 n! ''' # 函数作用。if num == 0: # 递归终止条件。return 1return num * factorial_n(num-1) # 递归函数等价公式 n × (n-1)!。

除了函数名称定义和功能说明，实际代码就三条语句，递归函数真是“简洁明了”！

2.1.3 炼码

试求 4 和 8 的阶乘：


if __name__ == '__main__':for i in (4, 8):print(f"\n整数 {i}! = {factorial_n(i)}")

代码运行效果截屏图片

由截屏图片可以看到，前面的“三行代码”递归函数代码无疑是正确的。
for 循环和“三元操作”的求 n!


def factorial_n(num: int) -> int:''' 递归 计算 n! (三元操作)'''return 1 if num == 0 else num * factorial_n(num-1) # 用三元操作语句改写。


def factorial_n(num: int) -> int:''' 递归 计算 n! ( for )'''result = 1for i in range(1, num+1):result *= ireturn result

回页目录

2.2 裴波拉契数列

2.2.1 概念

斐波那契数列( Fibonacci sequence )，又称黄金分割数列，因数学家莱昂纳多·斐波那契( Leonardo Fibonacci )以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……

在数学上，斐波那契数列以如下递推的方法定义：F(0)=1，F(1)=1, F(n)=F(n - 1)+F(n - 2) ( n ≥ 2，n ∈ N* )

在现代物理、准晶体结构、化学等领域，斐波那契数列都有直接的应用，为此，美国数学会从 1963 年起出版了以《斐波那契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。

2.2.2 递归代码

我们严格按“递归框架”来：

一、递归函数作用——代码要干啥—— 求裴波拉契数列第 n 项。

二、递归结束条件——“边界条件”—— n = 0、1 时 F(n) = 1 ，即裴波拉契数列前两项都是 1 。

三、递归函数等价关系——“递推关系”——从第三项起，每项的值是紧邻前两项之和，即 F(n) = F(n-1) + F(n-2)。

根据“框架”出代码：


def fib3(n: int) -> int:''' 求裴波拉契数列第 n 项 '''if n < 3: # 递归结束条件——递归边界条件—— n = 0/1/2 。return 1 if n in (1, 2) else 0return fib(n-1) + fib(n-2) # 函数等价关系——递推关系公式—— 当前项 = 前两项和 。

求裴波拉契数列第 n 项值的函数，还是仅用三行代码，即可求得。

2.2.3 炼码

试求裴波拉契数列第 3、5、8 项的值以及列表解析出前 35 项的值：


if __name__ == '__main__':for i in (3, 5, 8):print(f"\n裴波拉契第 {i} 项是：{fib(i)}")input(f"\n裴波拉契数列前 35 项： \n{[fib(i) for i in range(35)]}")

代码运行效果截屏图片

回页目录

2.3 1～n 的自然数序列求和

2.3.1 求和代码

我们严格按“递归框架”来：

一、递归函数作用——代码要干啥—— 求自然数序列总和。

二、递归结束条件——“边界条件”—— n = 1 时总和为 1 。

三、递归函数等价关系——“递推关系”—— n + (n - 1)序列总和。

根据“框架”出代码：

def recur_n(num: int) -> int:''' 递归 计算 1～n 的和 '''if num == 1:return 1 # 递归结束条件——递归边界条件。return num + recur_n(num-1) # 函数等价关系——递归递推关系公式。

1～n 的自然数序列求和，也是仅用三条代码语句，就能搞定。

2.3.2 炼码

试求 1～10 、1～100 的总和：


if __name__ == '__main__':for i in (10, 100):print(f"\n 1～{i} 的总和是：{recur_n(i)}")

代码运行效果截屏图片
for 循环、sum()和“三元操作”的求 1～n 的总和

def recur_n(num: int) -> int:''' 递归 计算 1～n 的和 '''return 1 if num == 1 else num + recur_n(num-1) # 用三元操作语句改写。


def factorial_for(num: int) -> int:''' 乘积计算 n! '''multiple = 1for i in range(1, num+1):multiple *= i    return multiple


def sum_n(num: int) -> int:''' sum() 计算 1～n 的和 '''return sum(range(1, num+1))

回页目录

3、图解递归算法

以求裴波拉契数列第6项为例，说明递归算法的“递推”——递归前进段、“回归”——递归返回段过程。
第6项的值是第5项与第4项值之和，第5项的值是第4项和第3项值之和，以此类推到第3项的值是第2项和第一项值的和，第一、二项已知值为1，到达“递归出口”——边界条件，不再向下递推，开始回归，依次返回已知值，求得第6项值为8。如下图：

图解递归算法

代码


def fib(n: int) -> int:''' 求裴波拉契数列第 n 项 '''return 0 if n < 1 else 1 if n < 3 else fib(n-1) + fib(n-2)if __name__ == '__main__':print(f"\n{' 求裴波拉契数列第 n 项 ':~^41}\n\n")for i in range(7):print(f"{'第':>18} {i} 项是 {fib(i):>6} ")input(f"\n\n{'':~^50}")

代码运行效果截屏图片

回页目录

4、递归的“优化”

下面，我用“求裴波拉契数列第 n 项”来浅析“递归优化”，分别列举算法优化和代码优化，并打印出在相同环境求相同项数所用时间，以此窥其“优劣”。

4.1 “算法优化”

有人用数组存储递推结果，减少重复递推计算，大大提高递归算法效率。其实还可以用 Python 字典 dict 来存储，也是即为方便的。

下面以求裴波拉契数列第 n 项值为例，演示“递归算法优化”。经过“优化”，有效减少重复递推计算，能轻松算出第 1000 值。

数组 list 存储


def fib4(n: int) -> int:''' 求裴波拉契数列第 n 项(数组存储递推结果) '''if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0a = b = 0if not lis[n-1]:lis[n-1] = fib(n-1)else:a = lis[n-1]if not lis[n-2]:lis[n-2] = fib(n-2)else:b = lis[n-2]if a and b:return a + belif a and not b:return a + fib(n-2)elif not a and b:return fib(n-1) + bprint()return fib(n-1) + fib(n-2)

代码运行效果截屏图片
字典 dict 存储


def fib(n: int) -> int:''' 求裴波拉契数列第 n 项(字典存储递推结果) '''if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0keys = list(nums.keys())if n-1 in keys and n-2 in keys:return nums.get(n-1) + nums.get(n-2)elif n-1 in keys:temp = fib(n-2)nums[n-2] = tempreturn nums.get(n-1) + tempelif n-2 in keys:temp = fib(n-1)nums[n-1] = tempreturn nums.get(n-2) + tempcurrent = fib(n-1) + fib(n-2)nums[n] = currentreturn current

代码运行效果截屏图片

4.2 “代码优化”

虽然递归代码已经够少了，但还可以用“ 三元操作符”粘接成一条语句。😋

_{(可以点击蓝色文字跳转我的学习笔记，了解更多 Python 三元操作符)}

阶乘


def factorial_n(num: int) -> int:''' 递归 计算 n! '''return 1 if num == 0 else num * factorial_n(num-1) # 用三元操作语句改写。

裴波拉契数列


def fib(n: int) -> int:''' 求裴波拉契数列第 n 项 '''return 1 if n in (0, 1) else fib(n-1) + fib(n-2) # 用三元操作语句改写。

代码运行效果截屏图片

自然数序列求总和


def recur_n(num: int) -> int:''' 递归 计算 1～n 的和 '''return 1 if num == 1 else num + recur_n(num-1) # 用三元操作语句改写。

回页目录

4.3 循环改写递归

由代码运行时间可以看出，Python 的 for 循环是要优于 while 的——代码更简洁紧凑，运行时间会略短。

for 循环


def fib(n: int) -> int:''' 求裴波拉契数列第 n 项( for 循环) '''a = b = 1 # 当前项前两项初值。if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0for i in range(3, n+1):current = a + ba = bb = current # 更新当前项前两项值。return current

代码运行效果截屏图片
while 循环


def fib(n: int) -> int:''' 求裴波拉契数列第 n 项( while 循环) '''if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0a = b = 1 # 当前项前两项初值。k = 3while k <= n:current = a + ba = bb = current # 更新当前项前两项值。k += 1return current

代码运行效果截屏图片

回页目录

4.4 递归“优化”感悟

由一系列“优化”操作试炼后得出：

我用递归，就希罕她的苗条妖娆

用数组存储递推结果，大大加快了代码执行速度，但 代码稍显冗长，“算法”有点儿费理，这却与递归本来的“清爽”样子背道而驰。for 循环的写法，“性能”几乎与算法“优化”的递归一致，但代码却也是不太输“清秀”递归。

所以，在符合递归的场景，放手递归，别想着去“优化”；当场景能轻易被 for 替代，绝不拖泥带水——果立决！

如果不是特别需要“三元操作”的计算返回值，尽量少用。它会让您的代码相对“难读”，特别是用了嵌套的“三元操作”，虽然写起来我感觉非常爽。
在这里插入图片描述

回页目录

5、完整源码

(源码较长，点此跳过源码)

#!/sur/bin/nve python
# coding: utf-8
from time import time### 求裴波拉契数列第 n 项def fib(n: int) -> int:''' 求裴波拉契数列第 n 项 '''return 0 if n < 1 else 1 if n < 3 else fib(n-1) + fib(n-2)if __name__ == '__main__':print(f"\n{' 求裴波拉契数列第 n 项 ':~^41}\n\n")for i in range(7):print(f"{'第':>18} {i} 项是 {fib(i):>6} ")input(f"\n\n{'':~^50}")def fib(n: int) -> int:''' 求裴波拉契数列第 n 项(字典存储递推结果) '''if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0keys = list(nums.keys())if n-1 in keys and n-2 in keys:return nums.get(n-1) + nums.get(n-2)elif n-1 in keys:temp = fib(n-2)nums[n-2] = tempreturn nums.get(n-1) + tempelif n-2 in keys:temp = fib(n-1)nums[n-1] = tempreturn nums.get(n-2) + tempcurrent = fib(n-1) + fib(n-2)nums[n] = currentreturn currentdef fib(n: int) -> int:''' 求裴波拉契数列第 n 项(数组存储递推结果) '''if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0a = b = 0if not lis[n-1]:lis[n-1] = fib(n-1)else:a = lis[n-1]if not lis[n-2]:lis[n-2] = fib(n-2)else:b = lis[n-2]if a and b:return a + belif a and not b:return a + fib(n-2)elif not a and b:return fib(n-1) + breturn fib(n-1) + fib(n-2)def fib(n: int) -> int:''' 求裴波拉契数列第 n 项( for 循环) '''a = b = 1 # 当前项前两项初值。if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0for i in range(3, n+1):current = a + ba = bb = current # 更新当前项前两项值。return currentdef fib(n: int) -> int:''' 求裴波拉契数列第 n 项( while 循环) '''if n < 3: # 递归结束条件——递归边界条件。return 1 if n in (1, 2) else 0a = b = 1 # 当前项前两项初值。k = 3while k <= n:current = a + ba = bb = current # 更新当前项前两项值。k += 1return currentdef fib(n: int) -> int:''' 求裴波拉契数列第 n 项 '''if n < 3: # 递归结束条件——递归边界条件—— n = 0/1/2 。return 1 if n in (1, 2) else 0return fib(n-1) + fib(n-2) # 函数等价关系——递推关系公式—— 当前项 = 前两项和 。def fib(n: int) -> int:''' 求裴波拉契数列第 n 项 '''return 1 if n in (1, 2) else 0 if n < 3 else fib(n-1) + fib(n-2) # 用三元操作语句改写。if __name__ == '__main__':n = 35start_s = time()nums = {0: 0, 1: 1, 2: 1}lis = [0] * ninput(f"\n裴波拉契第 3、5、{n} 项是 {fib(3)}, {fib(5)}, {[fib(i) for i in range(n+1)][-1]}。\n\n程序运行用时 {time() - start_s:.6f} 秒。")### 求自然数 1～n 的序列总和def sum_n(num: int) -> int:''' sum() 计算 1～n 的和 '''return sum(range(1, num+1))def recur_n(num: int) -> int:''' 递归 计算 1～n 的和 '''if num == 1:return 1 # 递归结束条件——递归边界条件。return num + recur_n(num-1) # 函数等价关系——递归递推关系公式。def recur_n(num: int) -> int:''' 递归 计算 1～n 的和 '''return 1 if num == 1 else num + recur_n(num-1) # 用三元操作语句改写。def factorial_for(num: int) -> int:''' 乘积计算 n! '''multiple = 1for i in range(1, num+1):multiple *= i    return multipleif __name__ == '__main__':for i in (10, 100):print(f"\n 1～{i} 的总和是：{recur_n(i)}")### 求 n! def factorial_n(num: int) -> int:''' 递归 计算 n! '''if num == 0: # 递归终止条件。return 1return num * factorial_n(num-1) # 递归等价公式。def factorial_n(num: int) -> int:''' 递归 计算 n! (三元操作)'''return 1 if num == 0 else num * factorial_n(num-1) # 用三元操作语句改写。def factorial_n(num: int) -> int:''' 递归 计算 n! ( for )'''result = 1for i in range(1, num+1):result *= ireturn resultif __name__ == '__main__':for i in (4, 8):print(f"\n整数 {i}! = {factorial_n(i)}")input() from time import timenum = int(input(f"\n{' n = ':>15}"))print(f"\n{'':=^50}\n\n")start_sec = time()print(f"\n{' sum() 、递归求 1～n 的和 ':=^43}\n\n{'':~^50}\n\n 1～{num} 的和：sum() 计算 {sum_n(num)}、递归计算 {recur_n(num)}\n\n{'':~^50}\n{f'程序用时{time()-start_sec:.4f}秒':^45}\n")start_sec = time()print(f"\n{' for 循环相乘 、递归求 n! ':=^42}\n\n{'':~^50}\n\n {num}! = for 循环相乘计算 {factorial_for(num)}、递归计算 {factorial_n(num)}\n\n{'':~^50}\n{f'程序用时{time()-start_sec:.4f}秒':^45}\n")

源码全文本运行效果截屏图片

回页首

上一篇：找出 1~1000中的所有完美数_{(再次练习查找完美数，找出 1-1000 中的所有完美数)}
下一篇：三元操作&三元操作符_{( Python 三元操作符 if-else ，其他语言三元操操作符 ? :)}

我的HOT博：

本次共计收集 195 篇博文笔记信息，总阅读量 31.65w，平均阅读量 1623。已生成 20 篇阅读量不小于 3000 的博文笔记索引链接。数据采集于 2023-04-25 05:20:28 完成，用时 4 分 36.51 秒。

让QQ群昵称色变的神奇代码
( 53234 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/122566500
点赞：22 踩：0 收藏：74 打赏：0 评论：16
本篇博文笔记于 2022-01-18 19:15:08 首发，最晚于 2022-01-20 07:56:47 修改。
ChatGPT国内镜像站初体验：聊天、Python代码生成等
( 46594 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/129035387
点赞：123 踩：0 收藏：784 打赏：0 评论：73
本篇博文笔记于 2023-02-14 23:46:33 首发，最晚于 2023-03-22 00:03:44 修改。
pandas 数据类型之 DataFrame
( 7944 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/124525814
点赞：6 踩：0 收藏：23 打赏：0 评论：0
本篇博文笔记于 2022-05-01 13:20:17 首发，最晚于 2022-05-08 08:46:13 修改。
罗马数字转换器|罗马数字生成器
( 6345 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/122592047
点赞：0 踩：0 收藏：1 打赏：0 评论：0
本篇博文笔记于 2022-01-19 23:26:42 首发，最晚于 2022-01-21 18:37:46 修改。
Python字符串居中显示
( 6018 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/122163023
点赞：1 踩：0 收藏：5 打赏：0 评论：1
本篇博文笔记于 2021-12-26 23:35:29 发布。
斐波那契数列的递归实现和for实现
( 5276 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/122355295
点赞：4 踩：0 收藏：2 打赏：0 评论：8
本篇博文笔记于 2022-01-06 23:27:40 发布。
练习：字符串统计(坑：f‘string‘报错)
( 4851 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/121723096
点赞：0 踩：0 收藏：1 打赏：0 评论：0
本篇博文笔记于 2021-12-04 22:54:29 发布。
个人信息提取(字符串)
( 4666 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/124244618
点赞：1 踩：0 收藏：8 打赏：0 评论：0
本篇博文笔记于 2022-04-18 11:07:12 首发，最晚于 2022-04-20 13:17:54 修改。
练习：尼姆游戏(聪明版/傻瓜式•人机对战)
( 4565 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/121645399
点赞：14 踩：0 收藏：42 打赏：0 评论：0
本篇博文笔记于 2021-11-30 23:43:17 发布。
回车符、换行符和回车换行符
( 4306 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/123109488
点赞：0 踩：0 收藏：2 打赏：0 评论：0
本篇博文笔记于 2022-02-24 13:10:02 首发，最晚于 2022-02-25 20:07:40 修改。
python清屏
( 4190 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/120762101
点赞：0 踩：0 收藏：5 打赏：0 评论：0
本篇博文笔记于 2021-10-14 13:47:21 发布。
密码强度检测器
( 3851 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/121739694
点赞：1 踩：0 收藏：4 打赏：0 评论：0
本篇博文笔记于 2021-12-06 09:08:25 首发，最晚于 2022-11-27 09:39:39 修改。
罗马数字转换器(用罗马数字构造元素的值取模实现)
( 3786 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/122608526
点赞：0 踩：0 收藏：0 打赏：0 评论：0
本篇博文笔记于 2022-01-20 19:38:12 首发，最晚于 2022-01-21 18:32:02 修改。
练习：班里有人和我同生日难吗？(概率probability、蒙特卡洛随机模拟法)
( 3514 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/124424935
点赞：1 踩：0 收藏：2 打赏：0 评论：0
本篇博文笔记于 2022-04-26 12:46:25 首发，最晚于 2022-04-27 21:22:07 修改。
练习：生成100个随机正整数
( 3482 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/122558220
点赞：1 踩：0 收藏：3 打赏：0 评论：0
本篇博文笔记于 2022-01-18 13:31:36 首发，最晚于 2022-01-20 07:58:12 修改。
我的 Python.color() (Python 色彩打印控制)
( 3320 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/123194259
点赞：2 踩：0 收藏：7 打赏：0 评论：0
本篇博文笔记于 2022-02-28 22:46:21 首发，最晚于 2022-03-03 10:30:03 修改。
Python列表(list)反序(降序)的7种实现方式
( 3311 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/128271700
点赞：4 踩：0 收藏：10 打赏：0 评论：8
本篇博文笔记于 2022-12-11 23:54:15 首发，最晚于 2023-03-20 18:13:55 修改。
练习：仿真模拟福彩双色球——中500w巨奖到底有多难？跑跑代码就晓得了。
( 3176 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/125415626
点赞：3 踩：0 收藏：4 打赏：0 评论：3
本篇博文笔记于 2022-06-22 19:54:20 首发，最晚于 2022-06-23 22:41:33 修改。
聊天消息敏感词屏蔽系统(字符串替换 str.replace(str1, *) )
( 3045 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/124539589
点赞：3 踩：0 收藏：3 打赏：0 评论：3
本篇博文笔记于 2022-05-02 13:02:39 首发，最晚于 2022-05-21 06:10:42 修改。
Linux 脚本文件第一行的特殊注释符(井号和感叹号组合)的含义
( 3011 阅读)
博文地址：https://blog.csdn.net/m0_57158496/article/details/123087606
点赞：0 踩：0 收藏：4 打赏：0 评论：3
本篇博文笔记于 2022-02-23 13:08:07 首发，最晚于 2022-04-04 23:52:38 修改。