一、第一个 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，回车之后就可以立马得到计算结果：

>>> 100+200
300

• 打印指定文字：

如果要让 Python 打印出指定的文字，可以用 print() 函数，然后把希望打印的文字用单引号或者双引号括起来，单不能混用单引号和双引号：

>>> print('hello, world')
hello, world

• 执行 .py 文件：

在命令行模式下，可以执行 python 进入 Python 交互环境，也可以执行 python hello.py 运行一个 .py 文件。

此外，在命令行模式运行 .py 文件和 Python 交互环境下直接运行 Python 代码有所不同。Python 交互环境会把每一行 Python 代码的结果自动打印出来，但是，直接运行 Python 代码却不会默认打印。

比如，写入一个 calc.py 的文件，内容如下：

100+200+300

然后再命令行模式下执行：

C:\work>python calc.py

发现什么输出都没有，这是正常的。想要输出结果，必须用 print() 打印出来，如下所示：

print(100+200+300)

再执行，就可以看到结果：

C:\work>python calc.py
600

最后，Python交互模式的代码时输入一行，执行一行，二命令行模式下直接运行 .py 文件时一次性执行该文件内的所有代码。

可见，Python 交互模式 主要是为了调试 Python 代码用的，也便于初学者学习，它 不是正式运行 Python 代码的环境。

1.3 SyntaxError 语法错误

如果遇到了 SyntaxError，表示输入的 Python 代码有语法错误，最常见的一种语法错误是使用了中文括号 （ 和 ）：

>>> print（'hello'）
  File "<stdin>", line 1
    print（'hello'）
         ^
SyntaxError: invalid character '（' (U+FF08)

或者使用了中文引号 “ 和 ”：

>>> print(“hello”)
  File "<stdin>", line 1
    print(“hello”)
          ^
SyntaxError: invalid character '“' (U+201C)

1.4 输入和输出

• 输入：

如果要让用户从电脑输入一些字符串怎么办？Python 提供了一个 input() 方法。可以让用户输入字符串，并存放到一个变量里。

比如输入用户的名字：

>>> name = input();
Michael

当你输入 name=input() 并按下回车后，Python 交互式命令行就在等待你的输入了。这时，你可以输入任意字符，然后按回车后挖成输入。

输入完成后，不会有任何提示，Python 交互式命令又回到 >>> 状态了。我们刚才输入的内容存放到 name 变量里了。可以直接输入 name 查看变量内容，如下所示：

>>> name
'Michael'

• 输出：

用 print() 在括号中加上字符串，就可以像屏幕上输出指定的文字。比如输出 'hello, world'，用代码实现如下：

>>> print('hello, world')
hello, world

print() 函数也可以接受多个字符串，用英文逗号 , 隔开，就可以连成一串输出：

>>> print('The quick brown fox', 'jumps over', 'the lazy dog')
The quick brown fox jumps over the lazy dog

print() 函数会依次打印每个字符串，遇到英文逗号 , 会输出一个空格。因此，输出的字符串是这样拼起来的：

print() 也可以打印整数，或者计算结果：

>>> print(300)
300
>>> print(100 + 200)
300

因此，我们可以把计算 100 + 200 的结果打印得更漂亮一些：

>>> print('100 + 200 =', 100 + 200)
100 + 200 = 300

有了输入和输出，我们就可以把上次打印 'hello, world' 的程序改成有意义一些：

name = input('please enter your name: ')
print('hello', name)

再次运行这个程序，你会发现，程序一运行，会首先打印出 please enter your name: 。这样用户就可以根据提示，输入姓名后，得到 hello, xxx 的输出：

每次运行该程序，根据用户输入的不通，输出结果也会不同。

---

二、Python 基础

2.1 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，内容如下：

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' 语句，它在计算机中的执行顺序是：

1. 先在内存中创建一个字符串 “python”；
2. 在程序栈寄存器中创建一个变量 s；
3. 最后把 “python” 字符串的地址赋值给 s。

