引言

这里主要是依托于 jackfrued 仓库 Python-100-Days 进行学习，记录自己的学习过程和心得体会。

Day1

1 Python 简介

Python（英式发音：/ˈpaɪθən/；美式发音：/ˈpaɪθɑːn/）是由荷兰人吉多·范罗苏姆（Guido von Rossum）发明的一种编程语言，是目前世界上最受欢迎和拥有最多用户的编程语言。Python 强调代码的可读性和语法的简洁性，相较于 C、C++、Java 这些同样影响深远的编程语言，Python 让使用者能够用更少的代码表达自己的意图。下面是几个权威的编程语言排行榜给出的 Python 语言的排名，其中第1张图由 TIOBE Index 提供，第3张图由 IEEE Spectrum 提供。值得一提的是第2张图，它展示了编程语言在全球最大代码托管平台 GitHub 上受欢迎的程度，最近的四年时间 Python 语言都占据了冠军的宝座。

1.1 Python 编年史

1. ​1989年​

   • 荷兰程序员吉多·范罗苏姆在圣诞假期开始开发新编程语言
   • 名称源自喜剧《Monty Python’s Flying Circus》

2. ​1991年​

   • 2月20日发布Python 0.9.0
   • 首次具备类继承、异常处理等现代特性
   • 确立"Batteries included"哲学

3. ​1994年​

   • Python 1.0发布
   • 引入函数式编程工具lambda, map, filter
   • 形成开源社区雏形

4. ​2000年​

   • Python 2.0发布
   • 新增垃圾回收机制
   • 标准库突破2万个函数
   • Zope成为首个企业级Python产品

5. ​2003年​

   • NumPy库发布
   • 科学计算领域开始大规模采用
   • NASA、劳伦斯国家实验室成为早期用户

6. ​2008年​

   • Python 3.0(代号Py3K)发布
   • 核心革新：统一Unicode编码，print改为函数
   • 向后不兼容引发社区长期讨论

7. ​2010年​

   • Flask框架诞生
   • PyPI仓库突破1万个软件包
   • Instagram全面转向Python技术栈

8. ​2013年​

   • Pandas 0.12重塑数据处理标准
   • Jupyter Notebook成为科研标配
   • Netflix推荐系统Python化

9. ​2016年​

   • TensorFlow 1.0确立AI框架标准
   • Python占据91%机器学习框架市场
   • RedMonk语言排行榜首次登顶

10. ​2019年​

    • Python 2.7正式退役
    • 结束长达10年的2.x/3.x并行期

11. ​2020年​

    • Python 3.9发布
    • 引入模式匹配(match/case)
    • 官方支持Mypy静态类型检查

12. ​2021年​

    • Python 3.10推出结构化模式匹配
    • 语言创建者吉多·范罗苏姆加入微软
    • 社区启动解释器性能优化计划

13. ​2022年​

    • Python 3.11发布
    • 解释器速度平均提升25%
    • 引入Exception Groups语法
    • TIOBE年度语言冠军

14. ​2024年​

    • Python 3.12引入JIT编译器雏形
    • 全球用户突破2500万
    • 教育领域采用率达87%
    • 持续主导AI大模型开发

1.2 Python优缺点

Python 语言的优点很多，简单为大家列出几点。

1. 简单优雅，跟其他很多编程语言相比，Python 更容易上手。
2. 能用更少的代码做更多的事情，提升开发效率。
3. 开放源代码，拥有强大的社区和生态圈。
4. 能够做的事情非常多，有极强的适应性。
5. 胶水语言，能够黏合其他语言开发的东西。
6. 解释型语言，更容易跨平台，能够在多种操作系统上运行。

Python 最主要的缺点是执行效率低（解释型语言的通病），如果更看重代码的执行效率，C、C++ 或 Go 可能是你更好的选择。

1.2 安装 Python 环境

建议直接使用 Anaconda 配置环境，Anaconda 是一个开源的 Python 发行版，它包含了大量的科学计算库，同时它还提供了一个包管理器和环境管理器，可以方便地安装和管理 Python 包和环境。

这里我给出一些参考链接：

• Anaconda安装python环境
• Anaconda安装(2024年8月最新版)并配置Python环境

2 Python 语言中的变量

对于想学习编程的新手来说，有两个问题可能是他们很想知道的，其一是"什么是（计算机）程序"，其二是"写（计算机）程序能做什么"。先说说我对这两个问题的理解：程序是数据和指令的有序集合，写程序就是用数据和指令控制计算机做我们想让它做的事情。今时今日，为什么有那么多人选择用 Python 语言来写程序，因为 Python 语言足够简单和强大。相较于 C、C++、Java 这样的编程语言，Python 对初学者和非专业人士更加友好，很多问题在 Python 语言中都能找到简单优雅的解决方案。接下来，我们就从最基础的语言元素开始，带大家认识和使用 Python 语言。

2.1 一些常识

在开始系统的学习 Python 编程之前，我们先来科普一些计算机的基础知识。计算机的硬件系统通常由五大部件构成，包括：运算器、控制器、存储器、输入设备和输出设备。其中，运算器和控制器放在一起就是我们常说的中央处理器（CPU），它的功能是执行各种运算和控制指令。刚才我们提到过，程序是指令的集合，写程序就是将一系列的指令按照某种方式组织到一起，然后通过这些指令去控制计算机做我们想让它做的事情。存储器可以分为内部存储器和外部存储器，前者就是我们常说的内存，它是中央处理器可以直接寻址的存储空间，程序在执行的过程中，对应的数据和指令需要加载到内存中。输入设备和输出设备经常被统称为 I/O 设备，键盘、鼠标、麦克风、摄像头是典型的输入设备，而显示器、打印机、扬声器等则是典型的输出设备。目前，我们使用的计算机基本大多是遵循"冯·诺依曼体系结构"的计算机，这种计算机有两个关键点：一是将存储器与中央处理器分开；二是将数据以二进制方式编码。

二进制是一种"逢二进一"的计数法，跟人类使用的"逢十进一"的计数法本质是一样的。人类因为有十根手指，所以使用了十进制计数法，在计数时十根手指用完之后，就只能用进位的方式来表示更大的数值。当然凡事都有例外，玛雅人可能是因为长年光着脚的原因，把脚趾头也都用上了，于是他们使用了二十进制的计数法。基于这样的计数方式，玛雅人使用的历法跟我们平常使用的历法就产生了差异。按照玛雅人的历法，2012 年是上一个所谓的"太阳纪"的最后一年，而 2013 年则是新的"太阳纪"的开始。后来这件事情还被以讹传讹的方式误传为"2012 年是玛雅人预言的世界末日"的荒诞说法。今天有很多人猜测，玛雅文明之所以发展缓慢跟使用了二十进制是有关系的。对于计算机来说，二进制在物理器件上最容易实现的，因为可以用高电压表示 1，用低电压表示 0。不是所有写程序的人都需要熟悉二进制，熟悉十进制与二进制、八进制、十六进制的转换，大多数时候我们即便不了解这些知识也能写程序。但是，我们必须知道，计算机是使用二进制计数的，不管什么样的数据，到了计算机内存中都是以二进制形态存在的。

说明：关于二进制计数法以及它与其他进制如何相互转换，大家可以翻翻名为《计算机导论》或《计算机文化》的书，都能找到相应的知识，此处就不再进行赘述了，不清楚的读者可以自行研究。

2.2 变量和类型

要想在计算机的内存中保存数据，首先得说一说变量这个概念。在编程语言中，变量是数据的载体，简单的说就是一块用来保存数据的内存空间，变量的值可以被读取和修改，这是所有运算和控制的基础。计算机能处理的数据有很多种类型，最常见的就是数值，除了数值之外还有文本、图像、音频、视频等各种各样的数据类型。虽然数据在计算机中都是以二进制形态存在的，但是我们可以用不同类型的变量来表示数据类型的差异。Python 语言中预设了多种数据类型，也允许我们自定义新的数据类型，这一点在后面会讲到。我们首先来了解几种 Python 中最为常用的数据类型。

1. 整型（int）：Python 中可以处理任意大小的整数，而且支持二进制（如0b100，换算成十进制是4）、八进制（如0o100，换算成十进制是64）、十进制（100）和十六进制（0x100，换算成十进制是256）的表示法。运行下面的代码，看看会输出什么。

1
2
3
4

print(0b100) # 二进制整数
print(0o100) # 八进制整数
print(100)   # 十进制整数
print(0x100) # 十六进制整数

