LogoLogo
  • README
  • 前端编程
    • 01 Node JS
    • 02-ES6详解
    • 03-NPM详解
    • 04-Babel详解
    • 05-前端模块化开发
    • 06-WebPack详解
    • 07-Vue详解
    • 08-Git详解
    • 09-微信小程序
  • 人工智能
    • 机器学习
      • 二次分配问题
      • 非负矩阵
      • 概率潜在语义分析
      • 概率图模型
      • 集成学习
      • 降维
      • 距离度量
      • 决策树
      • 逻辑回归
      • 马尔可夫决策过程
      • 马尔可夫链蒙特卡洛法
      • 朴素贝叶斯法
      • 谱聚类
      • 奇异值分解
      • 潜在狄利克雷分配
      • 潜在语义分析
      • 强化学习
      • 社区算法
      • 时间序列模型
      • 特征工程
      • 条件随机场
      • 图论基础
      • 线性分类
      • 线性回归
      • 信息论中的熵
      • 隐马尔科夫模型
      • 支持向量机
      • 主成分分析
      • EM算法
      • Hermite 矩阵的特征值不等式
      • k-means聚类
      • k近邻法
      • PageRank算法
    • 深度学习
      • Pytorch篇
        • 01-线性模型
        • 02-梯度下降法
        • 03-反向传播
        • 04-pytorch入门
        • 05-用pytorch实现线性回归
        • 06-logistic回归
        • 07-处理多维特征的输入
        • 08-加载数据集
        • 09-多分类问题
        • 10-卷积神经网络
        • 11-循环神经网络
    • 图神经网络
      • 图神经网络笔记01
        • 01-图(Graphs)的结构
        • 02-网络的性质和随机图模型
        • 03-网络工具
        • 04-网络中的主题和结构角色
        • 05-网络中的社区结构
      • 图神经网络笔记02
        • 01-深度学习引言
        • 02-神经网络基础
        • 03-卷积神经网络
        • 04-图信号处理与图卷积神经网络
        • 05-GNN的变体与框架-
        • [06-Google PPRGo 两分钟分类千万节点的最快GNN](人工智能/图神经网络/图神经网络笔记02/06-Google%20PPRGo 两分钟分类千万节点的最快GNN.md)
        • 07-序列模型
        • 08-变分自编码器
        • 09-对抗生成网络
  • 日常记录
    • 健身日记
    • 面经记录
    • 自动生成Summary文件
  • 实战项目
    • 谷粒商城
      • 00-项目概述
      • 01-分布式基础-全栈开发篇
      • 02-分布式高级-微服务架构篇
      • 03-高可用集群-架构师提升篇
  • 数据库
    • MySQL笔记
      • 01-MySQL基础篇
      • 02-MySQL架构篇
      • 03-MySQL索引及调优篇
      • 04-MySQL事务篇
      • 05-MySQL日志与备份篇
    • Redis笔记
      • 01-Redis基础篇
      • 02-Redis高级篇
    • 02-Redis篇
  • 算法笔记
    • 01-算法基础篇
    • 02-算法刷题篇
  • 职能扩展
    • 产品运营篇
  • Go编程
    • 01-Go基础
      • 01-Go基础篇
  • Java编程
    • 01-Java基础
      • 01-Java基础篇
      • 02-多线程篇
      • 03-注射与反解篇
      • 04-JUC并发编程篇
      • 05-JUC并发编程与源码分析
      • 06-JVM原理篇
      • 07-Netty原理篇
      • 08-设计模式篇
    • 02 Java Web
      • 01-Mybatis篇
      • 01-Mybatis篇(新版)
      • 02-Spring篇
      • 02-Spring篇(新版)
      • 03-SpringMVC篇
      • 04-MybatisPlus篇
    • 03-Java微服务
      • 01-SpringBoot篇
      • 01-SpringBoot篇(新版)
      • 02-SpringSecurity篇
      • 03-Shiro篇
      • 04-Swagger篇
      • 05-Zookeeper篇
      • 06-Dubbo篇
      • 07-SpringCloud篇
      • 08-SpringAlibaba篇
      • 09-SpringCloud篇(新版)
    • 04-Java中间件
      • 数据库篇
        • 01-分库分表概述
        • 02-MyCat篇
        • 03-MyCat2篇
        • 04-Sharding-jdbc篇
        • 05-ElasticSearch篇
      • 消息中间件篇
        • 01-MQ概述
        • 02-RabbitMQ篇
        • 03-Kafka篇
        • 04-RocketMQ篇
        • 05-Pulsar篇
    • 05-扩展篇
      • Dubbo篇
      • SpringBoot篇
      • SpringCloud篇
    • 06-第三方技术
      • 01-CDN技术篇
      • 02-POI技术篇
      • 03-第三方支付技术篇
      • 04-第三方登录技术篇
      • 05-第三方短信接入篇
      • 06-视频点播技术篇
      • 07-视频直播技术篇
    • 07-云原生
      • 01-Docker篇
      • 02-Kubernetes篇
      • 03-Kubesphere篇
  • Linux运维
    • 01-Linux篇
    • 02-Nginx篇
  • Python编程
    • 01-Python基础
      • 01.配置环境
      • 02.流程控制
      • 03.数值
      • 04.操作符
      • 05.列表
      • 06.元祖
      • 07.集合
      • 08.字典
      • 09.复制
      • 10.字符串
      • 11.函数
      • 12.常见内置函数
      • 13.变量
      • 14.异常和语法错误
      • 15.时间和日期
      • 16.正则表达式
    • 02 Python Web
      • flask篇
        • 01.前言
        • 02.路由
        • 03.模板
        • 04.视图进阶
        • 05.flask-sqlalchemy
        • 06.表单WTForms
        • 07.session与cookie
        • 08.上下文
        • 09.钩子函数
        • 10.flask 信号
        • 11.RESTFUL
        • 13.flask-mail
        • 14.flask+celery
        • 15.部署
        • 16.flask-login
        • 17.flask-cache
        • 18.flask-babel
        • 19.flask-dashed
        • 20.flask-pjax
        • 21.flask上传文件到第三方
        • 22.flask-restless
        • 23.flask-redis
        • 24.flask-flash
        • 25.消息通知
        • 26.分页
    • 03-Python数据分析
      • Matplotlib
      • Numpy
      • Pandas
      • Seaborn
    • 04-Python爬虫
      • 1.准备工作
      • 2.请求模块的使用
      • 3.解析模块的使用
      • 4.数据存储
      • 5.识别验证码
      • 6.爬取APP
      • 7.爬虫框架
      • 8.分布式爬虫