字符串的常见操作：

• 切片（slice）：语法为 [ 起始 : 结束 : 步长]，选取的区间为 “左闭右开”。“起始” 为空，则默认从头开始；“结束” 为空，则默认一直到结尾；步长为空，则默认为1。

>>> s = '学习Python'
>>> s[0], s[-1], s[3:], s[::-1]
('学', 'n', 'ython', 'nohtyP习学')

• 替换（可以使用正则表达式）

>>> s = '学习Python'
>>> s.replace('Python', 'Java')
'学习Java'

• 查找：

  find()：返回子字符串第一次出现的索引，找不到返回 -1。

  index()：返回子字符串第一次出现的索引，找不到抛出 ValueError。

  rfind()：返回子字符串最后一次出现的索引，找不到返回 -1。

  rindex()：返回子字符串最后一次出现的索引，找不到抛出 ValueError。

>>> 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()：检查是否所有字母小写。

>>> s = '学习Python'
>>> s.upper() # 转大写
'学习PYTHON'
>>> s.swapcase() # 交换大小写
'学习pYTHON'
>>> s.istitle() # 是否首字母大写，其余小写
True
>>> s.islower() # 是否小写
False

• 去空格：

  strip([chars])：去除字符串两端的指定字符（默认为空白字符）。

  lstrip([chars])：去除字符串左侧的指定字符（默认为空白字符）。

  rstrip([chars])：出去字符串右侧的指定字符（默认为空白字符）。

>>> s = ' 学习Python '
>>> s.strip()
'学习Python'

• 格式化：有以下三种方式可以进行格式化：（推荐使用 format() 格式化字符串）

方式一：使用 % 格式化

常见的占位符如下。

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

有几个 %? 占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个 %?，括号可以省略。

>>> s1 = '%s %s' % ('Windriver', 21)
>>> s1
'Windriver 21'

其中格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

# 是否补0、保留位数
>>> '%2d-%02d' % (3, 1)
' 3-01'
>>> '%.2f' % 3.1415926
'3.14'

如果你不太确定应该用什么，%s 永远起作用，它会把任何数据类型转换为字符串：

>>> 'Age: %s. Gender: %s' %

方式二：使用 format() 格式化

方式三：使用 f-string 格式化

>>> 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()。

>>> l = ['2024', '12', '09', '22:00']
>>> '-'.join(l)
'2024-12-09-22:00'
>>> '-'.join(l).split('-')
['2024', '12', '09', '22:00']

• 字符串编码：所有 Python 字符串都是 Unicode 字符串，当需要将文件保存到外设或进行网络传输时，就要进行编码转换，以提高效率。

# 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） 是写在方括号 [] 之间，用英文逗号 , 分隔开的元素列表，列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字、字符串甚至可以包含列表（嵌套），列表中的元素是可以改变的。

示例：

>>> 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） 与列表类似，不同之处在于 元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开，组中的元素类型也可以不相同。

示例：

>>> 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() 而不是 {}，因为 {} 是用来创建一个空字典。

• 集合可以进行的操作：集合运算、添加、删除。（集合不能被切片，也不能根据坐标查询）

示例：

>>> 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） 是一种映射类型，它的元素是键值对，字典的关键字必须为不可变类型，且不能重复。创建空字典使用 {}。

示例：

>>> 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)
3

7）空值

空值 是 Python 里一个特殊的值，用 None 表示。

注意：None 不能理解为 0，因为 0 是有意义的，而 None 是一个特殊的控制。

此外，Python 还允许创建自定义数据类型，我们后面会继续讲到。

2.3 变量、常量

1）变量

变量 的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量命名的规则：

变量名必须由 英文大小写（区分大小写）、数字 和 下划线 _ 组成。