2. 浮点型（float）：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，浮点数除了数学写法（如123.456）之外还支持科学计数法（如1.23456e2，表示$\small{1.23456 \times 10^{2}}$）。运行下面的代码，看看会输出什么。

1
2

print(123.456)
print(1.23456e2)

3. 字符串型（str）：字符串是以单引号或双引号包裹起来的任意文本，比如’hello’和"hello"。

1
2

print('hello')
print("hello")

4. 布尔型（bool）：布尔型只有True、False两种值，要么是True，要么是False，可以用来表示现实世界中的"是"和"否"，命题的"真"和"假"，状况的"好"与"坏"，水平的"高"与"低"等等。如果一个变量的值只有两种状态，我们就可以使用布尔型。

1
2

print(int(True))
print(int(False))

2.3 变量命名

对于每个变量，我们都需要给它取一个名字，就如同我们每个人都有自己的名字一样。在 Python 中，变量命名需要遵循以下的规则和惯例。

• 规则部分：
  • 规则1：变量名由字母、数字和下划线构成，数字不能开头。需要说明的是，这里说的字母指的是 Unicode 字符，Unicode 称为万国码，囊括了世界上大部分的文字系统，这也就意味着中文、日文、希腊字母等都可以作为变量名中的字符，但是一些特殊字符（如：！、@、#等）是不能出现在变量名中的。我们强烈建议大家把这里说的字母理解为尽可能只使用英文字母。
  • 规则2：Python 是大小写敏感的编程语言，简单的说就是大写的A和小写的a是两个不同的变量，这一条其实并不算规则，而是需要大家注意的地方。
  • 规则3：变量名不要跟 Python 的关键字重名，尽可能避开 Python 的保留字。这里的关键字是指在 Python 程序中有特殊含义的单词（如：is、if、else、for、while、True、False等），保留字主要指 Python 语言内置函数、内置模块等的名字（如：int、print、input、str、math、os等）。
• 惯例部分：
  • 惯例1：变量名应该具有可读性，能够反映出变量的含义，比如一个表示年龄的变量，我们就可以命名为age，而不是a或者x。
  • 惯例2：变量名应该避免使用缩写，除非缩写非常常见且易于理解，比如name比nm要好，age比a要好。
  • 惯例3：变量名通常使用小写英文字母，多个单词用下划线进行连接。
  • 惯例4：受保护的变量用单个下划线开头。
  • 惯例5：私有的变量用两个下划线开头。

2.4 变量的使用

下面通过例子来说明变量的类型和变量的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13

"""
使用变量保存数据并进行加减乘除运算

Version: 1.0
Author: Penry
"""
a = 45        # 定义变量a，赋值45
b = 12        # 定义变量b，赋值12
print(a, b)   # 45 12
print(a + b)  # 57
print(a - b)  # 33
print(a * b)  # 540
print(a / b)  # 3.75

在 Python 中可以使用type函数对变量的类型进行检查。程序设计中函数的概念跟数学上函数的概念非常类似，数学上的函数相信大家并不陌生，它包括了函数名、自变量和因变量。如果暂时不理解函数这个概念也不要紧，我们会在后续的内容中专门讲解函数的定义和使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
使用type函数检查变量的类型

Version: 1.0
Author: Penry
"""
a = 100
b = 123.45
c = 'hello, world'
d = True
print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'str'>
print(type(d))  # <class 'bool'>

可以通过 Python 内置的函数来改变变量的类型，下面是一些常用的和变量类型相关的函数。

• int()：将一个数值或字符串转换成整数，可以指定进制。
• float()：将一个字符串（在可能的情况下）转换成浮点数。
• str()：将指定的对象转换成字符串形式，可以指定编码方式。
• chr()：将整数（字符编码）转换成对应的（一个字符的）字符串。
• ord()：将（一个字符的）字符串转换成对应的整数（字符编码）。

下面的例子为大家演示了 Python 中类型转换的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

"""
变量的类型转换操作

Version: 1.0
Author: Penry
"""
a = 100
b = 123.45
c = '123'
d = '100'
e = '123.45'
f = 'hello, world'
g = True
print(float(a))         # int类型的100转成float，输出100.0
print(int(b))           # float类型的123.45转成int，输出123
print(int(c))           # str类型的'123'转成int，输出123
print(int(c, base=16))  # str类型的'123'按十六进制转成int，输出291
print(int(d, base=2))   # str类型的'100'按二进制转成int，输出4
print(float(e))         # str类型的'123.45'转成float，输出123.45
print(bool(f))          # str类型的'hello, world'转成bool，输出True
print(int(g))           # bool类型的True转成int，输出1
print(chr(a))           # int类型的100转成str，输出'd'
print(ord('d'))         # str类型的'd'转成int，输出100

说明：str类型转int类型时可以通过base参数来指定进制，可以将字符串视为对应进制的整数进行转换。str类型转成bool类型时，只要字符串有内容，不是’'或""，对应的布尔值都是True。bool类型转int类型时，True会变成1，False会变成0。在 ASCII 字符集和 Unicode 字符集中， 字符'd'对应的编码都是100。

3 Python语言中的运算符

Python 语言支持很多种运算符，下面的表格按照运算符的优先级从高到低，对 Python 中的运算符进行了罗列。有了变量和运算符，我们就可以构造各种各样的表达式来解决实际问题。在计算机科学中，表达式是计算机程序中的句法实体，它由一个或多个常量、变量、函数和运算符组合而成，编程语言可以对其进行解释和计算以得到另一个值。不理解这句话没有关系，但是一定要知道，不管使用什么样的编程语言，构造表达式都是非常重要的。

说明： 所谓优先级就是在一个运算的表达式中，如果出现了多个运算符，应该先执行什么再执行什么的顺序。编写代码的时候，如果搞不清楚一个表达式中运算符的优先级，可以使用圆括号（小括号）来确保运算的执行顺序。

3.1 算术运算符

Python 中的算术运算符非常丰富，除了大家最为熟悉的加、减、乘、除之外，还有整除运算符、求模（求余数）运算符和求幂运算符。下面的例子为大家展示了算术运算符的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13

"""
算术运算符

Version: 1.0
Author: Penry
"""
print(321 + 12)     # 加法运算，输出333
print(321 - 12)     # 减法运算，输出309
print(321 * 12)     # 乘法运算，输出3852
print(321 / 12)     # 除法运算，输出26.75
print(321 // 12)    # 整除运算，输出26
print(321 % 12)     # 求模运算，输出9
print(321 ** 12)    # 求幂运算，输出1196906950228928915420617322241

算术运算需要先乘除后加减，这一点跟数学课本中讲的知识没有区别，也就是说乘除法的运算优先级是高于加减法的。如果还有求幂运算，求幂运算的优先级是高于乘除法的。如果想改变算术运算的执行顺序，可以使用英文输入法状态下的圆括号（小括号），写在圆括号中的表达式会被优先执行，如下面的例子所示。

1
2
3
4
5
6
7
8
9
10

"""
算术运算的优先级

Version: 1.0
Author: Penry
"""
print(2 + 3 * 5)           # 17
print((2 + 3) * 5)         # 25
print((2 + 3) * 5 ** 2)    # 125
print(((2 + 3) * 5) ** 2)  # 625

3.2 赋值运算符

赋值运算符应该是最为常见的运算符，它的作用是将右边的值赋给左边的变量。赋值运算符还可以跟上面的算术运算符放在一起，组合成复合赋值运算符，例如：a += b相当于a = a + b，a *= a + 2相当于a = a * (a + 2)。下面的例子演示了赋值运算符和复合赋值运算符的使用。

1
2
3
4
5
6
7
8
9
10
11

"""
赋值运算符和复合赋值运算符

Version: 1.0
Author: Penry
"""
a = 10
b = 3
a += b        # 相当于：a = a + b
a *= a + 2    # 相当于：a = a * (a + 2)
print(a)      # 大家算一下这里会输出什么

赋值运算构成的表达式本身不产生任何值，也就是说，如果你把一个赋值表达式放到print函数中试图输出表达式的值，将会产生语法错误。为了解决这个问题，Python 3.8 中引入了一个新的赋值运算符:=，我们称之为海象运算符，大家可以猜一猜它为什么叫这个名字。海象运算符也是将运算符右侧的值赋值给左边的变量，与赋值运算符不同的是，运算符右侧的值也是整个表达式的值，看看下面的代码大家就明白了。

• 这里给出一个海象运算符的详细介绍文档：Python 海象运算符

1
2
3
4
5
6
7
8
9
10
11

"""
海象运算符