由 GitBook 提供支持
在本页
  • 分支语句
  • 条件语句
  • 断言函数
  • 循环语句
  • for 循环语句
  • while 循环语句
  • 嵌套循环
  • range()
  • 函数语法
  • break 语句
  • continue 语句
  • pass 声明

这有帮助吗?

在GitHub上编辑
  1. Python编程
  2. 01-Python基础

02.流程控制

接下来将要讲下流程控制

分支语句

前面操作的时候都是一条条顺序往下执行的,现在来学习一下如何选择执行语句块

条件语句

if语句

语法:

if 表达式为真:
    执行语句块

先来看下实例:

>>> if 1 < 2:
...     print("1小于2")
...
1小于2

这里可以看到1比2要小,所以值为真,if条件语句的执行条件是值为真,便可以往下执行,所以这里打印了“1小于2”。如果条件为假,语句块就不会被执行(你猜到了,不是吗)

else 子句

语法:

if 表达式为真:
    执行语句块
else:
    否者执行这个语句块

上面利用if语句,添加了一个选项,现在使用else为它多加一个可以选择的选项

(之所以叫子句,是因为else不是独立的语句,需要和if语句一起使用)

实例:

>>> if 1 == 2:
...     print("1等于2")
... else:
...     print("1不等于2")
...
1不等于2

