python 的基础语法

2 – python 的基础语法

  • 计算机语言

    • 人与计算机之间交互的语言

  • 机器语言

    • 一定位数组成二进制的O和1的序列,称为机器指令。机器指令的集合就是机器语言

    • 与自然语言差异太大、难学、难懂、难写、难记、难查错

  • 汇编语言

    • 用一些助记符号替代机器指令,称为汇编语言。ADD A,B 指的是将寄存器 A 的数与寄存器 B 的数相加得到的数放到寄存器 A 中

    • 汇编语言写好的程序需要汇编程序转换成机器指令

    • 汇编语言只是稍微好记了些,可以认为就是机器指令对应的助记符。只是符号本身接近自然语言

2.1 语言的分类

  • 低级语言

    • 面向机器的语言,包括机器语言、汇编语言

    • 不同的机器不能通用,不同的机器需要不同的机器指令或者汇编程序

  • 高级语言

    • 接近自然语言和数学语言的计算机语言、

    • 高级语言首先要书写源程序,通过编译程序把源程序转换成机器指令的程序

    • 1954年正式发布的 Fortran 语言是最早的高级语言,本意是公式翻译

    • 人们只需要关心怎么书写源程序,针对不同机器的编译的事交给编译器关心处理

编译过程:我们写好的程序需要编译,编译成指令,把指令交给 CPU 。

2.2 低级语言到高级语言

  • 语言越高级,越接近人类的自然语言和数学语言

  • 语言越低级,越能让机器理解

  • 高级语言和低级语言之间需要一个转换的工具:编译器解释器

  • C、C++等语言的源代码需要本地编译

  • Java、Python、C#的源代码需要被解释器编译成中间代码(Bytecode ),在虚拟机上运行

  • 编译语言,把源代码转换成目标机器的 CPU 指令

  • 解释语言,解释后转换成字节码,运行在虚拟机上,解释器执行中间代码

2.3 高级语言的发展

  • 非结构化语言

    • 编号或标签、GOTO,子程序可以有多个入口和出口

    • 有分支、循环

  • 结构化语言

    • 任何基本结构只允许是唯一入口和唯一出口

    • 顺序、分支、循环,废弃GOTO

  • 面向对象语言

    • 更加接近人类认知世界的方式,万事万物抽象成对象,对象间关系抽象成类和继承

    • 封装、继承、多态

  • 函数式语言

    • 函数是“一等公民”,高阶函数

    • 古老的编程范式,应用在数学计算、并行处理的场景。引入到了很多现代高级语言中

2.4 程序 Program

  • 程序

    • 算法+数据结构 = 程序

    • 数据一切程序的核心

    • 数据结构是数据在计算机中的类型和组织方式

    • 算法是处理数据的方式,算法有优劣之分

  • 写程序难点

    • 理不清数据

    • 搞不清处理方法

    • 无法把数据设计转换成数据结构,无法把处理方法转换成算法

    • 无法用设计范式来进行程序设计

    • 世间程序皆有bug,但不会debug

2.5 Python 解释器

  • 官方CPython

    • C 语言开发,最广泛的 Python 解释器

  • IPython

    • 一个交互式、功能增强的 Cpython

  • PyPy

    • Python 语言写的 Python 解释器,JIT 技术,动态编译 Python 代码

  • Jython

    • Python 的源代码编译成 Java 的字节码,跑在 JVM 上

  • IronPython

    • 与 Jython 类似,运行在 .Net 平台上的解释器,Python 代码被编译成.Net的字节码

2.6 python 基础语法

  • 注释 # 标注的文本

  • 数字

    • 整数,不区分 long 和 int

      • 进制0xa、0o10、0b10

      • bool,2个值True、False

    • 浮点数

      • 1.2、 3.1415、-0.12,1.46e9等价于1.46*109

    • 复数,1+2j

  • 字符串

    • 使用 ‘ ” 单双引号引用的字符的序列

    • ‘ ” 和 “”” 单双三引号,可以跨行、可以在其中自由的使用单双引号

    • 在字符串前面加上 r 或者 R 前缀,表示该字符串不做特殊的处理