Version: 1.0
Author: Penry
"""
# SyntaxError: invalid syntax
# print((a = 10))
# 海象运算符
print((a := 10))  # 10
print(a)          # 10

提示：上面第 8 行代码如果不注释掉，运行代码会看到SyntaxError: invalid syntax错误信息，注意，这行代码中我们给a = 10加上了圆括号，如果不小心写成了print(a = 10)，会看到TypeError: 'a' is an invalid keyword argument for print()错误信息，后面讲到函数的时候，大家就会明白这个错误提示是什么意思了。

这里给出一个普通赋值运算符和海象运算符实现密码输入检验程序的对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
密码输入检验

Version: 1.0
Author: Penry
"""

while True:
    psw = input('请输入密码: ')
    if psw == '123456':
        print('密码正确，进入程序...')
        break
    else:
        print('密码错误，请重新输入...')

1
2
3
4
5
6
7
8
9
10
11

"""
海象运算符实现密码输入检验

Version: 1.0
Author: Penry
"""

while (psw := input("请输入密码："))!= '123456':
    print("密码错误，请重新输入...")

print("密码正确，进入程序...")

3.3 比较运算符和逻辑运算符

比较运算符也称为关系运算符，包括==、!=、<、>、<=、>=，我相信大家一看就能懂。需要提醒的是比较相等用的是==，请注意这里是两个等号，因为=是赋值运算符，我们在上面刚刚讲到过。比较不相等用的是!=，跟数学课本中使用的$\small{\neq}$并不相同，Python 2 中曾经使用过<>来表示不等于，在 Python 3 中使用<>会引发SyntaxError（语法错误）。比较运算符会产生布尔值，要么是True，要么是False。

逻辑运算符有三个，分别是and、or和not。and字面意思是"而且"，所以and运算符会连接两个布尔值或者产生布尔值的表达式，如果两边的布尔值都是True，那么运算的结果就是True；左右两边的布尔值有一个是False，最终的运算结果就是False。注意，如果and运算符左边的布尔值是False，不管右边的布尔值是什么，最终的结果都是False，这时运算符右边的布尔值会被跳过（专业的说法叫短路处理，如果and右边是一个表达式，那么这个表达式不会执行）。or字面意思是"或者"，所以or运算符也会连接两个布尔值或产生布尔值的表达式，如果两边的布尔值有任意一个是True，那么最终的结果就是True。注意，or运算符也是有短路功能的，当它左边的布尔值为True的情况下，右边的布尔值会被短路（如果or右边是一个表达式，那么这个表达式不会执行）。not运算符的后面可以跟一个布尔值，如果not后面的布尔值或表达式是True，那么运算的结果就是False；如果not后面的布尔值或表达式是False，那么运算的结果就是True。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

"""
比较运算符和逻辑运算符的使用

Version: 1.0
Author: Penry
"""
flag0 = 1 == 1
flag1 = 3 > 2
flag2 = 2 < 1
flag3 = flag1 and flag2
flag4 = flag1 or flag2
flag5 = not flag0
print('flag0 =', flag0)     # flag0 = True
print('flag1 =', flag1)     # flag1 = True
print('flag2 =', flag2)     # flag2 = False
print('flag3 =', flag3)     # flag3 = False
print('flag4 =', flag4)     # flag4 = True
print('flag5 =', flag5)     # flag5 = False
print(flag1 and not flag2)  # True
print(1 > 2 or 2 == 3)      # False

说明：比较运算符的优先级高于赋值运算符，所以上面的flag0 = 1 == 1先做1 == 1产生布尔值True，再将这个值赋值给变量flag0。print函数可以输出多个值，多个值之间可以用,进行分隔，输出的内容默认以空格分开。

思考以下问题并与结果对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

"""
基础短路验证

Version: 1.0
Author: Penry
"""

def foo():
    print("foo 被调用")
    return True

def bar():
    print("bar 被调用")
    return False

# 情况 A
result_A = bar() and foo()   # 输出什么？为什么？

# 情况 B
result_B = foo() or bar()    # 输出什么？为什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

"""
嵌套短路分析

Version: 1.0
Author: Penry
"""

def func1():
    print("func1 执行")
    return False

def func2():
    print("func2 执行")
    return True

# 表达式分析
outcome = func1() and func2() or "短路生效"
print(outcome)

这里在测试过程中发现我们还需要详细学习一下 and 和 or 返回值规则：

1. and返回值规则​：
   • 如果 ​左操作数为假值​ → ​直接返回左操作数​
   • 如果 ​左操作数为真值​ → ​直接返回右操作数​（无论右操作数的真假）
2. or返回值规则​：
   • 如果 ​左操作数为真值​ → ​直接返回左操作数​
   • 如果 ​左操作数为假值​ → ​直接返回右操作数​（无论右操作数的真假）

1
2
3
4
5
6
7
8
9
10
11

"""
and 和 or 返回值测试

Version: 1.0
Author: Penry
"""

print(n := ("1234" and "5678"))
print(m := (0 and "1234"))
print(x := ("2345" or "6789"))
print(y := (False or 0))

3.4 运算符和表达式应用

例子1：华氏温度转摄氏温度

要求：输入华氏温度将其转换为摄氏温度，华氏温度到摄氏温度的转换公式为： $\small{C = (F - 32) / 1.8}$ 。

1
2
3
4
5
6
7
8
9
10

"""
华氏温度转摄氏温度

Version: 1.0
Author: Penry
"""

f = float(input("请输入华氏温度："))
c = (f - 32) / 1.8
print("华氏温度为%.1f度，对应的摄氏温度为%.1f度" % (f, c))

说明：上面代码中的input函数用于从键盘接收用户输入，由于输入的都是字符串，如果想处理成浮点小数来做后续的运算，可以用我们上一课讲解的类型转换的方法，用float函数将str类型处理成float类型。

上面的代码中，我们对print函数输出的内容进行了格式化处理，print输出的字符串中有两个%.1f占位符，这两个占位符会被%之后的(f, c)中的两个float类型的变量值给替换掉，浮点数小数点后保留1位有效数字。如果字符串中有%d占位符，那么我们会用int类型的值替换掉它，如果字符串中有%s占位符，那么它会被str类型的值替换掉。

除了上面格式化输出的方式外，Python 中还可以用下面的办法来格式化输出，我们给出一个带占位符的字符串，字符串前面的f表示这个字符串是需要格式化处理的，其中的{f:.1f}和{c:.1f}可以先看成是{f}和{c}，表示输出时会用变量f和变量c的值替换掉这两个占位符，后面的:.1f表示这是一个浮点数，小数点后保留1位有效数字。

1
2
3
4
5
6
7
8
9

"""
将华氏温度转换为摄氏温度

Version: 1.1
Author: Penry
"""
f = float(input('请输入华氏温度: '))
c = (f - 32) / 1.8
print(f'{f:.1f}华氏度 = {c:.1f}摄氏度')

例子2：计算圆的周长和面积

要求：输入一个圆的半径（$\small{r}$），计算出它的周长（ $\small{2 \pi r}$ ）和面积（ $\small{\pi r^{2}}$ ）。

1
2
3
4
5
6
7
8
9
10
11
12

"""
输入半径计算圆的周长和面积

Version: 1.0
Author: Penry
"""
radius = float(input('请输入圆的半径: '))
perimeter = 2 * 3.1416 * radius
area = 3.1416 * radius * radius
print('半径: %.2f' % radius)
print('周长: %.2f' % perimeter)
print('面积: %.2f' % area)

Python 中有一个名为math 的内置模块，该模块中定义了名为pi的变量，它的值就是圆周率。如果要使用 Python 内置的这个pi，我们可以对上面的代码稍作修改。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
输入半径计算圆的周长和面积

Version: 1.1
Author: Penry
"""
import math

radius = float(input('请输入圆的半径: '))
perimeter = 2 * math.pi * radius
area = math.pi * radius ** 2
print(f'半径: {radius:.2f}')
print(f'周长: {perimeter:.2f}')
print(f'面积: {area:.2f}')

说明：上面代码中的import math表示导入math模块，导入该模块以后，才能用math.pi得到圆周率的值。

这里其实还有一种格式化输出的方式，是 Python 3.8 中增加的新特性，大家直接看下面的代码就明白了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
输入半径计算圆的周长和面积

Version: 1.2
Author: Penry
"""
import math