elif 子句

如果需要检查多个条件该怎么办?那么就可以使用elif了,elif是else if的简写

语法:

if 条件1:
    执行语句块1
elif 条件2:
    执行语句块2
    .....
else:
    都不满足执行这个语句块

实例:

>>> a = 1
>>> if a==1:
...     print("*")
... elif a==2:
...     print("**")
... else:
...     print("无")
...
*

条件表达式(三元操作符)

有时候只需执行if语句以及else子句就可以了,看下实例

>>> if 1 == 2:
...     print("1等于2")
... else:
...     print("1不等于2")
...
1不等于2

但是会发现如果这样写的话,感觉有点长,那现在可以使用三目运算符来简写这个条件语句

简写这个条件语句之前,先看下三目运算符的语法

语法: 输出a if 表达式b else 输出c

解释:如果表达式b条件为真,就执行输出1,否者执行输出c

实例:

>>> print("1") if 1 < 2 else print("2")
1


>>> print("1等于2") if 1==2 else print("1不等于2")
1不等于2

断言函数

断言函数用来什么某个条件是真的,其作用是测试一个条件是否成立,如果不成立,则抛出异常

先来看看断言函数assert的语法:

语法:

assert condition (expression)

如果condition为false,就抛出一个AssertionError异常

expression为可选参数,可以自定以打印的内容

实例:

>>> a = 1
>>> b = 2
>>> assert a > b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

