Python基础指令(上)
Python基础指令上
- 常量和表达式
- 变量和类型
-
- 1. 什么是变量
- 2. 变量的语法
-
- 2.1 定义变量
- 2.2 使用变量
- 3. 变量的类型
- 4. 为什么要有这么多类型
- 5. 动态类型特性
- 注释
- 输入输出
-
- 1. 程序与用户的交互
- 2. 通过控制台输出
- 3. 通过控制台输入
- 运算符
-
- 1. 算术运算符
- 2. 关系运算符
- 3. 逻辑运算符
- 4. 赋值运算符
- 条件语句
- 缩进和代码块
- 空语句 pass
- 循环语句
-
- 1. while循环
- 2. for 循环
常量和表达式
print(1 + 2 - 3)
print(1 + 2 * 3)
print(1 + 2 / 3)
运行结果
0
7
1.6666666666666665
print 是一个 Python 内置的函数
可以使用 + - * / ( ) 等运算符进行算术运算. 先算乘除, 后算加减.
运算符和数字之间, 可以没有空格, 也可以有多个空格. 但是一般习惯上写一个空格
形如1 + 2 - 3这样是算式, 在编程语言中称为 表达式, 算式的运算结果, 称为 表达式的返回值
其中1 , 2 , 3这种称为 字面值常量, + - * / 这种称为 运算符 或者 操作符
注意: 熟悉 C / C++ 的同学可能认为, 2 / 3 结果为 0 (小数部分被截断), 但是在 Python 中得到的结果则是一个小数,更符合日常使用的直觉
变量和类型
1. 什么是变量
在Python中，变量是用于存储数据值的标识符。这些标识符可以是字母、数字和下划线的组合，但必须遵循一些命名规则，比如变量名不能以数字开头，不能包含空格，等等。Python中的变量是动态类型的，这意味着你不需要提前声明变量的数据类型，Python会根据赋给变量的值自动确定其类型。
以下是一个简单的Python变量示例：
x = 10 # 创建一个整数类型的变量x并赋值为10
name = "John" # 创建一个字符串类型的变量name并赋值为"John"
is_student = True # 创建一个布尔类型的变量is_student并赋值为True
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2 #创建一个浮点数类型的变量total并赋值为四个小数的方差
与C语言相比，Python中的变量有一些显著的区别：
- 动态类型：在C语言中，你需要在声明变量时明确指定其数据类型，而在Python中，变量的数据类型由赋给它的值自动确定。这使得Python更加灵活和简洁。
- 无需声明：在C语言中，你必须在使用变量之前显式声明它，而Python中不需要。你可以直接给一个变量赋值，Python会自动创建它。
- 不需要分号：在C语言中，语句通常以分号结束，而Python使用缩进来表示代码块，不需要分号。
- 更高级的数据类型：Python具有许多内置的高级数据类型，如列表、字典、集合和元组，这些数据类型使得在Python中处理复杂数据结构更加方便。
- 垃圾回收：Python具有自动内存管理和垃圾回收机制，不需要手动管理内存分配和释放。
总的来说，Python相对于C语言来说更加简洁和易于学习，但在某些情况下可能会牺牲一些性能。在选择编程语言时，需要根据项目需求和性能要求来进行权衡。
注意:
x,name,is_student,total均为变量.
** 在 Python 中表示乘方运算. ** 2 即为求平方
2. 变量的语法
2.1 定义变量
a = 10
创建变量的语句非常简单, 其中
a为变量名. 当我们创建很多个变量的时候, 就可以用名字来进行区分.
=为赋值运算符, 表示把=右侧的数据放到=左侧的空间中
注意: 变量的名字要遵守一定规则
硬性规则(务必遵守)
变量名由数字字母下划线构成.
数字不能开头.
变量名不能和 “关键字” 重复.
变量名大小写敏感. num 和 Num 是两个不同的变量名.
软性规则(建议遵守)
变量名使用有描述性的单词来表示, 尽量表达出变量的作用.
一个变量名可以由多个单词构成, 长一点没关系, 但是含义要清晰.
当变量名包含多个单词的时候, 建议使用 “驼峰命名法”. 形如
totalCount,personInfo这种, 除了首个单词外, 剩余单词首字母大写.
数学上, 变量通常使用 x, y, z 这种简单的英文字母或者拉丁字母表示. 但是在编程中不建议这样使用.原因是编程中, 一个程序里通常会同时创建出很多个变量. 如果只是使用单个字母表示, 在变量多了的时候, 就很难记住哪个变量是干啥的, 从而给维护程序带来了一定的困难. 因此我们更建议使用带有明确描述性的名字, 来表示变量的用途.
2.2 使用变量
读取变量的值
a = 10
print(a)
修改变量的值
a = 20
print(a)
在 Python 中, 修改变量也是使用 = 运算, 看起来和定义变量没有明显区别.
当然, 也可以用一个变量的值赋给另外一个变量
a = 10
b = 20
a = b
print(a)
print(b)
3. 变量的类型
Python的整数类型（int）、浮点数类型（float）、字符串类型（str）和逻辑值（bool）与C语言中的相应类型有一些区别：
-
整数类型（int）：
- Python中的整数类型是动态的，不需要指定类型，Python会根据赋给变量的值自动确定其类型。
- Python的整数类型可以表示任意大小的整数，没有固定的范围限制，这称为“无限精度整数”（arbitrary-precision integers）。
- 在C语言中，整数类型的大小取决于编译器和平台，通常有固定的位数和范围。
在Python中，整数类型可以表示非常大的整数，而不需要担心溢出问题。例如：
x = 1234567890123456789012345678901234567890 print(x) print(type(x))这个数字在C语言中可能会导致溢出或精度问题，但在Python中没有问题。
1234567890123456789012345678901234567890 <class 'int'> -
浮点数类型（float）：
- Python中的浮点数类型也是动态的，不需要显式指定类型。
- Python使用双精度浮点数标准（IEEE 754），通常支持15到17位的十进制精度。
- 在C语言中，浮点数类型的大小和精度取决于编译器和平台，可以是单精度或双精度浮点数。
Python的浮点数类型具有双精度精度，可以表示小数值，例如：
y = 3.14159265358979323846 print(y) print(type(y))这个浮点数在Python中有足够的精度来表示π的近似值。在C语言中，浮点数精度取决于编译器和平台，可能不够精确。
3.141592653589793 <class 'float'> -
字符串类型（str）：
- Python的字符串类型是Unicode字符串，这意味着它可以表示世界上大多数字符集的字符，包括ASCII字符和非ASCII字符。
- Python的字符串是不可变的，这意味着一旦创建，就不能修改它们的内容。
- 在C语言中，字符串通常是字符数组，使用null终止，而且可以被修改。
Python的字符串类型可以包含各种字符，包括Unicode字符。这使得在处理不同字符集的文本数据时非常方便，例如：
name = "李雷" print(name) print(type(name))这是一个包含中文字符的字符串，Python可以轻松地处理它。在C语言中，处理Unicode字符可能会更加复杂，需要使用宽字符或Unicode转换函数。
李雷 <class 'str'>
总的来说，Python中的整数和浮点数类型具有更大的灵活性和精度，而字符串类型具有更好的Unicode支持和不可变性。这些差异使Python在处理各种数据类型时更加方便，但也需要在性能方面进行权衡，因为C语言通常在处理底层数据时更加高效。根据具体需求，可以选择使用不同的语言和数据类型。
注意: 在 Python 中, 单引号构成的字符串和双引号构成的字符串, 没有区别. 'hello' 和"hello"是完全等价的.
可以使用 len 函数来获取字符串的长度
a = 'hello'
print(len(a))
输出5
可以使用 + 针对两个字符串进行拼接
a = 'hello
b = 'world'
print(a + b)
输出helloworld
此处是两个字符串相加. 不能拿字符串和整数/浮点数相加
- 逻辑值（bool）:
- Python中的布尔类型有两个值：True（真）和False（假）。
- 布尔类型通常用于条件判断，例如在if语句中。
- Python的布尔类型是大小写敏感的，必须使用大写字母开头的True和False，小写的true和false不是布尔值。
is_true = True
is_false = False
if is_true:
print("这是True")
if not is_false:
print("这是False")
print(type(is_true))
print(type(is_false))
输出
这是True
这是False
<class 'bool'>
<class 'bool'>
- 其他
除了上述类型之外, Python 中还有 list, tuple, dict, 自定义类型 等等. 我们后面单独介绍
4. 为什么要有这么多类型
类型决定了数据在内存中占据多大空间.
例如 float 类型在内存中占据 8 个字节.
计算机里面使用二进制来表示数据. 也就是每个位只能表示 0 或者 1.
1 个二进制位, 就称为是一个 “比特”, 8 个二进制位, 就称为一个 “字节” (Byte)
一个 float 变量在内存中占据 8 个字节空间, 也就是 64 个二进制位，我的电脑有 16GB 的内存空间, 也就是一共有 1024 * 1024 * 1024 * 8 这么多的二进制位.
类型其实约定了能对这个变量做什么样的操作.
例如 int / float 类型的变量, 可以进行 + - * / 等操作
而 str 类型的变量, 只能进行 + (并且行为是字符串拼接), 不能进行 - * / , 但是还能使用 len 等其他操作.
总结: 类型系统其实是在对变量进行 “归类”. 相同类型的变量(数据) 往往具有类似的特性和使用规则
5. 动态类型特性
在 Python 中, 一个变量是什么类型, 是可以在 “程序运行” 过程中发生变化的. 这个特性称为 “动态类型”
a = 10
print(type(a))
a = 'hello'
print(type(a))
输出:
<class 'int'>
<class 'str'>
在程序执行过程中, a 的类型刚开始是 int, 后面变成了 str
C++/Java 这样的语言则不允许这样的操作. 一个变量定义后类型就是固定的了. 这种特性则称为 “静态类型”
动态类型特性是一把双刃剑
对于中小型程序, 可以大大的解约代码量(比如写一段代码就可以同时支持多种类型).
对于大型程序, 则提高了模块之间的交互成本. (程序猿 A 提供的代码难以被 B 理解)
注释
在Python中，有两种主要类型的注释：单行注释和多行注释。注释用于在代码中添加说明或注解，不会被解释器执行。
- 单行注释： 单行注释以井号
#开头，后面的内容被视为注释，直到行尾结束。单行注释通常用于添加对代码的简短说明。
示例：
# 这是一个单行注释
x = 5 # 这是赋值语句，将5赋给变量x
- 多行注释： Python中没有像C或C++那样的块注释，但你可以使用三重引号
'''或"""来创建多行字符串，并将其放在代码中来实现多行注释的效果。虽然这实际上是创建了一个字符串，但如果不将其分配给变量，它将被视为注释。
示例：
'''
这是一个
多行注释
它实际上是一个多行字符串，但没有分配给变量
'''
print("Hello, World!")
或者使用双重引号：
"""
这也是一个
多行注释
"""
print("Hello, World!")
请注意，多行字符串虽然可以用于多行注释，但通常情况下，开发者更倾向于使用单行注释和函数/类/方法的文档字符串（docstring）来添加注释和文档说明。
示例：
def add(x, y):
"""
这是一个函数的文档字符串
它用于计算两个数字的和
"""
return x + y
这样的文档字符串可以使用help()函数查看，也有工具可以生成文档。在实际开发中，文档字符串对于代码的可读性和维护性非常有帮助。
注释的规范
- 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
- 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
- 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.
- 积极向上: 注释中不要包含负能量(例如 领导 SB 等). 据说上过新闻被开了,手动滑稽
输入输出
1. 程序与用户的交互
程序需要和用户进行交互
用户把信息传递给程序的过程, 称为 “输入”.
程序把结果展示给用户的过程, 称为 “输出”.
输入输出的最基本的方法就是控制台. 用户通过控制台输入一些字符串, 程序再通过控制台打印出一些字符串
PyCharm 运行程序, 下方弹出的窗口就可以视为是控制台
windows 自带的 cmd 程序, 也可以视为是控制台
输入输出的最常见方法是图形化界面
Python 当然也可以用来开发图形化界面的程序. 但是图形化程序开发本身是一个大话题,我们后面再做详细介绍
2. 通过控制台输出
比如输出一个其他类型的变量
a = 10
print(a)
b = True
print(b)
输出
10
True
更多的时候, 我们希望能够输出的内容是混合了字符串和变量的
示例: 输出 num = 10
num = 10
print(f'num = {num}')
使用
f作为前缀的字符串, 称为f-string
里面可以使用{ }来内嵌一个其他的变量/表达式
3. 通过控制台输入
python 使用 input 函数, 从控制台读取用户的输入
num = 0
num = input('请输入一个整数: ')
print(f'你输入的整数是 {num}')
输入后输出
请输入一个整数: 2
你输入的整数是 2
input 的参数相当于一个 “提示信息”, 也可以没有.
input 的返回值就是用户输入的内容. 是字符串类型
a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
print(f'a + b = {a + b}')
输入后输出
请输入第一个整数: 20
请输入第二个整数: 23
a + b = 2023
此处的结果是字符串拼接, 不是算术运算. 如果要想进行算术运算, 需要先转换类型
a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
a = int(a)
b = int(b)
print(f'a + b = {a + b}')
输入后输出
请输入第一个整数: 20
请输入第二个整数: 23
a + b = 43
通过
int( )把变量转成了int类型.
类似的, 使用float( ), bool( ), str( )等可以完成对应的类型转换
代码示例: 输入 4 个小数, 求 4 个小数的平均值
a = input('请输入第一个数字: ')
b = input('请输入第二个数字: ')
c = input('请输入第三个数字: ')
d = input('请输入第四个数字: ')
a = float(a)
b = float(b)
c = float(c)
d = float(d)
avg = (a + b + c + d) / 4
print(f'平均值: {avg}')
输入后输出
请输入第一个数字: 21.2
请输入第二个数字: 20.3
请输入第三个数字: 21.4
请输入第四个数字: 21.5
平均值: 21.1
代码示例: 利用海伦公式计算三角形面积
import math
a=float(input("输入直角三角形第一条边"))
b=float(input("输入直角三角形第二条边"))
c=float(input("输入直角三角形第三条边"))
#计算海伦公式中p的值,即半周长
p=(a+b+c)/2
s=math.sqrt(p*(p-a)*(p-b)*(p-c))
print(s)
输入后输出
输入直角三角形第一条边3
输入直角三角形第二条边4
输入直角三角形第三条边5
6.0
运算符
1. 算术运算符
像 + - * / % ** // 这种进行算术运算的运算符, 称为 算术运算符
- 和其他语言一样
/中不能用 0 作为除数. 否则会抛出异常
print(10 / 0)
输出
Traceback (most recent call last):
File "C:\Users\xzq20\PycharmProjects\pythonProject1\hello.py", line 1, in <module>
print(10 / 0)
~~~^~~
ZeroDivisionError: division by zero
异常 是编程语言中的一种常见机制, 表示程序运行过程中, 出现了一些 “意外情况”, 导致程序不能继续往下执行了
整数 / 整数结果可能是小数. 而不会截断
print(1 / 2)
输出
0.5
%不是 “百分数”, 而是求余数
print(7 % 2)
输出
1
**是求乘方. 不光能算整数次方, 还能算小数次方
print(4 ** 2)
print(4 ** 0.5)
输出
16
2.0
//是取整除法(也叫地板除). 整数除以整数, 结果还是整数(舍弃小数部分, 并向下取整. 不是四舍五入)
print(7 // 2)
print(-7 // 2)
输出
3
-4
2. 关系运算符
像 < <= > >= == != 这一系列的运算符称为 关系运算符, 它们是在比较操作数之间的关系.
其中
<=是 “小于等于”
>=是 “大于等于”
==是 “等于”
!=是 “不等于”
如果关系符合, 则表达式返回 True. 如果关系不符合, 则表达式返回 False
a = 10
b = 20
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)
输出
True
True
False
False
False
True
关系运算符不光针对整数/浮点数进行比较, 还能针对字符串进行比较
a = 'hello'
b = 'world'
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)
输出
True
True
False
False
False
True
直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / C++ 不同).
字符串比较大小, 规则是 “字典序” (相当于C++中的map应用)
对于浮点数来说, 不要使用 == 判定相等
print(0.1 + 0.2 == 0.3)
输出
False
浮点数在计算机中的表示并不是精确的! 在计算过程中, 就容易出现非常小的误差
print(0.1)
print(0.2)
print(0.3)
print(0.1 + 0.2)
输出
0.1
0.2
0.3
0.30000000000000004
可以看到, 0.1 + 0.2 的结果并非是 0.3 , 而是带了个小尾巴. 虽然这个尾巴非常小了, 但是 == 是锱铢必较的, 仍然会导致 == 的结果为 False
不止是 Python 如此, 主流编程语言都是如此. 这个是 IEEE754 标准规定的浮点数格式所引入的问题,这个在我之前的C语言博客中有提到
正确的比较方式: 不再严格比较相等了, 而是判定差值小于允许的误差范围
a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)
实际工程实践中, 误差在所难免, 只要保证误差在合理范围内即可
3. 逻辑运算符
像 and or not 这一系列的运算符称为 逻辑运算符.
and 并且:两侧操作数均为 True, 最终结果为 True. 否则为 False. (一假则假)
or 或者: 两侧操作数均为 False, 最终结果为 False. 否则为 True. (一真则真)
not 逻辑取反: 操作数本身为 True, 则返回 False. 本身为 False, 则返回 True
a = 10
b = 20
c = 30
print(a < b and b < c)
print(a < b and b > c)
print(a > b or b > c)
print(a < b or b > c)
print(not a < b)
print(not a > b)
输出
True
False
False
True
False
True
一种特殊写法
a < b and b < c这个操作等价于a < b < c. 这个设定和大部分编程语言都不相同
短路求值
和其他编程语言类似, Python 也存在短路求值的规则.
对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行.
对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行
print(10 > 20 and 10 / 0 == 1)
print(10 < 20 or 10 / 0 == 1)
输出
False
True
4. 赋值运算符
=的使用
=表示赋值. 这个我们已经用过很多次了. 注意和==区分.
=除了基本的用法之外, 还可以同时针对多个变量进行赋值
链式赋值
a = b = 10
多元赋值
a, b = 10, 20
代码实例: 交换两个变量
基础写法（类似C的写法)
a = 10
b = 20
tmp = a
a = b
b = tmp
基于多元赋值
a = 10
b = 20
a, b = b, a
- 复合赋值运算符
Python 还有一些 复合赋值运算符. 例如 += -= *= /= %=
其中 a += 1 等价于 a = a + 1 . 其他复合赋值运算符也是同理
a = 10
a = a + 1
print(a)
b = 10
b += 1
print(b)
注意:
像 C / C++ 中, 存在 ++ -- 这样的自增/自减运算符. Python 中则不支持这种运算. 如果需要使用,则直接使用 += 1 或者 -= 1
++ -- 最大的问题就是容易分不清前置和后置的区别. 这一点 Python 语法在设计的时候就进行了规避, 避免出现这种不直观, 并且容易混淆的语法.
除了上述之外, Python 中还有一些运算符, 比如 身份运算符 (is, is not), 成员运算符 (in, not in), 位运算符( & | ~ ^ << >>) 等.
条件语句
Python 中使用 if else 关键字表示条件语句
if
if expression:
do_something1
do_something2
next_something
如果 expression 值为 True, 则执行 do_something1, do_something2, next_something
如果 expression 值为 False, 则只执行 next_something, 不执行 do_something1, do_something2
if - else
if expression:
do_something1
else:
do_something2
如果 expression 值为 True, 则执行 do_something1
如果 expression 值为 False, 则执行 do_something2
if - elif - else
if expression1:
do_something1
elif expression2:
do_something2
else:
do_something3
如果 expression1 值为 True, 则执行 do_something1
如果 expression1 值为 False, 并且 expression2 为 True 则执行 do_something2
如果 expression1 值为 False, 并且 expression2 为 False 则执行 do_something3
注意: Python中的条件语句写法, 和很多编程语言不太一样
if 后面的条件表达式, 没有 ( ), 使用 : 作为结尾.
if / else 命中条件后要执行的 “语句块”, 使用 缩进 (通常是 4 个空格或者 1 个 tab)来表示, 而不是 { }
对于多条件分支, 不是写作 else if, 而是 elif.
缩进和代码块
代码块 指的是一组放在一起执行的代码.
在 Python 中使用缩进表示代码块. 不同级别的缩进, 程序的执行效果是不同的
代码1
a = input("请输入一个整数: ")
if a == "1":
print("hello")
print("world")
代码2
a = input("请输入一个整数: ")
if a == "1":
print("hello")
print("world")
区别
在代码1 中, print(“world”) 有一级缩进, 这个语句属于 if 内的代码块, 意味着条件成立, 才执行, 条件不成立, 则不执行.
在代码2 中, print(“world”) 没有缩进, 这个语句是 if 外部的代码, 不属于 if 内部的代码块. 意味着条件无论是否成立, 都会执行. 另外, 代码块内部还可以嵌套代码块
a = input("请输入第一个整数: ")
b = input("请输入第二个整数: ")
if a == "1":
if b == "2":
print("hello")
print("world")
print("python")
在这个代码中
print(“hello”) 具有两级缩进, 属于 if b == “2” 条件成立的代码块
print(“world”) 具有一级缩进, 属于 if a == “1” 条件成立的代码块
print(“python”) 没有缩进, 无论上述两个条件是否成立, 该语句都会执行
基于缩进的方式表示代码块, 带来的好处就是强制要求程序员要写明确的缩进, 来明确代码之间的相对关系. 如果缩进书写的不对, 则直接报错.像 C++ / Java 这些语言, 即使完全不写缩进, 语法也不会报错. 代码可读性就比较差. 同时, 带来的坏处就是, 如果缩进层次比较多, 就容易分不清楚某个语句属于哪个层级
if a == 1:
if b == 2:
if c == 3:
if d == 4:
if e == 5:
if f == 6:
if g == 7:
print("hello")
print("1")
print("2")
因此, 就有了 “写 Python 需要自备游标卡尺” 这个梗
空语句 pass
示例: 输入一个数字, 如果数字为 1, 则打印 hello
a = int(input("请输入一个整数:"))
if a == 1:
print("hello")
也可以等价写成
a = int(input("请输入一个整数:"))
if a != 1:
pass
else:
print("hello")
其中 pass 表示 空语句, 并不会对程序的执行有任何影响, 只是占个位置, 保持 Python 语法格式符合要求
但不能写成
a = int(input("请输入一个整数:"))
if a != 1:
else:
print("hello")
不符合 Python 语法, 会直接报错
循环语句
1. while循环
基本语法格式
while 条件:
循环体
条件为真, 则执行循环体代码.
条件为假, 则结束循环.
示例: 求 1! + 2! + 3! + 4! + 5!
num = 1
sum = 0
while num <= 5:
factorResult = 1
i = 1
while i <= num:
factorResult *= i
i += 1
sum += factorResult
num += 1
print(sum)
这个程序用到了两重循环，也就是在循环语句中也可以套循环
2. for 循环
基本语法格式
for 循环变量 in 可迭代对象:
循环体
注意:
python 的 for 和其他语言不同, 没有 “初始化语句”, “循环条件判定语句”, “循环变量更新语句”, 而是更加简单
所谓的 “可迭代对象”, 指的是 “内部包含多个元素, 能一个一个把元素取出来的特殊变量”
示例1: 打印 1-10
for i in range(1, 11):
print(i)
使用 range 函数, 能够生成一个可迭代对象. 生成的范围是 [1, 11), 也就是 [1, 10]
示例2: 打印 2, 4, 6, 8, 10
for i in range(2, 12, 2):
print(i)
通过 range 的第三个参数, 可以指定迭代时候的 “步长”. 也就是一次让循环变量加几
示例3: 打印 10-1
for i in range(10, 0, -1):
print(i)
range 的 步长 也可以设定成负数
示例3: 求 1 - 100 的和
sum = 0
for i in range(1, 101):
sum += i
print(sum)
continnue和break的用法和C语言类似，这里不做讲解