radius = float(input('请输入圆的半径: '))
perimeter = 2 * math.pi * radius
area = math.pi * radius ** 2
print(f'{radius = :.2f}')
print(f'{perimeter = :.2f}')
print(f'{area = :.2f}')

说明：假如变量a的值是9.87，那么字符串f'{a = }'的值是a = 9.87；而字符串f'{a = :.1f}'的值是a = 9.9。这种格式化输出的方式会同时输出变量名和变量值。

例子3：判断闰年

要求：输入一个 1582 年以后的年份，判断该年份是不是闰年。

1
2
3
4
5
6
7
8
9
10

"""
闰年判断

Version: 1.0
Author: Penry
"""

year = int(input("请输入年份："))
is_leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
print(f'{is_leap = }')

说明：对于格里历（Gregorian calendar），即今天我们使用的公历，判断闰年的规则是：1. 公元年份非 4 的倍数是平年；2. 公元年份为 4 的倍数但非 100 的倍数是闰年；3. 公元年份为 400 的倍数是闰年。格里历是由教皇格里高利十三世在 1582 年 10 月引入的，作为对儒略历（Julian calendar）的修改和替代，我们在输入年份时要注意这一点。上面的代码通过%来判断year是不是4的倍数、100的倍数、400的倍数，然后用and和or运算符将三个条件组装在一起，前两个条件要同时满足，第三个条件跟前两个条件的组合只需满足其中之一。

Day2

1 分支结构

迄今为止，我们写的 Python 程序都是一条一条语句按顺序向下执行的，这种代码结构叫做顺序结构。然而仅有顺序结构并不能解决所有的问题，比如我们设计一个游戏，游戏第一关的过关条件是玩家获得 1000 分，那么在第一关完成后，我们要根据玩家得到的分数来决定是进入第二关，还是告诉玩家"Game Over"（游戏结束）。在这种场景下，我们的代码就会产生两个分支，而且只有一个会被执行。类似的场景还有很多，我们将这种结构称之为"分支结构"或"选择结构"。给大家一分钟的时间，你应该可以想到至少 5 个以上类似的例子，赶紧试一试吧！

1.1 使用 if 和 else 构造分支结构

在 Python 中，构造分支结构最常用的是if、elif和else三个关键字。所谓关键字就是编程语言中有特殊含义的单词，很显然你不能够使用它作为变量名。当然，我们并不是每次构造分支结构都会把三个关键字全部用上，我们通过例子加以说明。例如我们要写一个身体质量指数（BMI）的计算器。身体质量质数也叫体质指数，是国际上常用的衡量人体胖瘦程度以及是否健康的一个指标，计算公式如下所示。通常认为 BMI 值低于 18.5 为偏瘦，18.5～24.9 为正常，25～29.9 为偏胖，30 以上为肥胖。

$$BMI = \frac{体重}{身高^{2}}$$

说明：上面公式中的体重以千克（kg）为单位，身高以米（m）为单位。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

"""
BMI计算器

Version: 1.0
Author: Penry
"""
height = float(input("请输入身高（m）："))
weight = float(input("请输入体重（kg）："))
bmi = weight / (height ** 2)
print(f"您的BMI指数为：{bmi:.2f}")
if bmi < 18.5:
    print("您的体重过轻！")
elif bmi < 24.9:
    print("您的体重正常！")
elif bmi < 29.9:
    print("您的体重过重！")
else:
    print("您的体重肥胖！")

提示：if语句的最后面有一个:，它是用英文输入法输入的冒号；程序中输入的'、"、=、(、)等特殊字符，都是在英文输入法状态下输入的，这一点之前已经提醒过大家了。很多初学者经常会忽略这一点，等到执行代码时，就会看到一大堆错误提示。当然，认真读一下错误提示还是很容易发现哪里出了问题，但是强烈建议大家在写代码的时候切换到英文输入法，这样可以避免很多不必要的麻烦。

上面的代码中，if后面的条件判断语句就是bmi < 18.5，如果条件成立，那么就执行if和else之间的代码，否则就执行else和if之间的代码。if和else之间的代码又称为分支体，它也是由一条或多条语句组成的代码块。if和else之间的代码块需要用缩进的方式表示出来，缩进方式有两种，一种是空格，一种是Tab。空格和 Tab 之间是有区别的，空格是等宽字符，Tab 是等高字符，所以它们之间不能混用。在 Python 中，缩进是语法的一部分，如果缩进不正确，那么程序就会报错。

1.2 使用 match 和 case 构造分支结构

Python 3.10 中增加了一种新的构造分支结构的方式，通过使用match和case关键字，我们可以轻松的构造出多分支结构。Python 的官方文档在介绍这个新语法时，举了一个 HTTP 响应状态码识别的例子（根据 HTTP 响应状态输出对应的描述），非常有意思。如果不知道什么是 HTTP 响应状态吗，可以看看 MDN 上面的下面我们对官方文档上的示例稍作修改，为大家讲解这个语法，先看看下面用if-else结构实现的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

"""
HTTP响应状态码识别

Version: 1.0
Author: Penry
"""

status_code = int(input('响应状态码: '))
if status_code == 400:
    description = 'Bad Request'
elif status_code == 401:
    description = 'Unauthorized'
elif status_code == 403:
    description = 'Forbidden'
elif status_code == 404:
    description = 'Not Found'
elif status_code == 405:
    description = 'Method Not Allowed'
elif status_code == 418:
    description = 'I am a teapot'
elif status_code == 429:
    description = 'Too many requests'
else:
    description = 'Unknown status Code'
print('状态码描述:', description)

下面是使用match-case语法实现的代码，虽然作用完全相同，但是代码显得更加简单优雅。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

"""
HTTP响应状态码识别

Version: 1.1
Author: Penry
"""

"""
HTTP响应状态码识别

Version: 1.1
Author: Penry
"""

status_code = int(input('响应状态码: '))
match status_code:
    case 400: description = 'Bad Request'
    case 401: description = 'Unauthorized'
    case 403: description = 'Forbidden'
    case 404: description = 'Not Found'
    case 405: description = 'Method Not Allowed'
    case 418: description = 'I am a teapot'
    case 429: description = 'Too many requests'
    case _: description = 'Unknown Status Code'
print('状态码描述:', description)

说明：带有_的case语句在代码中起到通配符的作用，如果前面的分支都没有匹配上，代码就会来到case _。case _的是可选的，并非每种分支结构都要给出通配符选项。如果分支中出现了case _，它只能放在分支结构的最后面，如果它的后面还有其他的分支，那么这些分支将是不可达的。

当然，match-case语法还有很多高级玩法，比如可以匹配多个值，或者匹配一个范围，或者匹配一个模式，或者匹配一个类型，或者匹配一个函数，或者匹配一个对象，或者匹配一个表达式，等等。下面是一个匹配多个值的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

"""
HTTP响应状态码识别

Version: 1.2
Author: Penry
"""
HTTP响应状态码识别

Version: 1.2
Author: Penry
"""

status_code = int(input("响应状态码: "))
match status_code:
    case 400 | 405:
        description = "Invalid Request"
    case 401 | 403 | 404:
        description = "Not Allowed"
    case 418:
        description = "I'm a teapot"
    case 429:
        description = "Too Many Requests"
    case _:
        description = "Unknown Status Code"
print(f"状态码描述：{description =}")

1.3 分支结构的应用

1.3.1 示例1：分段函数求值

要求：编写一个程序，输入一个数，输出这个数在分段函数中的值。分段函数如下：

$$y = \begin{cases} 3x-5 & \text{if } x > 1 \\ x+2 & \text{if } -1 \leq x \leq 1 \\ 5x+3 & \text{if } x < -1 \end{cases}$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

"""
分段函数求值

Version: 1.0
Author: Penry
"""

x = float(input("x = "))
match x:
    case x if x > 1:
        y = 3 * x - 5
    case x if x >= -1:
        y = x + 2
    case _:
        y = 5 * x + 3
print(f"y = {y}")

根据实际开发的需要，分支结构是可以嵌套的，也就是说在分支结构的if、elif或else代码块中还可以再次引入分支结构。例如if条件成立表示玩家过关，但过关以后还要根据你获得宝物或者道具的数量对你的表现给出评价（比如点亮一颗、两颗或三颗星星），那么我们就需要在if的内部再构造一个新的分支结构。同理，我们在elif和else中也可以构造新的分支，我们称之为嵌套的分支结构。按照这样的思路，上面的分段函数求值也可以用下面的代码来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

"""
分段函数求值