1. 小写字母： 变量名通常使用小写字母，单词之间用下划线分隔，这种风格称为 蛇形命名法（Snake Case）。
2. 简洁明了： 变量名应简短且具有描述性，避免使用模糊不清的缩写。
3. 避免使用关键字： 不要使用 Python 的关键字作为变量名，如 if、for、while 等。
4. 避免使用数字开头： 变量名不应以数字开头，这会导致语法错误。

举个例子：

a = 1
b = 'T007'
c = True

• 可以看到，变量可以是整数、字符串、布尔值等各种类型。

这种变量本身类型不固定的语言称之为 动态语言，与之对应的是 静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如 Java 是静态语言，赋值语言如下：（//表示 Java 注释）

int a = 123; // a是整数类型变量
a = "ABC"; // 报错：不能把字符串赋给整型变量

和静态语言相比，动态语言更灵活，就是这个原因。

最后，理解变量在计算机内存中的表示也非常重要。当我们编写如下代码：

a = 'ABC'

Python 解释器做了两件事：

1. 在内存中创建了一个 ABC 的字符串；
2. 在内存中创建了一个名为 a 的变量，并把它指向 ABC。

Python 中，变量和变量值的关系实际上和 Java 的 “地址引用” 以及 C 的 “指针” 是相同的概念。

所以大家可以猜到，没错！Python 中也是通过 垃圾收集器（GC） 来进行内存回收的！

2）常量

所谓 常量 就是指不能改变的变量，比如常用的数学常数 π 就是一个常量。在 Python 中，通常用 全部大写 + 下划线 的变量名来表示常量。如下所示：

PI = 3.14159265359

但事实上 PI 仍然是一个变量，Python 根本没有任何机制保证 PI 不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量 PI 的值，也不会报编译错误。

最后解释一下整数的除法为什么也是精确的。

在 Python 中，有两种除法，一种除法是 /。如下所示：

>>> 10 / 3
3.3333333333333335

/ 除法计算结果是 浮点数，即使是两个整数恰好整除，结果也是浮点数。如下所示：

>>> 9 / 3
3.0

还有一种除法是 //，称为 地板除，即相除之后向下取整为整数。如下所示：

>>> 10 // 3
3

因为 // 地板除只取结果的整数部分，所以 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 语句实现：

age = 20
if age >= 18
    print('your age is', age)
    print('adult')

根据 Python 的缩进规则，如果 if 语句判断是 True，就把缩进的两行 print() 语句执行了，否则，什么也不做。执行结果如下：

也可以给 if 添加一个 else 语句，如果 if 判断是 Flase，不执行 if 的内容，执行 else 内容：

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。

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

补充： if 判断条件还可以简写，比如写：

if x:
 print('True')

只要 x 是非零数值、非空字符串、非空list等，就判断为 True，否则为 False。

3）input() 条件判断报错

当我们使用 input() 读取用户的输入后，如果我们直接进行条件判断会报错，如下代码所示：

birth = input('birth: ')
if birth < 2000:
    print('00前')
else:
    print('00后')

执行后，输入 1982，结果报错：

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() 函数来进行转换：

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 语句编写的代码如下所示：

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 语句的基础上，除了可以匹配简单的单个值外，还可以匹配多个值、匹配一定范围，并且把匹配后的值绑定到变量：

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 语句的基础上，支持数组匹配。

代码示例如下：

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 中的每个元素迭代出来，看例子：

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

执行这段代码，会依次打印 names 的每一个元素，结果如下：

所以 for x in ... 循环就是把每个元素代入变量 x，然后执行缩进块的语句。

再比如，我们像计算 1~10 的整数之和，可以用一个 sum 变量做累加，代码如下：

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。正确写法如下：

sum = 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 的整数：

>>> list(range(5))
[0, 1, 2, 3, 4]

那么上述计算 1~10 的整数之和，就可以简写为这样：

sum = 0
for x in range(11):
    sum = sum + x
print(sum)

执行结果：

2）while 循环

while循环 是指只要条件满足，就不断循环，条件不满足时则退出循环。

比如，我们要计算 100 以内所有奇数之和，可以用 while 循环实现：

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