2.6.1 基础语法

  • 转义序列 \\ \t \r \n \' \" 前缀r,把里面的所有字符当普通字符对待

  • 缩进 未使用C等语言的花括号,而是采用缩进的方式表示层次关系 约定使用4个空格缩进

  • 续行 在行尾使用 \ 如果使用各种括号,认为括号内是一个整体,内部跨行不用 \

  • 标识符 1.一个名字,用来指代一个值

    2.只能是字母、下划线和数字

    3.只能以字母或下划线开头

    4.不能是python的关键字,例如def、class就不能作为标识符

    5.Python 是大小写敏感的

  • 约定: 不允许使用中文 不允许使用歧义单词,例如class_ 在 python 中不要随便使用下划线开头的标识符

  • 常量 —旦赋值就不能改变值的标识符 python 中无法定义常量

  • 字面常量 一个单独的量,例如 12、”abc” ‘2341356514.03e-9’

  • 变量 赋值后,可以改变值的标识符

2.6.2 python 的语言类型

  • Python是动态语言、强类型语言

  • 静态编译语言 实现声明变量类型,类型不能再改变 编译时检查

  • 动态编译语言 不用事先声明类型,随时可以赋值为其他类型 编程时不知道是什么类型,很难推断

  • 强类型语言

    不同类型之间操作,必须先强制类型转换为同一类型。print(‘a’+1),强类型语言在不同类型之间必须先强制类型转换为同一类型才行。

  • 弱类型语言 不同类型间可以操作,自动隐式转换,JavaScript 中 console.log (1+’a’)

python 强类型语言类型转换演示如下:

# 进入 python 操作终端
[15:38:06 python@py ~]$python
Python 2.7.5 (default, Apr  2 2020, 13:16:51) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linux2
Type "help", "copyright", "credits" or "license" for more information.