Version: 1.1
Author: Penry
"""

"""
分段函数求值

Version: 1.1
Author: Penry
"""
x = float(input('x = '))
if x > 1:
    y = 3 * x - 5
else:
    if x >= -1:
        y = x + 2
    else:
        y = 5 * x+3
print('f(%.2f) = %.2f' % (x, y))

1.3.2 示例2：百分制成绩转等级制成绩

要求：编写一个程序，根据输入的百分制成绩输出对应的等级。等级划分标准如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

"""
百分制成绩转等级制成绩

Version: 1.0
Author: Penry
"""

score = int(input("该学生的成绩是："))
match score:
    case score if score > 100:
        print("成绩有误！")
        grade = 'Error'
    case score if score >= 90:
        grade = 'A'
    case score if score >= 80:
        grade = 'B'
    case score if score >= 70:
        grade = 'C'
    case score if score >= 60:
        grade = 'D'
    case _:
        grade = 'E'
print("该学生的成绩等级是：", grade)

1.3.3 示例3：输入三条边长，如果能构成三角形就计算周长和面积

要求：输入三条边长，如果能构成三角形就计算周长和面积。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

"""
三角形周长和面积计算

Version: 1.0
Author: Penry
"""

a = int(input("a = "))
b = int(input("b = "))
c = int(input("c = "))
if a + b > c and a + c > b and b + c > a:
    print("周长: %d" % (a + b + c))
    p = (a + b + c) / 2
    area = (p * (p - a) * (p - b) * (p - c)) ** 0.5
    print("面积: %f" % area)
else:
    print("不能构成三角形")

2 循环结构

我们在写程序的时候，极有可能遇到需要重复执行某条或某些指令的场景，例如我们需要每隔1秒钟在屏幕上输出一次"hello, world"并持续输出一个小时。如下所示的代码可以完成一次这样的操作，如果要持续输出一个小时，我们就需要把这段代码写3600遍，你愿意这么做吗？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

"""
每隔1秒输出一次"hello, world"

Version: 1.0
Author: Penry
"""

import time

time.sleep(1)
print("Hello World")
time.sleep(1)
print("Hello World")
time.sleep(1)
print("Hello World")

说明：上面的代码中，我们使用了time模块的sleep函数，它可以让程序暂停1秒。

为了应对上述场景中的问题，我们可以在 Python 程序中使用循环结构。所谓循环结构，就是程序中控制某条或某些指令重复执行的结构。有了这样的结构，刚才的代码就不需要写 3600 遍，而是写一遍然后放到循环结构中重复 3600 次。在 Python 语言中构造循环结构有两种做法，一种是for-in循环，另一种是while循环。

2.1 使用 for-in 循环

如果明确知道循环执行的次数，我们推荐使用for-in循环，例如上面说的那个重复 3600 次的场景，我们可以用下面的代码来实现。 注意，被for-in循环控制的代码块也是通过缩进的方式来构造，这一点跟分支结构中构造代码块的做法是一样的。我们被for-in循环控制的代码块称为循环体，通常循环体中的语句会根据循环的设定被重复执行。

1
2
3
4
5
6
7
8
9
10
11
12

"""
每隔1秒输出一次"Hello,world"，持续1小时

Version: 1.1
Author: Penry
"""

import time

for i in range(3600):
    time.sleep(1)
    print("Hello,world")

需要说明的是，上面代码中的range(3600)可以构造出一个从0到3599的范围，当我们把这样一个范围放到for-in循环中，就可以通过前面的循环变量i依次取出从0到3599的整数，这就会让for-in代码块中的语句重复 3600 次。当然，range的用法非常灵活，下面的清单给出了使用range函数的例子：

• range(101)：可以用来产生0到100范围的整数，需要注意的是取不到101。
• range(1, 101)：可以用来产生1到100范围的整数，相当于是左闭右开的设定，即[1, 101)。
• range(1, 101, 2)：可以用来产生1到100的奇数，其中2是步长（跨度），即每次递增的值，101取不到。
• range(100, 0, -2)：可以用来产生100到1的偶数，其中-2是步长（跨度），即每次递减的值，0取不到。

大家可能已经注意到了，上面代码的输出操作和休眠操作都没有用到循环变量i，对于不需要用到循环变量的for-in循环结构，按照 Python 的编程惯例，我们通常把循环变量命名为_，修改后的代码如下所示。虽然结果没什么变化，但是这样写显得你更加专业，逼格瞬间拉满。

1
2
3
4
5
6
7
8
9
10
11
12

"""
每隔1秒输出一次"Hello,world"，持续1小时

Version: 1.2
Author: Penry
"""

import time

for _ in range(3600):
    time.sleep(1)
    print("Hello,world")

下面，我们用for-in循环实现从 1 到 100 的整数求和，即$\sum_{i=1}^{100}i$。

1
2
3
4
5
6
7
8
9
10

"""
求从 1 到 100 的所有整数之和。

Version: 1.0
Author: Penry
"""
sum_num = 0
for i in range(101):
    sum_num += i
print(sum_num)

我们再来写一个求取从 1 到 100 的偶数之和的程序。

1
2
3
4
5
6
7
8
9
10
11

"""
求从 1 到 100 的所有偶数之和。

Version: 1.0
Author: Penry
"""

sum_even = 0
for i in range(0,101,2):
    sum_even += i
print(sum_even)

当然， 更为简单的办法是使用 Python 内置的sum函数求和，这样我们连循环结构都省掉了。

1
2
3
4
5
6
7
8

"""
求从 1 到 100 的所有偶数之和。

Version: 1.1
Author: Penry
"""

print(f"1-100偶数求和为：{sum(range(2, 101, 2))}")

2.2 使用 while 循环

如果要构造循环结构但是又不能确定循环重复的次数，我们推荐使用while循环。while循环通过布尔值或能产生布尔值的表达式来控制循环，当布尔值或表达式的值为True时，循环体（while语句下方保持相同缩进的代码块）中的语句就会被重复执行，当表达式的值为False时，结束循环。

下面我们用while循环来实现从 1 到 100 的偶数求和，代码如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

"""
求从 1 到 100 的所有偶数之和。

Version: 1.0
Author: Penry
"""

sum_even = 0
i = 0
num_lst = []
while i <= 100:
    num_lst.append(i)
    sum_even += i
    i += 2
print(num_lst)
print(sum_even)

这里需要注意，我们根据 num_lst 列表来观察中间变量 i 的值，它从 0 开始，每次循环都增加 2，当 i 的值大于 100 时，循环结束。这里也能发现，在循环外围我们设置 i 的初始值为 0，而在 num_lst 列表中，第一个元素也为0，说明 while 循环是先将起始值赋值给中间变量，再进行条件判断。

相较于for-in循环，上面的代码我们在循环开始前增加了一个变量i，我们使用这个变量来控制循环，所以while后面给出了i <= 100的条件。在while的循环体中，我们除了做累加，还需要让变量i的值递增，所以我们添加了i += 2这条语句，这样i的值就会依次取到0、2、4、……，直到 102。当i变成 102 时，while循环的条件不再成立，代码会离开while循环，此时我们输出变量sum_even的值，它就是从 1 到 100 偶数求和的结果 2550。

2.3 break 和 continue 语句

在循环结构中，我们还可以使用break和continue两个关键字来控制循环的流程。其中，break用于终止循环，而continue用于跳过当前循环的剩余语句，直接进入下一次循环。

如果把while循环的条件设置为True，即让条件恒成立会怎么样呢？我们看看下面的代码，还是使用while构造循环结构，计算 1 到 100 的偶数和。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

"""
求从 1 到 100 的所有偶数之和。

Version: 1.1
Author: Penry
"""

sum_even = 0
num_lst = []
i = 0
while True:
    i += 2
    if i > 100:
        break
    else:
        num_lst.append(i)
        sum_even += i
print(num_lst)
print(sum_even)

上面的代码中使用while True构造了一个条件恒成立的循环，也就意味着如果不做特殊处理，循环是不会结束的，这就是我们常说的"死循环"。为了在i的值超过 100 后让循环停下来，我们使用了break关键字，它的作用是终止循环结构的执行。需要注意的是，break只能终止它所在的那个循环，这一点在使用嵌套循环结构时需要引起注意，后面我们会讲到什么是嵌套的循环结构。除了break之外，还有另一个在循环结构中可以使用的关键字continue，它可以用来放弃本次循环后续的代码直接让循环进入下一轮，代码如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

"""
求从 1 到 100 的所有偶数之和。

