目录
-
- [一、第一个 Python 程序](#一、第一个 Python 程序)
-
- [1.1 命令行模式、Python 交互模式](#1.1 命令行模式、Python 交互模式)
- [1.2 Python的执行方式](#1.2 Python的执行方式)
- [1.3 SyntaxError 语法错误](#1.3 SyntaxError 语法错误)
- [1.4 输入和输出](#1.4 输入和输出)
- [二、Python 基础](#二、Python 基础)
-
- [2.1 Python 语法](#2.1 Python 语法)
- [2.2 数据类型](#2.2 数据类型)
-
- [1）Number 数字](#1）Number 数字)
- [2）String 字符串](#2）String 字符串)
- [3）List 列表](#3）List 列表)
- [4）Tuple 元组](#4）Tuple 元组)
- [5）Set 集合](#5）Set 集合)
- [6）Dict 字典](#6）Dict 字典)
- 7）空值
- [2.3 变量、常量](#2.3 变量、常量)
- [2.4 条件判断](#2.4 条件判断)
- [2.5 模式匹配、复杂匹配](#2.5 模式匹配、复杂匹配)
- [2.6 循环](#2.6 循环)
-
- [1）for 循环](#1）for 循环)
- [2）while 循环](#2）while 循环)
一、第一个 Python 程序
在正式编写第一个 Python 程序前，我们先复习一下什么是命令行模式和 Python 交互模式。
1.1 命令行模式、Python 交互模式
命令行模式：
在 Windows 开始菜单选择 "命令提示符"，就进入到命令行模式，它的提示符类似 C:\>：
Python 交互模式：
在命令行模式下敲命令 python，就看到类似如下的一堆文本输出，然后就进入到 Python 交互模式，它的提示符是 >>>。
在 Python 交互模式下输入 exit() 并回车，就退出了 Python 交互模式，并回到命令行模式：
也可以直接通过开始菜单选择 Python 3.10 (64-bit) 菜单选项，直接进入 Python 交互模式。
了解了如何启动和推出 Python 的交互模式，我们就可以正式开始编写 Python 代码了。
1.2 Python的执行方式
- 数学计算：
在交互模式的提示符 >>> 下，直接输入代码，按回车，就可以立刻得到代码执行结果。现在，试试输入 100+200，回车之后就可以立马得到计算结果：
python
>>> 100+200
300- 打印指定文字：
如果要让 Python 打印出指定的文字，可以用 print() 函数，然后把希望打印的文字用单引号或者双引号括起来，单不能混用单引号和双引号：
python
>>> print('hello, world')
hello, world- 执行 .py 文件：
在命令行模式下，可以执行 python 进入 Python 交互环境，也可以执行 python hello.py 运行一个 .py 文件。
此外，在命令行模式运行 .py 文件和 Python 交互环境下直接运行 Python 代码有所不同。Python 交互环境会把每一行 Python 代码的结果自动打印出来，但是，直接运行 Python 代码却不会默认打印。
比如，写入一个 calc.py 的文件，内容如下：
python
100+200+300然后再命令行模式下执行：
python
C:\work>python calc.py发现什么输出都没有，这是正常的。想要输出结果，必须用 print() 打印出来，如下所示：
python
print(100+200+300)再执行，就可以看到结果：
shell
C:\work>python calc.py
600最后，Python交互模式的代码时输入一行，执行一行，二命令行模式下直接运行 .py 文件时一次性执行该文件内的所有代码。
可见，Python 交互模式 主要是为了调试 Python 代码用的，也便于初学者学习，它 不是正式运行 Python 代码的环境。
1.3 SyntaxError 语法错误
如果遇到了 SyntaxError，表示输入的 Python 代码有语法错误，最常见的一种语法错误是使用了中文括号 （ 和 ）：
python
>>> print（'hello'）
File "<stdin>", line 1
print（'hello'）
^
SyntaxError: invalid character '（' (U+FF08)或者使用了中文引号 " 和 "：
python
>>> print("hello")
File "<stdin>", line 1
print("hello")
^
SyntaxError: invalid character '"' (U+201C)1.4 输入和输出
- 输入：
如果要让用户从电脑输入一些字符串怎么办？Python 提供了一个 input() 方法。可以让用户输入字符串，并存放到一个变量里。
比如输入用户的名字：
python
>>> name = input();
Michael当你输入 name=input() 并按下回车后，Python 交互式命令行就在等待你的输入了。这时，你可以输入任意字符，然后按回车后挖成输入。
输入完成后，不会有任何提示，Python 交互式命令又回到 >>> 状态了。我们刚才输入的内容存放到 name 变量里了。可以直接输入 name 查看变量内容，如下所示：
python
>>> name
'Michael'- 输出：
用 print() 在括号中加上字符串，就可以像屏幕上输出指定的文字。比如输出 'hello, world'，用代码实现如下：
python
>>> print('hello, world')
hello, worldprint() 函数也可以接受多个字符串，用英文逗号 , 隔开，就可以连成一串输出：
python
>>> print('The quick brown fox', 'jumps over', 'the lazy dog')
The quick brown fox jumps over the lazy dogprint() 函数会依次打印每个字符串，遇到英文逗号 , 会输出一个空格。因此，输出的字符串是这样拼起来的：
print() 也可以打印整数，或者计算结果：
python
>>> print(300)
300
>>> print(100 + 200)
300因此，我们可以把计算 100 + 200 的结果打印得更漂亮一些：
python
>>> print('100 + 200 =', 100 + 200)
100 + 200 = 300有了输入和输出，我们就可以把上次打印 'hello, world' 的程序改成有意义一些：
python
name = input('please enter your name: ')
print('hello', name)再次运行这个程序，你会发现，程序一运行，会首先打印出 please enter your name: 。这样用户就可以根据提示，输入姓名后，得到 hello, xxx 的输出：
每次运行该程序，根据用户输入的不通，输出结果也会不同。
二、Python 基础
2.1 Python 语法
Python 的语法比较简单，采用缩进方式，写出来的代码就像下面的样子：
python
# print absolute value of an interger:
a = 1000
if a >= 0:
print(a)
else:
print(-a)- 注释：
以 # 开头的语句是注释，注释的作用是方便代码阅读，解释器会忽略掉注释。
- 缩进：
缩进有利有弊。
好处1：强迫你写出格式化的代码，应该始终坚持使用 4个空格作为缩进。
好处2：强迫你写出缩进较少的代码，你会倾向于把一段很长的代码拆分成若干函数，从而得到缩进较少的代码。
坏处："复制-粘贴"功能失效了。IDE 很难像格式化 Java 代码那样格式化 Python 代码，当你重构代码时，粘贴过去的代码必须重新检查缩进是否正常。
- 大小写敏感：
请务必注意，Python 程序是大小写敏感的，如果写错了大小写，程序会报错。
2.2 数据类型
Python3 中有 六个标准的数据类型：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Sets（集合）、Dictionary（字典）。
Python3 的六个标准数据类型中：
- 不可变数据（3个）： Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3个）： List（列表）、Dictionary（字典）、Set（集合）。
1）Number 数字
Python3 支持 int、float、bool、complex（复数）。
数字类型是顾名思义用来存储数值的，需要记住的是，有些和 Java 的字符串差不多的是，如果改变了数据类型的值，将重新分配内存空间。
Python 支持三种不同的数值类型：
整型（Int）：通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有大小限制的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。浮点型（float）：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 × 10的2次方 = 250）。复数（complex）：复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a, b) 表示，复数的实部 a 和虚部 b 都是浮点型。
示例：创建一个 number.py，内容如下：
python
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "test" # 字符串
print(counter)
print(miles)
print(name)执行结果：
数字类型转换：
int(x)：将 x 转换为一个整数。float(x)：将 x 转换到一个浮点数。complex(x)：将 x 转换到一个复数，实数部分为 x，虚数部分为 0。complex(x, y)：将 x 和 y 转换到一个复数，实数部分为 x，叙述部分为 y。x 和 y 是数字表达式。
和别的语言一样，数字类型支持各种常见的运算，不过 Python 的运算比别的大多数常见语言都更加丰富。此外，还有大量丰富的方法，提供更高效的开发。
数值运算示例：
+：加法，例：5 + 4 = 9-：减法，例：4.3 - 2 = 2.3*：乘法，例：3 * 7 = 21/：除法，得到一个浮点数，例：2 / 4 = 0.5//：除法，得到一个整数，例：2 // 4 = 0%：取余，例：17 % 3 = 2**：乘方，例：2 ** 10 = 1024
2）String 字符串
创建字符串可以使用单引号 '、双引号 "、三单引号 ''' 和三双引号 """，其中三引号可以多行定义字符串，Python 不支持单字符类型，单字符在 Python 也是作为一个字符串使用。
我们定义一个 s='python' 语句，它在计算机中的执行顺序是：
- 先在内存中创建一个字符串 "python"；
- 在程序栈寄存器中创建一个变量 s；
- 最后把 "python" 字符串的地址赋值给 s。
字符串的常见操作：
切片（slice）：语法为 [ 起始 : 结束 : 步长] ，选取的区间为 "左闭右开"。"起始" 为空，则默认从头开始；"结束" 为空，则默认一直到结尾；步长为空，则默认为1。
python
>>> s = '学习Python'
>>> s[0], s[-1], s[3:], s[::-1]
('学', 'n', 'ython', 'nohtyP习学')替换（可以使用正则表达式）
python
>>> s = '学习Python'
>>> s.replace('Python', 'Java')
'学习Java'-
查找：find()：返回子字符串第一次出现的索引，找不到返回
-1。index()：返回子字符串第一次出现的索引，找不到抛出
ValueError。rfind()：返回子字符串最后一次出现的索引，找不到返回
-1。rindex()：返回子字符串最后一次出现的索引，找不到抛出
ValueError。
python
>>> s = '学习Python'
>>> s.find('P') # 返回第一次出现的子串的下标（从0开始）
2
>>> s.find('h', 2) # 设定从下标2开始查找
5
>>> s.find('2333') # 查找不到会返回-1
-1
>>> s.index('y') # 返回第一次出现的子串的下标
3
>>> s.index('a') # 不同于find()，查找不到会抛出异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found-
转大小写：upper()：将所有字母转大写。
lower()：将所有字母转小写。
swapcase()：将所有字母交换大小写。
capitalize()：将第一个字母转换为大写，其余字母转换为小写。
istitle()：检查字符串是否为标题格式（首个单词的首字母大写，其余小写）。
isupper()：检查是否所有字母大写。
islower()：检查是否所有字母小写。
python
>>> s = '学习Python'
>>> s.upper() # 转大写
'学习PYTHON'
>>> s.swapcase() # 交换大小写
'学习pYTHON'
>>> s.istitle() # 是否首字母大写，其余小写
True
>>> s.islower() # 是否小写
False-
去空格：strip([chars])：去除字符串两端的指定字符（默认为空白字符）。
lstrip([chars])：去除字符串左侧的指定字符（默认为空白字符）。
rstrip([chars])：出去字符串右侧的指定字符（默认为空白字符）。
python
>>> s = ' 学习Python '
>>> s.strip()
'学习Python'格式化：有以下三种方式可以进行格式化：（推荐使用 format() 格式化字符串）
方式一：使用
%格式化
常见的占位符如下。
| 占位符 | 替换内容 |
|---|---|
| %d | 整数 |
| %f | 浮点数 |
| %s | 字符串 |
| %x | 十六进制整数 |
有几个 %? 占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个 %?，括号可以省略。
python
>>> s1 = '%s %s' % ('Windriver', 21)
>>> s1
'Windriver 21'其中格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
python
# 是否补0、保留位数
>>> '%2d-%02d' % (3, 1)
' 3-01'
>>> '%.2f' % 3.1415926
'3.14'如果你不太确定应该用什么，%s 永远起作用，它会把任何数据类型转换为字符串：
python
>>> 'Age: %s. Gender: %s' %方式二：使用
format()格式化
方式三：使用f-string格式化
python
>>> s2 = '{}, {}'.format('Windriver', 21)
>>> s2
'Windriver, 21'
>>> s3 = '{0}, {1}, {0}'.format('Windriver', 21)
>>> s3
'Windriver, 21, Windriver'
>>> s4 = '{name}: {age}'.format(name='Windriver', age=21)
>>> s4
'Windriver: 21'连接与分割：使用+连接字符串，每次操作会重新计算、开辟、释放内存，效率很低，推荐使用 join()。
python
>>> l = ['2024', '12', '09', '22:00']
>>> '-'.join(l)
'2024-12-09-22:00'
>>> '-'.join(l).split('-')
['2024', '12', '09', '22:00']字符串编码：所有 Python 字符串都是 Unicode 字符串，当需要将文件保存到外设或进行网络传输时，就要进行编码转换，以提高效率。
python
# encode() 将字符转换为字节
>>> s = '学习Python'
>>> print(s.encode()) # 默认输出 UTF-8 编码格式。（输出内容中b开头表示当前内容为二进制）
b'\xe5\xad\xa6\xe4\xb9\xa0Python'
>>> print(s.encode('gbk')) # 输出为 GBK 编码格式
b'\xd1\xa7\xcf\xb0Python'
# decode() 将字节转换为字符
>>> s.encode().decode('utf8')
'学习Python'
>>> s.encode('gbk').decode('gbk')
'学习Python'3）List 列表
类似 Java List 集合接口。
列表（List） 是写在方括号 [] 之间，用英文逗号 , 分隔开的元素列表，列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字、字符串甚至可以包含列表（嵌套），列表中的元素是可以改变的。
示例：
python
>>> Weekday = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
# list 根据坐标查询
>>> Weekday[0]
'Monday'
# list 根据内容查询（重复的话，仅返回第一个坐标）
>>> Weekday.index('Wednesday')
2
# list 增加元素
>>> Weekday.append('new')
>>> Weekday
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'new']
# list 删除
>>> Weekday.remove('Thursday')
>>> Weekday
['Monday', 'Tuesday', 'Wednesday', 'Friday', 'new']4）Tuple 元组
元组（Tuple） 与列表类似，不同之处在于 元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开，组中的元素类型也可以不相同。
示例：
python
>>> letters = ('a', 'b', 'c', 'd', 'e', 'f', 'g')
# Tuple 根据坐标查询
>>> letters[0]
'a'
# Tuple 输出子元组
>>> letters[0:3]
('a', 'b', 'c')5）Set 集合
类似 Java Set 集合接口。
集合（Set） 是一个无序不重复元素的序列，使用大括号 {} 或者 set() 函数创建集合。
注意：创建一个空集合必须使用 set() 而不是 {}，因为 {} 是用来创建一个空字典。
- 集合可以进行的操作：集合运算、添加、删除。（集合不能被切片，也不能根据坐标查询）
示例：
python
>>> a_set = {1, 2, 3, 4}
# Sets 添加
>>> a_set.add(5)
>>> a_set
{1, 2, 3, 4, 5}
# Sets 删除
>>> a_set.discard(5)
>>> a_set
{1, 2, 3, 4}6）Dict 字典
类似 Java Map 集合接口。
字典（Dict） 是一种映射类型，它的元素是键值对，字典的关键字必须为不可变类型，且不能重复。创建空字典使用 {}。
示例：
python
>>> logo_code = {
... 'BAIDU': 'Baidu',
... 'SINA': 'Sina',
... 'YOKU': 'Youku'
... }
>>> logo_code
{'BAIDU': 'Baidu', 'SINA': 'Sina', 'YOKU': 'Youku'}
# 输出键为 'one' 的值
>>> logo_code['SINA']
'Sina'
# 输出所有健
>>> logo_code.keys()
dict_keys(['BAIDU', 'SINA', 'YOKU'])
# 输出所有值
>>> logo_code.values()
dict_values(['Baidu', 'Sina', 'Youku'])
# 输出键值对个数
>>> len(logo_code)
37）空值
空值 是 Python 里一个特殊的值，用 None 表示。
注意：None 不能理解为
0，因为0是有意义的，而 None 是一个特殊的控制。
此外，Python 还允许创建自定义数据类型，我们后面会继续讲到。
2.3 变量、常量
1）变量
变量 的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。
变量命名的规则：
变量名必须由 英文大小写 （区分大小写）、数字 和 下划线 _ 组成。
- 小写字母： 变量名通常使用小写字母，单词之间用下划线分隔，这种风格称为
蛇形命名法（Snake Case）。 - 简洁明了： 变量名应简短且具有描述性，避免使用模糊不清的缩写。
- 避免使用关键字： 不要使用 Python 的关键字作为变量名，如
if、for、while等。 - 避免使用数字开头： 变量名不应以数字开头，这会导致语法错误。
举个例子：
python
a = 1
b = 'T007'
c = True- 可以看到，变量可以是整数、字符串、布尔值等各种类型。
这种变量本身类型不固定的语言称之为 动态语言 ，与之对应的是 静态语言 。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如 Java 是静态语言，赋值语言如下：（//表示 Java 注释）
java
int a = 123; // a是整数类型变量
a = "ABC"; // 报错：不能把字符串赋给整型变量和静态语言相比，动态语言更灵活，就是这个原因。
最后，理解变量在计算机内存中的表示也非常重要。当我们编写如下代码：
python
a = 'ABC'Python 解释器做了两件事：
- 在内存中创建了一个
ABC的字符串； - 在内存中创建了一个名为
a的变量，并把它指向ABC。
Python 中，变量和变量值的关系实际上和 Java 的 "地址引用" 以及 C 的 "指针" 是相同的概念。
所以大家可以猜到，没错！Python 中也是通过 垃圾收集器（GC） 来进行内存回收的！
2）常量
所谓 常量 就是指不能改变的变量，比如常用的数学常数 π 就是一个常量。在 Python 中，通常用 全部大写 + 下划线 的变量名来表示常量。如下所示：
python
PI = 3.14159265359但事实上 PI 仍然是一个变量，Python 根本没有任何机制保证 PI 不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量 PI 的值，也不会报编译错误。
最后解释一下整数的除法为什么也是精确的。
在 Python 中，有两种除法，一种除法是 /。如下所示：
python
>>> 10 / 3
3.3333333333333335/ 除法计算结果是 浮点数，即使是两个整数恰好整除，结果也是浮点数。如下所示：
python
>>> 9 / 3
3.0还有一种除法是 //，称为 地板除，即相除之后向下取整为整数。如下所示：
python
>>> 10 // 3
3因为 // 地板除只取结果的整数部分，所以 Python 还提供一个余数运算，可以得到两个整数相除的余数，如下所示：
python
>>> 10 % 3
1无论整数做 // 地板除还是取余数，结果永远是整数。所以，整数运算结果永远是精确的。
总结：
Python 支持多种数据类型，在计算机内部，可以把任何数据都看成一个 "对象"，而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来。
对变量赋值 x = y 是把变量 x 指向阵阵的对象，该对象是变量 y 所指向的。随后对变量 y 的赋值 不影响 变量 x 的指向。
注意：
1.Python 的整数没有大小限制 ，而某些语言的整数根据其存储长度是有大小限制的，例如 Java 对 32 位整数的范围限制在
-2147483648至21473647。2.Python 的浮点数也没有大小限制 ，da你是超出一定返回就直接表示为
inf（无限大）。
2.4 条件判断
计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。
1）条件判断语法
条件判断语法如下：
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
2）举例说明
比如，输入用户年龄，根据年龄打印不同的内容，在 Python 程序中，用 if 语句实现：
python
age = 20
if age >= 18
print('your age is', age)
print('adult')根据 Python 的缩进规则，如果 if 语句判断是 True，就把缩进的两行 print() 语句执行了，否则，什么也不做。执行结果如下：
也可以给 if 添加一个 else 语句，如果 if 判断是 Flase，不执行 if 的内容，执行 else 内容：
python
age = 3
if age >= 18:
print('your age is', age)
print('adult')
else:
print('your age is', age)
print('teenager')注意不要少写了冒号 :，执行结果如下：
当然上面的判断是很粗略的，完全可以用 elif 做更细致的判断：
elif是else if的缩写，完全可以有多个elif。
python
age = 3
if age >= 18:
print('adult')
elif age >= 6:
print('teenager')
else:
print('kid')补充： if 判断条件还可以简写，比如写：
pythonif x: print('True')只要
x是非零数值、非空字符串、非空list等，就判断为True，否则为False。
3）input() 条件判断报错
当我们使用 input() 读取用户的输入后，如果我们直接进行条件判断会报错，如下代码所示：
python
birth = input('birth: ')
if birth < 2000:
print('00前')
else:
print('00后')执行后，输入 1982，结果报错：
python
Traceback (most recent call last):
File "D:\pythonProject\python-demo\test\test.py", line 2, in <module>
if birth < 2000:
TypeError: '<' not supported between instances of 'str' and 'int'这是因为 input() 返回的数据类型是 str，str 不能直接和整数比较，必须先把 str 转换成整数。Python 提供了 int() 函数来进行转换：
python
birth = input('birth: ')
birth = int(birth)
if birth < 2000:
print('00前')
else:
print('00后')再次运行，就可以得到正确的结果。
2.5 模式匹配、复杂匹配
1）模式匹配
模式匹配：使用 match 语句来针对某个变量匹配若干种情况。避免用 if ... elif ... elif ... else ... 判断，可读性较差。
例如，某个学生的成绩只能是 A、B、C，用 match 语句编写的代码如下所示：
python
score = 'B'
match score:
case 'A':
print('score is A.')
case 'B':
print('score is B.')
case 'C':
print('score is C.')
case _: # _表示匹配到其他任何情况
print('score is ???.')使用 match 语句时，我们依次用 case xxx 匹配，并且可以在最后（且仅能在最后）加一个 case _ 表示 "任意值"，相比一连串的 if ... elif ... 更易读。
2）复杂匹配
复杂匹配：即在 match 语句的基础上，除了可以匹配简单的单个值外，还可以匹配多个值、匹配一定范围，并且把匹配后的值绑定到变量：
python
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:
print('11~18 years old.')
case 19:
print('19 years old.')
case _:
print('not sure.')case x if x < 10：表示当 age < 10 成立时匹配，且赋值给 x。case 10：仅匹配单个值。case 11|12|...|18：能匹配多个值，用|分隔。
3）匹配列表
匹配列表：即在 match 语句的基础上，支持数组匹配。
代码示例如下：
python
args = ['gcc', 'hello.c', 'world.c']
# args = ['clean']
# args = ['gcc']
match args:
# 如果仅出现 gcc，报错：
case ['gcc']:
print('gcc: missing source ')
# 出现 gcc，且至少指定了一个文件
case ['gcc', file1, *files]:
print('gcc compile: ' + file1 + ',' + ','.join(files))
# 仅出现 clean
case ['clean']
print('clean')
case _:
print('invalid command.')case ['gcc']：表示列表仅有 'gcc' 一个字符串，没有指定文件名，报错；case ['gcc', file1, *files]：表示列表第一个字符串是gcc，第二个字符串绑定到变量file1，后面的任意个字符串绑定到*files（符号*的作用将在 函数的参数 中讲解），它实际上表示至少指定一个文件；case ['clean']：表示列表仅有clean一个字符串；case _：表示其他所有情况。
2.6 循环
Python 的循环有两种，一种是 for 循环，另一种是 while 循环。
1）for 循环
for ... in 循环是依次把 List 或 Tuple 中的每个元素迭代出来，看例子：
python
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)执行这段代码，会依次打印 names 的每一个元素，结果如下：
所以 for x in ... 循环就是把每个元素代入变量 x，然后执行缩进块的语句。
再比如，我们像计算 1~10 的整数之和，可以用一个 sum 变量做累加，代码如下：
python
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + x
print(sum)注意： 如果是在 Python 的交互模式下，或者在编写模块时，
for循环后面是必须要加一个else语句的，用于在 for 循环正常结束后（即没有遇到break）执行，否则会报SyntaxError: invalid syntax。正确写法如下：
pythonsum = 0 for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]: sum = sum + x else: print(sum)
为了简化操作，Python 提供了一个 range() 函数，可以生成一个整数序列，再通过 list() 函数可以转换为 list。比如 range(5) 生成的序列是从 0 开始小于 5 的整数：
python
>>> list(range(5))
[0, 1, 2, 3, 4]那么上述计算 1~10 的整数之和，就可以简写为这样：
python
sum = 0
for x in range(11):
sum = sum + x
print(sum)执行结果：
2）while 循环
while循环 是指只要条件满足，就不断循环，条件不满足时则退出循环。
比如，我们要计算 100 以内所有奇数之和，可以用 while 循环实现：
python
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)在循环内部变量 n 不断自减，直到变为 -1 时，不再满足 while 条件，循环退出。
整理完毕，完结撒花~ 🌻
参考地址：
1.Python课程，https://liaoxuefeng.com/books/python/introduction/index.html
2.学习Python，这一篇管够（入门|基础|进阶|实战），https://zhuanlan.zhihu.com/p/421726412
3.Python学习------尾递归及装饰器优化，https://cloud.tencent.com/developer/article/1964203
4.【Python】Python变量和函数的命名规范，https://blog.csdn.net/baidu_22713341/article/details/139345722