# 我们将 a 和 1 两个不同类型的值相加在一起,就会报类型错误
>>> print('a' + 1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects

# 而我将 a 和 b 相加就会得到出 ab
>>> print('a' + 'b')
ab

# 1 和 2 相加就会得到 12
>>> print('1' + '2')
12

这时候就会报类型错误,所有需要我们自己手动来修改它的数据类型,让他通过强制类型转换。

# 这里是把 1 强制转换为一个字符串。转换成字符串之后就和 a 同类型了,然后他们就可以相加了
>>> print('a' + str(1))
a1

所以在 python 中必须进行强制类型转换,两个数据类型一致才可以进行相加的操作。

2.6.3 运算符 Operator

  • 算数运算符 +- * / % ** 自然除/结果是浮点数,整除//。注:2.x中/和//都是整除

  • 位运算符 & | ~ ^ << >> 口常用方式 : 乘除 2 的倍数,32 // 8 相当于 32 >> 3 12,0xc,0o14,0b1100 ~12等于多少,为什么

2.7 原码、反码、补码、负数表示法

  • 原码(很自然的把它转换成二进制的东西) 5 => 0b101,1 =>0b1,-1 = -0b1 , bin(-1)

  • 反码

    正数的反码与原码相同;负数的反码符号位不变其余按位取反

  • 补码(补码的补码是原码) 正数的补码与原码相同;负数的补码符号位不变其余按位取反后+1

  • 负数表示法

    早期数字电路的 CPU 中的运算器实现了加法器,但是没有减法器,减法要转换成加法

    负数在计算机中使用补码存储,-1的补码为11111111

    5-1=>5+(-1)直觉上是0b101-0b1,其实计算机中是0b101+0b11111111,溢出位舍育

    ~12为什么是-13?

    10^9 等于 ? 10^-9 等于 ? 为什么

2.8 运算符

  • 比较运算符 == !=``> < >= <= 返回一个 bool 值(布尔值) 1<'1’ 1=='1'(引号里面内容表示字符串所以不能比较) 链式比较操作符 4>3>2 4>mynumber >=1

逻辑运算符 与或非 and or not

  • 短路运算符 and 如果第一个表达式为 False ,后面就没有必要计算了,这个逻辑表达式一定是 False or 如果第一个表达式 True ,后面没有必要计算了,这个逻辑表达式一定是 True

  • 赋值运算符(变量只是一个标识符,只代表内存中的一个数据,所以我们通过声明变量就可以使用内存中的数据) a = min(3, 5) + = - = *= /= %= x= y = z = 10 这是一种连等方式 x,y,z这三个字母都等于 10

  • 成员运算符 in、 not in

  • 身份运算符 is、 is not

2.9 运算符优先级(由高到低)

运算符 描述
‘expr’ 字符串转换
{key:expr,…} 字典
[expr1,expr2…] 元组
function(expr,…) 函数调用
x[index:index] 切片
x[index] 小标索引取值
x.attribute 属性引用
~x 按位取反
+x,-x 正,负
x**y
x*y,x/y,x%y 乘,除,取模
x+y,x-y 加,减
x<<y,x>>y 移位
x&y 按位与
x^y 按位异或
x|y 按位或
x<y,x<=y,x==y,x!=y,x>=y,x>y 比较
x is y,x is not y 同等测试
x in y,x not in y 成员测试
not x 逻辑否
x and y 逻辑与
x or y 逻辑或
lambda arg ,… : expr lambda 匿名函数
  • 算数运算符 > 位运算符 > 身份运算符 > 成员运算符 > 逻辑运算符

  • 记不住,用括号

  • 长表达式,多用小括号,易懂,易读

  • 单幕运算符(例如取反)优先级高于双幕运算符(例如加法)

2.10 表达式

  • 由数字、符号、括号、变量等的组合

    • 算数表达式

    • 逻辑表达式

    • 赋值表达式

      • Python中,赋值即定义,如果一个变量已经定义,赋值相当于重新定义

2.11 内存管理

动态语言他有个好处不需要事先声明,也就是说赋值即为定义。这样的话使用起来很方便,但是赋值及定义,在内存中万一我们需要释放这个数据呢。所以像 JVM 或者说 PVM 这些虚拟机他们就提供一种叫做垃圾回收的机制,也就是所谓的内存管理。所以在 python 和 java 编程中一般不需关心变量的存亡。

也就是所谓的引用计数的机制。

  • 变量无须事先声明,也不需要指定类型

    • 动态语言的特性

  • Python 编程中一般无须关心变量的存亡,一般也不用关心内存的管理

  • python使用引用计数记录所有对象的引用数

    • 当对象引用数变为0,它就可以被垃圾回收GC

    • 计数增加︰赋值给其它变量就增加引用计数,例如x=3;y=x(假如 3 这个东西是内存中的对象的话,什么时候 3 才能够被计数增加呢也就是 x = 3 相当于 3 这个对象引用计数加一因为原来没有人使用现在 x 将他关联上了,x 这个标识符和它关联上了所以计数加一,然后 y 等于 x 也就是说相当于 y 等于 3 ,所以说这时候 3 又被别人用了一次所以 3 的计数就变为 2 了这就是所谓的技术增加)

    • 计数减少∶

      • 函数运行结束时,局部变量就会被自动销毁,对象引用计数减少

      • 变量被赋值给其它对象。例如 x=3;y=x;x=4(先 x 等于 3 接着 y 等于 x 这时候 3 的引用计数为两次,但是紧接着 x 等于 4 也就是说这时候 x 已经忘了 3 所以 3 的引用计数就减一,当每个内存中的数据引用计数为 0 时就会被自动销毁。)

  • 有关性能的时候,就需要考虑变量的引用问题,但是该释放内存,还是尽量不释放内存,看需求

  • 内存垃圾回收的目的是为了规整,整理。也就是内存碎片化:

    • 对于内存回收来讲的话实际上 C 语言是自己管理的,也就是说在释放内存的时候他就把那个固定位置的内存给释放掉了

2.11.1 内存碎片化图文讲解

那如上图我们将内存想象成长条结构的话然后在这个长条中有一块一块被使用的线行编制。我们可以把它分别向成 1 号房间、2 号房间、3 号房间、一直到 6 号往后编制这,但是每一个程序只能管他自己的房间,现在我来了一波人并且这一波人要挨在一起住,并且我们的一号房已经有人陷入住了,所以这时候我们就将 2 号房到 4 号房给了这几个客人,但是这时候又来了一些散客就住 5、6 号房。关键是 2 至 4 号房间的客人第二天走了,而且这时候又来了一波旅客,这第二波旅客说他们现在有 4个人并且要住在一起。实际上我们有空间给她但是给不了连续的,因为被 4、5号 客人打断了所以不能给。而我们的内存管理也是这个概念,我们可以认为内存是逻辑限行编制的

这个时候当你的数据摆在其中,C 语言就得自己清理。但是 C 语言会发现有 5 个需求空间是够的,但是 C 语言会告诉你开辟内存空间失败。因为它并不具备内存动态搬运。这时候就需要我们自己搬,就让 4、5 号房的两位客人请他们移到 6、7 号房中,将中间开辟一个大内存,这时候就又连续空间提供给第二波旅行团。但是当这些房客需要走的时候,内存就会被打成零零散散的东西,也就是我们所谓的内存碎片。

内存碎片化之后会带来很大的问题。当你开辟连续大空间的时候没有了,因为在数据结构里面有个东西叫做数组,在 python 中叫做列表他就是连续的空间,列表中间不能被打断(也就是一波客人要住在一起的这个概念),虽然开辟内存空间失败,但是内存的总空间是够的,但是 C 语言这种语言如果连续的去申请,然后 C 语言经常的去把这些内存释放掉,时间长了就会发现内存中到处都有数据。这个就叫做内存碎片化

2.11.2 内存垃圾回收

java 一想内存碎片这样不行,所以 java 就有虚拟机并且在虚拟机中提供了一个东西叫做垃圾回收,当然 python 也是这么做的。

垃圾回收第一个是首先 java 和 python 得知道我们那些数据不用,因为 java 和 python 不像 C 语言一样需要手动释放,而是 java 和 python 在猜那些内存数据不使用。所以就引入一种机制叫做引用计数机制,当引用计数为 0 了自然就没人使用了就清除掉。

但是 java 和 python 自动清除内存依旧会产生内存碎片化。但是在 java 和 python 中它们垃圾回收的同时就随便进行内存整理,当然内存整理是有原则的,也就是将一些最不常用的数据放到一个位置,然后呢比不常用的数据使用频率少的就紧挨着它,使用最少的数据就放到边上。也就是说到时候由使用频率少的往使用频率多的顺序已清理即可。

也就是将经常使用的数据往最里面放、使用一般的就挨着使用最多的数据放,而不怎么经常使用的数据就放在最边上。即使需要清除内存数据也是将最不常用的先清除掉。

也就是说最不容易变化的内存数据,就往内存中最里面放,这就是 java 和 python 的内存管理机制。

2.12 程序控制

  • 顺序

    • 按照先后顺序一条条执行

    • 例如,先洗手,再吃饭,再洗碗

  • 分支(按照不同的情况判断应该做什么,满足什么条件做什么事)

    • 根据不同的情况判断,条件满足执行某条件下的语句

    • 例如,先洗手,如果饭没有做好,玩游戏,如果饭做好了,就吃饭,如果饭都没有做,叫外卖

  • 循环(条件满足就能够反复循环,不满足就不再执行)

    • 条件满足就反复执行,不满足就不执行或不再执行

    • 例如,先洗手,看饭好了没有,没有好,一会来看一次是否好了,一会儿来看一次,直到饭好了,才可是吃饭。这里循环的条件是饭没有好,饭没有好,就循环的来看饭好了没有。

2.12.1 判断 — if 语句

2.12.1.1 单分支结构

  • if 语句

    if condition:
        代码块
    condition #必须是一个bool类型,这个地方有一个隐式转换bool(condition)
    if 1<2:                     # 这里就有隐式的布尔值在这
        print('1 less than 2')  # 在缩进之前上一段代码必须要以 : 结尾
    • 代码块 类似于 if 语句的冒号后面的就是一个语句块 在 if、for、def、class 等关键字后使用代码块

2.12.1.1 真假值表

if 语句后面会被转换为一个表达式,这个表达式不是 thru 就是 false 的布尔表达式。

对象/常量
“”
“string”
0
> = 1
< = -1
() 空元组
[] 空列表
{} 空字典
None

False 等价布尔值,相当于 bool(value)

  • 空集合

    • 空字符串

    • 空字典

    • 空列表

    • 空元组

  • None 对象

  • 0

2.12.1.2 多分支结构

  • if…elif…else语句

    if condition1:
        代码块1
          elif condition2:
        代码块2
          elif condition3:
        代码块3
    ......
    else:
        代码块
  • 举例

    a = 5                   
    if a<0:                 
        print('negative')
    elif a==0:          
        print('zero')
    else:
        print('positive')
    
        
    # 代码解释
    a = 5   # 先给 a 赋值等于 5
    if a<0: # if 判断 a<0 ? 也就是 5 是否小于 0,如果小于就打印下面这句话
        print('negative')
    elif a==0:  # 由于 a 为 5 并且大于 0 所以上一条判断错误,接着判断 5 是否等于 0,如果等于打印 zero
        print('zero')
    else:       # 其他条件,如果上面的判断条件都不对就打印 positive
        print('positive')
  • 分支只要进入其中一个分支,其他分支就不再执行,并且语法要求 else 必须式最后一个结束语句。

    • 举例

    a = 5                   
    if a<0:                 
        print('negative')
    elif a < 6: # 由于这里 a 小于 6 为真就直接执行代码块,并且不会再往下判断
        print('less than 6')
        print()
        print()
    elif a==0:          
        print('zero')
    else:
        print('positive')

    2.12.1.3 分支嵌套

    • 嵌套结构,可以是分支、循环嵌套

    • 可以互相嵌套多层

    举例

    score = 80
    if score < 0:
        print('wrong')
    else:
        if score == 0:
            print('egg')
        elif score <= 100:
            print ('right')
        else:
            print('too big')
            
    # 代码解释
    # 先给 score 赋值为 80
    # 接着 if 判断如果 score 小于 0 就打印 wrong 错误,但是 score 比 0 大所以这条判断语句不成立就接着往下继续匹配到了 else 其他条件中
    # 在其他条件中,有引入了一个 if 判断 score 是否为 0 如果为 0 就打印 egg ,但是由于 score 为 80 该条判断的布尔返回值为 false 所以不进行判断。
    # 然后 elif 判断 score 是否小于或者等于 100,如果是就打印 right。因为 score 赋值为 80 所以就是小于等于 100 布尔返回值为 thru 

2.12.1.3 练习

使用 input 函数

1、输入 2 个数字,最后打印最大数

答案:

num1 = int(input('输入数字'))
num2 = int(input('输入数字'))

if num1 >= num2:
    print('num1')
else:
    print('num2')
    
# 代码解释
1、先给 num1  num2 通过 input 函数赋值,int 是强制转化类型
2、在给 num1  num2 进行 if 判断,判断条件是 num1 大于或等于2 如果满足就大于 num1 的值
3、如果 num1 不大于也不等于 num2 就打印 num2 的值

2、给定一个不超过 5 位的正整数,判断其有几位。

正常答案:

num = int(input('一个不超过 5 位的正整数'))
if num <= 9:
    print('num 是一位数')
elif num <= 99:
    print('num 是两位数') 
elif num <= 999:
    print('num 是三位数')
elif num <= 9999:
    print('num 是四位数')
else:
    print('num 为 5 位数')
     
# 代码解释
1、给 num 赋值为一个不超过 5 位的正整数
2、进行一层一层 if,elfi,else 的判断,逻辑是取得单个位中最大得数来进行判断

折半查找算法答案:

num = int(input('一个不超过 5 位的正整数'))

if num >= 1000:
    if num >= 10000:
        print(5)
    else:
        print(4)
else:
    if num >= 100:
        print(3)
    elif num >= 10:
        print(2)
    else:
        print(1)

# 代码解释
1 num 赋值为一个不超过 5 位的正整数
2 使用折中算法,我们在 5 位数中找一个中间为比如 1000 的四位数进行 if 判断,如果 num 大于或等于 1000 ,我们就将 num  10000 进行比较,如果 num 大于等于 10000 就打印 5,如果不大于 10000 就说明 num 是小于 10000 并且大于 1000  4 位数
3 假如上面判断 num 就不等于 10000 也不等于 1000 就接着 else 判断 num 是否大于等于 100,如果是就打印 3 如果不是就判断是否大于或等于 10,如果是就打印 2 .
4、就会 else 其他分支,如果上面都条件匹配判断不成功就说明是一位数

# 所谓折半查找算法就是在该位数中取一个中间值,如该代码所示取得是 1000,先判断是否大于或等于1000 如果不是就直接判断 else 分支。这样的运行速度就相对较快

2.12.2 循环 — while 语句

  • 语法

    while condition:
        block
    
    # 当条件满足即 condition 为 true,进入循环体执行 block
    # 循环是执行完了之后会回头,回头之后再看条件是否满足。条件满足继续循环,条件不满足退出
  • 举例:

    flag = 10
    while flag:
        print(flag)
        flag -= 1
    
    # 代码解释
    1、给 flag 赋值为 10
    2、通过 while 循环,因为 flag 已经赋值所以它的布尔值为 true
    3、print 打印 flag 
    4、flag -=1 也就是说 10 依次减 1 直到为 0 退出循环,因为 0 不能被 -1 所以布尔值为 false
  • 代码分析:

    • 首先进入这个 while 循环条件的值是 10,并且依次减 1 ,但是到了 0 就不对了,所以打印结果为 10-1

2.12.3 循环 — for 语句

range函数:返回的是 range 对象,这个对象中有数据但是这个数据并不是能够立即拿到的,需要使用 for 循环来拿,能够帮助我们去做一些迭代的工作。默认是用来存放数据

  • 语法

    for element in iteratable:
        block
    
    # 当可迭代对象中有元素可以迭代,进入循环体执行 block
    # iteratable:为集合,element 从 iteratable 中取出值来进行循环
  • 举例:打印 1~10

    for i in range(10):
        print(i+1)

range 函数使用范例:

for i in range(5,1,-1):
...     print(i)
... 
5
4
3
2

# 代码解释
1、我调用了 range 函数,并且是以 5 开头 1 结尾,依次减一
2、通过 print 打印就会发现依次打印出来,但是不包 1 ,因为在 range 函数中是前包后不包

注意:

如下图代码中,因为 i 根本就没有进入到我们的 range 函数中,因为在 range 函数中什么值都没有。也就是说如果这个可迭代对象里面没有东西能够被迭代,循环时不能够进入取值的

for i in range(0):
    print(i)

2.12.4 循环 continue 语句

  • 中断当前循环的当前执行,继续下一次循环

    • 也就是说循环继续循环,但是当遇到 continue 这次循环就停了,也就是后面的语句不用执行了,碰见 continue 语句就赶紧回头。

  • 举例:计算 10 以内的偶数(for 循环)

    for i in range(10):
         if i%2:
             continue
        print(i)
    
    0
    2
    4
    6
    8
    
    # 代码解释
    1 先给 range 函数定义一个 10 也就显示 0~9  10 位数,然后 for 循环将数字赋值给 i
    2  i 进取模,此时整数能够被 2 整除结果为 0 ,而在 python  0 假所以就不能执行 continue 字段,但是基数不能被整除有余数为 1 所以就会执行 continue
    3 这时候 print 我们可以通过缩进观察不受 if 语句所管理,所以就打印
  • 二进制写法举例:

    for i in range(10):
         if i&1:
             continue
         print(i)
    
    0
    2
    4
    6
    8
    
    # 代码解释
    1 先给 range 函数定义一个 10 也就显示 0~9  10 位数,然后 for 循环将数字赋值给 i
    2 将其转为二进制, 所有基数有个特点就是最低位为 1 所以为真执行 continue,中断循环
    3、print 直接将不是基数的偶数进行打印
  • range 函数步进写法举例:

for i in range(0,10,2):
     print(i)
 
0
2
4
6
8

# 代码解释
1、先给 range 函数定义一个 0-10 的范围,然后步进为 2 
2、通过 print

少迭代效率肯定高

2.12.5 循环 break 语句

  • 终止当前循环,不在循环

  • 举例:计算 1000 以内的被 7 整除的前 20 个数(for 循环)

    z = 0
     for i in range(0,1000,7):
         print(i)
         z += 1
         if z >= 20:
           break
    ... 
    0
    7
    14
    21
    28
    35
    42
    49
    56
    63
    70
    77
    84
    91
    98
    105
    112
    119
    126
    133
    
    # 代码解释
    1、给 z 赋值等于 0 
    2、通过 range 函数指定范围是 0  1000 并且步进是 7 通过 for 循环给 i 
    3、通过 print 打印 i  现在也就是 7 的倍数
    4、然后 z 依次累计加 1
    5、if 来进行条件判断定义 z 的值大于或者等于 20 的时候就执行 break 退出循环

2.12.6 总结

  • continue 和 break 是循环控制语句,只影响当前循环,包括 while、for 循环

  • 如果循环嵌套,continue 和 break 也只影响语句所在的那一层循环

  • continue 和 break 不是跳出语句块,所以 if cond:break 不是跳出 if,而是终止 if 外的 break 所在循环

点赞