Version: 1.2
Author: Penry
"""

"""
求从 1 到 100 的所有偶数之和。

Version: 1.2
Author: Penry
"""

sum_even = 0
sum_lst = []
for i in range(1,101):
    if i % 2 == 0:
        continue
    else:
        sum_lst.append(i)
        sum_even += i
print(sum_lst)
print(sum_even)

说明：上面的代码中，我们使用continue关键字来跳过奇数的累加。

2.4 嵌套的循环结构

和分支结构一样，循环结构也是可以嵌套的，也就是说在循环结构中还可以构造循环结构。下面的例子演示了如何通过嵌套的循环来输出一个乘法口诀表（九九表）。

1
2
3
4
5
6
7
8
9
10
11

"""
打印九九乘法表

Version: 1.0
Author: Penry
"""

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{i} × {j} = {i * j}", end="\t")
    print()

上面的代码中，for-in循环的循环体中又用到了for-in循环，外面的循环用来控制产生i行的输出，而里面的循环则用来控制在一行中输出j列。显然，里面的for-in循环的输出就是乘法口诀表中的一整行。所以在里面的循环完成时，我们用了一个print()来实现换行的效果，让下面的输出重新另起一行。

2.5 循环结构的应用

2.5.1 练习题1：判断素数

要求：输入一个正整数判断是不是素数。
提示：素数指的是只能被 1 和自身整除的大于 1 的整数。例如对于正整数 n，我们可以通过在 2 到 n-1 之间寻找有没有 n 的因子，来判断它到底是不是一个素数。当然，循环不用从 2 开始到 n-1 结束，因为对于大于 1 的正整数，因子应该都是成对出现的，所以循环到 $\sqrt{n}$ 就可以结束了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

"""
判断一个数是不是素数

Version: 1.0
Author: Penry
"""

num = int(input("请输入你要判断的整数："))
end = int(num ** 0.5) + 1
is_prime = True
for i in range(2, end):
    if num % i == 0:
        is_prime = False
        break
if is_prime and num != 1:
    print("%d是素数" % num)
else:
    print("%d不是素数" % num)

说明：上面的代码中我们用了布尔型的变量is_prime，我们先将它赋值为True，假设num是一个素数；接下来，我们在 2 到 num ** 0.5 的范围寻找num的因子，如果找到了num的因子，那么它一定不是素数，此时我们将is_prime赋值为False，同时使用break关键字终止循环结构；最后，我们根据is_prime的值是True还是False来给出不同的输出。

2.5.2 练习题2：最大公约数

要求：输入两个正整数，计算它们的最大公约数。
提示：两个数的最大公约数是两个数的公共因子中最大的那个。例如，12 和 18 的最大公约数是 6，因为 12 和 18 的公共因子有 1、2、3、6，其中最大的因子是 6。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

"""
输入两个正整数，计算它们的最大公约数。

Version: 1.0
Author: Penry
"""

a = int(input())
b = int(input())
print(f"{a=}，{b=}")
if a > b:
    a, b = b, a
for factor in range(a, 0, -1):
    if a % factor == 0 and b % factor == 0:
        print(f"最大公约数为{factor}")
        break

用上面代码的找最大公约数在执行效率是有问题的。假如a的值是999999999998，b的值是999999999999，很显然两个数是互质的，最大公约数为 1。但是我们使用上面的代码，循环会重复999999999998次，这通常是难以接受的。我们可以使用欧几里得算法来找最大公约数，它能帮我们更快的得到想要的结果，整体数学原理见补充材料。代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

"""
输入两个正整数，计算它们的最大公约数。

Version: 1.1
Author: Penry
"""

a = int(input())
b = int(input())
print(f"{a=}，{b=}")
if a > b:
    a, b = b, a
while b % a != 0:
    b,a = a, b % a
print(f"最大公约数是{a}")

2.5.3 补充材料：欧几里得算法最大公约数原理的严格证明

欧几里得算法（也称辗转相除法）用于求解两个正整数 $a$ 和 $b$ 的最大公约数（$\gcd(a, b)$），其核心原理基于以下恒等式：

$$\gcd(a, b) = \gcd(b, a \mod b)$$

其中 $a \mod b$ 表示 $a$ 除以 $b$ 的余数（记作 $r$），满足 $0 \leq r < b$ 且 $a = bq + r$（$q$ 为商）。下面提供一个完整的数学证明，分为两部分：正确性证明（即该恒等式成立）和终止性证明（即算法在有限步内结束）。

正确性证明

设 $a$ 和 $b$ 是正整数，且 $a \geq b$（如果 $b > a$，交换两者不影响结果）。定义 $r = a \mod b$，则有：

$$a = bq + r, \quad 0 \leq r < b$$

需要证明：

$$\gcd(a, b) = \gcd(b, r)$$

证明：

1. 设 $d = \gcd(a, b)$。
   则 $d \mid a$（$d$ 整除 $a$)) 且 $d \mid b$。
   由 $r = a - bq$（因为 $a = bq + r$），可得：

   $$d \mid (a - bq) \implies d \mid r$$

   （因为如果 $d \mid a$ 和 $d \mid b$，则 $d$ 整除它们的线性组合 $a - bq$）。
   因此，$d \mid b$ 且 $d \mid r$，所以 $d$ 是 $b$ 和 $r$ 的一个公约数。

2. 设 $e = \gcd(b, r)$。
   则 $e \mid b$ 且 $e \mid r$。
   由 $a = bq + r$，可得：

   $$e \mid (bq + r) \implies e \mid a$$

   （因为如果 $e \mid b$ 和 $e \mid r$，则 $e$ 整除它们的线性组合 $bq + r$）。
   因此，$e \mid a$ 且 $e \mid b$，所以 $e$ 是 $a$ 和 $b$ 的一个公约数。

3. 比较 $d$ 和 $e$：

   • 因为 $d = \gcd(a, b)$ 是 $a$ 和 $b$ 的最大公约数，且 $e$ 是 $a$ 和 $b$ 的公约数，故 $e \leq d$。
   • 因为 $e = \gcd(b, r)$ 是 $b$ 和 $r$ 的最大公约数，且 $d$ 是 $b$ 和 $r$ 的公约数（由步骤 1），故 $d \leq e$。
     结合两者，有 $d = e$，即：

   $$\gcd(a, b) = \gcd(b, r)$$

结论： 对任意正整数 $a$ 和 $b$，$$\gcd(a, b) = \gcd(b, a \mod b)$$ 成立。

终止性证明

欧几里得算法通过反复应用恒等式 $$\gcd(a, b) = \gcd(b, r)$$ 逐步减小问题规模，直到余数为 0。算法过程如下：

• 初始化：设 $r_{-2} = a$, $r_{-1} = b$（假设 $a \geq b$）。
• 迭代：对于第 $k$ 步（$k \geq 0$），计算：

  $$r_k = r_{k-2} \mod r_{k-1}, \quad 0 \leq r_k < r_{k-1}$$

• 当某步余数 $r_n = 0$ 时停止，此时 $$\gcd(a, b) = r_{n-1}$$。

证明算法在有限步内终止：

• 在每一步迭代中，定义余数序列 $r_0, r_1, r_2, \ldots$，其中：
  • $r_0 = a \mod b$（初始余数），
  • 后续 $r_k = r_{k-2} \mod r_{k-1}$。
• 由余数定义，满足 $0 \leq r_k < r_{k-1}$（当 $r_{k-1} > 0$ 时）。
• 因此，序列 $r_0, r_1, r_2, \ldots$ 是非负整数序列，并严格递减：

  $$b > r_0 > r_1 > r_2 > \cdots \geq 0$$

• 因为序列递减且非负（所有 $r_k \geq 0$))，所以余数每次至少减少 1，序列必定在有限步内达到 0。
• 设迭代次数为 $n$，则当 $r_n = 0$ 时，有：

  $$\gcd(a, b) = \gcd(r_{n-1}, r_n) = \gcd(r_{n-1}, 0) = r_{n-1}$$

  （因为 $\gcd(m, 0) = m$ 对于正整数 $m$ 成立）。

说明： 最坏情况下，算法步数由斐波那契数列控制，但余数序列长度上限为 $O(\log(\min(a, b)))$，确保效率。

2.5.3 练习题3：猜数字游戏

要求：计算机出一个1到100之间的随机数，玩家输入自己猜的数字，计算机给出对应的提示信息（大一点、小一点或猜对了），如果玩家猜中了数字，计算机提示"恭喜你，猜对了！"并结束游戏；如果玩家没有猜中数字，计算机提示"游戏结束，游戏结束！"并结束游戏。
提示：计算机随机生成一个1到100之间的整数，玩家输入自己猜的数字，计算机给出对应的提示信息（大一点、小一点或猜对了），如果玩家猜中了数字，计算机提示"恭喜你，猜对了！"并结束游戏；如果玩家没有猜中数字，计算机提示"游戏结束，游戏结束！"并结束游戏。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

"""
猜数字游戏