>>> assert a > b,'{} is less than {}'.format(a,b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: 1 is less than 2

循环语句

在实际编程中,需要重复的去执行某些代码的时候不必要去书写多次,而是使用循环语句,重复的执行代码块

for 循环语句

在讲之前,先来看下for循环语句的语法

语法:

for 迭代值 in 序列:
    代码块

先看下实例,再来理解

items = [2,3,5,6,8,10]

for item in items:
    print(item)

运行结果:    
-------------------------

2
3
5
6
8
10

从上面可以知道,迭代的值是从序列中一个一个往后获取的

通过序列索引迭代

在讲之前需要大致了解下几个内置的函数的用法:

  • range()函数:返回一个序列的数

实例:

>>> list(range(10))  # 将数据以列表的形式返回
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

可以到range()函数,可以返回一个从0到9的数,不包括10

>>> list(range(0,10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0,11))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(1,11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  • len()函数:返回列表的长度,即元素的个数

实例:

>>> len([2,3,5])
3
>>> len([2,3,5,6])
4

接下来讲解下如何通过序列索引进行迭代

看下实例:

>>> foods = ["apple","banana","fish"]
>>> for i in range(len(foods)):
...     print("当前食物:"+foods[i])
...
当前食物:apple
当前食物:banana
当前食物:fish

这里利用len()函数获取foods序列的元素个数,然后利用range()函数返回一个序列[0,1,2],然后通过下标获取序列的元素

else语句

在 python 中,for … else 表示这样的意思,for 中的语句和普通的没有区别,else 中的语句会在循环正常执行完(即 for 不是通过 break 跳出而中断的)的情况下执行,while … else 也是一样

实例:

>>> for food in range(len(foods)):
...     print("当前食物:"+foods[food])
... else:
...     print("循环结束了")
...
当前食物:apple
当前食物:banana
当前食物:fish
循环结束了

while 循环语句

Python 编程中 while 语句用于循环执行程序,即在某条件下,循环执行某段程序,以处理需要重复处理的相同任务。

来看下while的语法

while 判断条件:
    执行语句……

执行语句可以是单个语句或语句块。判断条件可以是任何表达式,任何非零、或非空(null)的值均为true。

当判断条件假false时,循环结束。

实例:

>>> k = 1
>>> while k < 9:
...     print(k)
...     k+=1
...
1
2
3
4
5
6
7
8

可以使用continue,break 来跳过循环,continue 用于跳过该次循环,break 则是用于退出循环

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print(i)       # 输出双数2、4、6、8、10

i = 1
while 1:            # 循环条件为1必定成立
    print(i)         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

else语句

在 python 中,while … else 在循环条件为 false 时执行 else 语句块

>>> k = 1
>>> while k < 9:
...     print(k)
...     k+=1
... else:
...     print("循环结束了")

简写语句

类似 if 语句的语法,如果 while 循环体中只有一条语句,可以将该语句与while写在同一行中

>>> while 1<2 : print("1小于2")

可以使用Ctrl+C来中断循环

嵌套循环

用一个九九乘法表的小例子来讲解下什么是嵌套循环?

for i in range(1,10):
    for j in range(1,i+1):
        # print("{}*{}={} ".format(j,i,i*j),end="")
        print("%d*%-2d=%-4d" % (j,i,i*j),end=" ")
    print()

运行结果:

1*1 =1    
1*2 =2    2*2 =4    
1*3 =3    2*3 =6    3*3 =9    
1*4 =4    2*4 =8    3*4 =12   4*4 =16   
1*5 =5    2*5 =10   3*5 =15   4*5 =20   5*5 =25   
1*6 =6    2*6 =12   3*6 =18   4*6 =24   5*6 =30   6*6 =36   
1*7 =7    2*7 =14   3*7 =21   4*7 =28   5*7 =35   6*7 =42   7*7 =49   
1*8 =8    2*8 =16   3*8 =24   4*8 =32   5*8 =40   6*8 =48   7*8 =56   8*8 =64   
1*9 =9    2*9 =18   3*9 =27   4*9 =36   5*9 =45   6*9 =54   7*9 =63   8*9 =72   9*9 =81

可以从例子知道,嵌套循环就是在循环中在放入循环,这样做的目的是为了减少代码量的书写,不然上面的九九乘法表不知道要写多少个一个一个的单度的循环,所以要合理利用嵌套循环

range()

前面讲了下range()函数的一些用法,现在来好好了解下详细的range()函数的用法

range()函数返回的是一个可迭代的对象,而不是列表类型,如果想使range()函数返回的可迭代对象转换为一个列表,需要使用list()函数。

函数语法

|  range(stop) -> range object
|  range(start, stop[, step]) -> range object


start:从start开始计数,默认值为0
stop:从stop开始结束,但不包括stop这个数
step:步长,默认为1

温馨提示

如果range()函数中,如果不使用start参数,则默认从1开始,如果不使用step参数,则返回的数据之间的间隔为1

实例:

>>> range(10) # 返回的是可迭代对象
range(0, 10)

>>> list(range(10)) # 从0开始,到10结束,但不包括10,步长为1即数字之间的差为1,默认值为1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(0,10))  # 等价于上面
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(2,10)) # 从2开始,到10结束,但不包括10,步长为1即数字之间的差为1,默认值为1
[2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(2,10,3))  # 从2开始,到10结束,但不包括10,步长为3即数字之间的差为3
[2, 5, 8]

>>> list(range(2,10,5)) # 从2开始,到10结束,但不包括10,步长为5即数字之间的差为5
[2, 7]

break 语句

break 用于终止循环语句。即使循环条件不是 False 或者序列还没被完全递归完,也会终止。

注意:在嵌套循环语句中使用break,break则将结束最深层的循环

实例:

for i in range(1,10):
    if i<10:
        print("当前数值:",i)
        break



运行结果
------------------------------
当前数值: 1

continue 语句

continue用于跳过当前循环中剩下的语句,然后继续进行下一轮的循环

实例:

for i in range(1,10):
    if i<10:
        print("当前数值:",i)
        continue

运行结果:
--------------------------------
当前数值: 1
当前数值: 2
当前数值: 3
当前数值: 4
当前数值: 5
当前数值: 6
当前数值: 7
当前数值: 8
当前数值: 9

pass 声明

pass语句什么也不做,在程序不需要操作时,可以使用pass语句,一般用看做占位语句

实例:

while True:
    pass


def init():
    pass
上一页01.配置环境下一页03.数值

最后更新于3年前

这有帮助吗?