Version: 1.0
Author: Penry
"""

import random

answer = random.randint(1,101)
counter = 0
while True:
    counter += 1
    number = int(input('请输入: '))
    if number < answer:
        print('请大一些')
    elif number > answer:
        print('请小一些')
    else:
        print('恭喜你猜对了！')
        break
    if counter == 7:
        print('你的智商余额明显不足')
        break
print('你总共猜了%d次' % counter)

3 分支和循环结构实战

3.1 实战1：100以内的素数

要求：输出100以内的素数。
说明：素数指的是只能被 1 和自身整除的正整数（不包括 1），之前我们写过判断素数的代码，这里相当于是一个升级版本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

"""
输出100以内的素数

Version: 1.0
Author: Penry
"""

prime_lst = []

for num in range(2,100):
    is_prime = True
    for factor in range(2,int(num ** 0.5 +1)):
        if num % factor == 0:
            is_prime = False
            break
    if is_prime:
        prime_lst.append(num)

print(prime_lst)

3.2 实战2：斐波那契数列

要求：输出斐波那契数列中的前 20 个数。
说明：斐波那契数列（Fibonacci sequence），通常也被称作黄金分割数列，是意大利数学家莱昂纳多·斐波那契（Leonardoda Fibonacci）在《计算之书》中研究理想假设条件下兔子成长率问题而引入的数列，因此这个数列也常被戏称为“兔子数列”。斐波那契数列的特点是数列的前两个数都是 1，从第三个数开始，每个数都是它前面两个数的和。按照这个规律，斐波那契数列的前 10 个数是：1, 1, 2, 3, 5, 8, 13, 21, 34, 55。斐波那契数列在现代物理、准晶体结构、化学等领域都有直接的应用。

1
2
3
4
5
6
7
8
9
10
11
12

"""
输出斐波那契数列中的前 20 个数

Version: 1.0
Author: Penry
"""

a,b = 0,1

for _ in range(20):
    a,b = b, a+b
    print(a, end=' ')

3.3 实战3：寻找水仙花数

要求：找出 100 到 999 范围内的所有水仙花数。
提示：在数论中，水仙花数（narcissistic number）也被称为超完全数字不变数、自恋数、自幂数、阿姆斯特朗数，它是一个 $N$ 位非负整数，其各位数字的 $N$ 次方和刚好等于该数本身，例如：$153 = 1^3 + 5^3 + 3^3$，所以 153 是一个水仙花数；$1634 = 1^4 + 6^4 + 3^4 + 4^4$，所以 1634 也是一个水仙花数。对于三位数，解题的关键是将它拆分为个位、十位、百位，再判断是否满足水仙花数的要求，这一点利用 Python 中的//和%运算符其实很容易做到。

1
2
3
4
5
6
7
8
9
10
11
12
13

"""
找出100到999范围内的所有水仙花数

Version: 1.0
Author: Penry
"""

for num in range(100, 1000):
    a = num // 100
    b = num // 10 % 10
    c = num % 10
    if num == a ** 3 + b ** 3 + c ** 3:
        print(num)

3.4 实战4：不知位数的正整数反转

要求：将一个正整数反转。
提示：将一个正整数反转，例如：123456变成654321。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
将一个正整数反转

Version: 1.0
Author: Penry
"""

num = int(input("请输入要反转的整数: "))
print(num)
reversed_num = 0
while num > 0:
    reversed_num = reversed_num * 10 + num % 10
    num //= 10
print(reversed_num)

3.5 实战5：百钱百鸡问题

要求：百钱百鸡是我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
提示：设鸡翁、鸡母、鸡雏的个数分别为 $x$、$y$、$z$，则 $x$、$y$、$z$ 满足以下条件：

• $x + y + z = 100$
• $5x + 3y + z/3 = 100$
• $x$、$y$、$z$ 都是正整数

1
2
3
4
5
6
7
8
9
10
11
12

"""
百钱白鸡问题

Version: 1.0
Author: Penry
"""

for x in range(0,21):
    for y in range(0,34):
        for z in range(0,101,3):
            if x*5 + y*3 + z//3 == 100 and x + y + z == 100:
                print('公鸡：%d只，母鸡：%d只，小鸡：%d只' % (x,y,z))

上面使用的方法叫做穷举法，也称为暴力搜索法，这种方法通过一项一项的列举备选解决方案中所有可能的候选项，并检查每个候选项是否符合问题的描述，最终得到问题的解。上面的代码中，我们使用了嵌套的循环结构，假设公鸡有x只，显然x的取值范围是 0 到 20，假设母鸡有y只，它的取值范围是 0 到 33，假设小鸡有z只，它的取值范围是 0 到 99 且取值是 3 的倍数。这样，我们设置好 100 只鸡的条件x + y + z == 100，设置好 100 块钱的条件5 * x + 3 * y + z // 3 == 100，当两个条件同时满足时，就是问题的正确答案，我们用print函数输出它。这种方法看起来比较笨拙，但对于运算能力非常强大的计算机来说，通常都是一个可行的甚至是不错的选择，只要问题的解存在就能够找到它。

事实上，上面的代码还有更好的写法，既然我们已经假设公鸡有x只，母鸡有y只，那么小鸡的数量就应该是100 - x - y，这样减少一个条件，我们就可以把上面三层嵌套的for-in循环改写为两层嵌套的for-in循环。循环次数减少了，代码的执行效率就有了显著的提升，如下所示。

1
2
3
4
5
6
7
8
9
10
11
12

"""
百钱白鸡问题

Version: 1.1
Author: Penry
"""

for x in range(0, 21):
    for y in range(0, 34):
        z = 100 - x - y
        if z % 3 == 0 and 5 * x + 3 * y + z / 3 == 100:
            print("公鸡: %d只, 母鸡: %d只, 小鸡: %d只" % (x, y, z))

3.6 实战6：CRAPS赌博游戏

说明：CRAPS又称花旗骰，是美国拉斯维加斯非常受欢迎的一种的桌上赌博游戏。该游戏使用两粒骰子，玩家通过摇两粒骰子获得点数进行游戏。简化后的规则是：玩家第一次摇骰子如果摇出了 7 点或 11 点，玩家胜；玩家第一次如果摇出 2 点、3 点或 12 点，庄家胜；玩家如果摇出其他点数则游戏继续，玩家重新摇骰子，如果玩家摇出了 7 点，庄家胜；如果玩家摇出了第一次摇的点数，玩家胜；其他点数玩家继续摇骰子，直到分出胜负。为了增加代码的趣味性，我们设定游戏开始时玩家有 1000 元的赌注，每局游戏开始之前，玩家先下注，如果玩家获胜就可以获得对应下注金额的奖励，如果庄家获胜，玩家就会输掉自己下注的金额。游戏结束的条件是玩家破产（输光所有的赌注）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

"""
CRAPS赌博游戏

Version: 1.0
Author: Penry
"""

import random

property = 1000  # 起始资金
flag_participate = 'y'  # 判断是否继续游戏

while property > 0 and flag_participate == 'y':
    print(f"您目前的总资产为：{property}$")

    # 下注
    while True:
        bet = int(input("请下注："))
        if 0 < bet <= property:
            break
        else:
            print("下注金额无效，请重新输入！")

    # 开始游戏，用两个1到6均匀分布的随机数相加模拟摇两颗色子得到的点数
    first_point = random.randint(1,6) + random.randint(1,6)
    print(f"玩家摇出了{first_point}点")

    if first_point == 7 or first_point == 11:
        print("玩家胜！")
        property += bet
    elif first_point == 2 or first_point == 3 or first_point == 12:
        print("庄家胜！")
        property -= bet
    else:
        # 玩家继续摇色子，如果玩家摇出了 7 点，庄家胜；如果玩家摇出了第一次摇的点数，玩家胜；其他点数玩家继续摇骰子，直到分出胜负。
        while True:
            current_point = random.randint(1,6) + random.randint(1,6)
            print(f"玩家摇出了{current_point}点")
            if current_point == 7:
                print("庄家胜！")
                property -= bet
                break
            elif current_point == first_point:
                print("玩家胜！")
                property += bet
                break
    # 是否继续游戏
    while property > 0:
        flag_participate = input("是否继续游戏？(y/n)")
        if flag_participate == "y" or flag_participate == "n":
            break
        else:
            print("输入无效，请重新输入！")

print(f"您最终的资产为：{property}$")

3.7 实战7：完美数

要求：找出 10000 以内的完美数。
说明：完美数（Perfect number），又称完全数或完备数，是一些特殊的自然数。它所有的真因子（即除了自身以外的因子）的和（即因子函数），恰好等于它本身。例如：6（$6 = 1 + 2 + 3$）和 28（$28 = 1 + 2 + 4 + 7 + 14$）就是完美数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
找出10000以内的完美数

Version: 1.0
Author: Penry
"""

for num in range(1, 10000):
    sum = 0
    for factor in range(1, num):
        if num % factor == 0:
            sum += factor
    if sum == num:
        print(num)

Day3

0 常用数据结构之列表-1

在开始本节课的内容之前，我们先给大家一个编程任务，将一颗色子掷 6000 次，统计每种点数出现的次数。这个任务对大家来说应该是非常简单的，我们可以用 1 到 6 均匀分布的随机数来模拟掷色子，然后用 6 个变量分别记录每个点数出现的次数，相信通过前面的学习，大家都能比较顺利的写出下面的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

"""
掷骰子

Version: 1.0
Author: Penry
"""

import random

i = 6000
p1,p2,p3,p4,p5,p6 = 0,0,0,0,0,0

while i > 0:
    point = random.randint(1, 6)
    match point:
        case 1: p1 += 1
        case 2: p2 += 1
        case 3: p3 += 1
        case 4: p4 += 1
        case 5: p5 += 1
        case 6: p6 += 1
    i -= 1

for i in range(1, 7):
    print(f"点数{i}出现的次数为{eval(f'p{i}')}")

说明：eval() 是 Python 的一个内置函数，作用是将字符串解析为 Python 代码并执行

上面的代码非常有多么“丑陋”相信就不用我多说了。当然，更为可怕的是，如果我们要掷两颗或者掷更多的色子，然后统计每种点数出现的次数，那就需要定义更多的变量，写更多的分支结构，大家想想都会感到恶心。讲到这里，相信大家心中已经有一个疑问了：有没有办法用一个变量来保存多个数据，有没有办法用统一的代码对多个数据进行操作？答案是肯定的，在 Python 语言中我们可以通过容器型变量来保存和操作多个数据，我们首先为大家介绍列表（list）这种新的数据类型。

0.1 创建列表

在 Python 中，列表是由一系元素按特定顺序构成的数据序列，这就意味着如果我们定义一个列表类型的变量，可以用它来保存多个数据。在 Python 中，可以使用[]字面量语法来定义列表，列表中的多个元素用逗号进行分隔，代码如下所示。

1
2
3
4
5
6

items1 = [35, 12, 99, 68, 55, 35, 87]
items2 = ['Python', 'Java', 'Go', 'Kotlin']
items3 = [100, 12.3, 'Python', True]
print(items1)
print(items2)
print(items3)

说明：列表中可以有重复元素，例如items1中的35；列表中可以有不同类型的元素，例如items3中有int类型、float类型、str类型和bool类型的元素，但是我们通常并不建议将不同类型的元素放在同一个列表中，主要是操作起来极为不便。

我们可以使用type函数来查看变量的类型，代码如下所示。

1
2
3
4
5
6

items1 = [35, 12, 99, 68, 55, 35, 87]
items2 = ['Python', 'Java', 'Go', 'Kotlin']
items3 = [100, 12.3, 'Python', True]
print(type(items1))
print(type(items2))
print(type(items3))

因为列表可以保存多个元素，它是一种容器型的数据类型，所以我们在给列表类型的变量起名字时，变量名通常用复数形式的单词。

除此以外，还可以通过 Python 内置的list函数将其他序列变成列表。准确的说，list并不是一个普通的函数，它是创建列表对象的构造器，后面的课程会为大家介绍对象和构造器这些概念。

1
2
3
4

items1 = list(range(1, 10))
items2 = list('hello')
print(items1)
print(items2)

说明：range(1, 10)会产生1到9的整数序列，给到list构造器中，会创建出由1到9的整数构成的列表。字符串是字符构成的序列，上面的list('hello')用字符串hello的字符作为列表元素，创建了列表对象。

0.2 列表的运算

我们可以使用+运算符实现两个列表的拼接，拼接运算会将两个列表中的元素连接起来放到一个列表中，代码如下所示。

1
2
3
4
5
6
7

items5 = [35, 12, 99, 45, 66]
items6 = [45, 58, 29]
items7 = ['Python', 'Java', 'JavaScript']
print(items5 + items6)
print(items6 + items7)
items5 += items6
print(items5)

我们可以使用*运算符实现列表的重复运算，*运算符会将列表元素重复指定的次数，如下所示。

1
2

items8 = ['hello'] * 3
print(items8)

我们可以使用in或not in运算符判断一个元素在不在列表中，如下所示。

1
2
3

items9 = ['Python', 'Java', 'Go', 'Kotlin']
print('Python' in items9)
print('Ruby' not in items9)

由于列表中有多个元素，而且元素是按照特定顺序放在列表中的，所以当我们想操作列表中的某个元素时，可以使用[]运算符，通过在[]中指定元素的位置来访问该元素，这种运算称为索引运算。需要说明的是，[]的元素位置可以是0到N - 1的整数，也可以是-1到-N的整数，分别称为正向索引和反向索引，其中N代表列表元素的个数。对于正向索引，[0]可以访问列表中的第一个元素，[N - 1]可以访问最后一个元素；对于反向索引，[-1]可以访问列表中的最后一个元素，[-N]可以访问第一个元素，代码如下所示。

1
2
3
4
5
6
7
8
9
10
11

items8 = ['apple', 'waxberry', 'pitaya', 'peach', 'watermelon']
print(items8[0])
print(items8[2])
print(items8[4])
items8[2] = 'durian'
print(items8)
print(items8[-5])
print(items8[-4])
print(items8[-1])
items8[-4] = 'strawberry'
print(items8)

在使用索引运算的时候要避免出现索引越界的情况，对于上面的items8，如果我们访问items8[5]或items8[-6]，就会引发IndexError错误，导致程序崩溃，对应的错误信息是：list index out of range，翻译成中文就是“数组索引超出范围”。因为对于只有五个元素的列表items8，有效的正向索引是0到4，有效的反向索引是-1到-5。

如果希望一次性访问列表中的多个元素，我们可以使用切片运算。切片运算是形如[start:end:stride]的运算符，其中start代表访问列表元素的起始位置，end代表访问列表元素的终止位置（终止位置的元素无法访问），而stride则代表了跨度，简单的说就是位置的增量，比如我们访问的第一个元素在start位置，那么第二个元素就在start + stride位置，当然start + stride要小于end。如下代码展示了如何使用切片运算符访问列表元素。

1
2
3
4
5
6
7

items8 = ['apple', 'waxberry', 'pitaya', 'peach', 'watermelon']
print(items8[1:3])
print(items8[1:3:1])
print(items8[1:-2])
print(items8[1:])
print(items8[-2:-6:-1])
print(items8[:])

如果start值等于0，那么在使用切片运算符时可以将其省略；如果end值等于N，N代表列表元素的个数，那么在使用切片运算符时可以将其省略；如果stride值等于1，那么在使用切片运算符时也可以将其省略。

事实上，我们还可以通过切片操作修改列表中的元素，例如如下代码：

1
2
3
4
5

items8 = ['apple', 'waxberry', 'pitaya', 'peach', 'watermelon']
items8[1:3] = ['banana', 'orange']
print(items8)
items8[1:3] = ['banana', 'orange', 'pear', 'strawberry', 'pitaya']
print(items8)