目录

目标

01. 程序的三大流程

02. while 循环基本使用

2.1 while 语句基本语法

2.2 赋值运算符

2.3 Python 中的计数方法

2.4 循环计算

03. break 和 continue

3.1 break

3.2 continue

04. while 循环嵌套

4.1 循环嵌套

​

4.2 循环嵌套演练 —— 九九乘法表

列表生成式

生成器generator

迭代器

---

 

目标

• 程序的三大流程

• while 循环基本使用

• break 和 continue

• while 循环嵌套

01. 程序的三大流程

• 在程序开发中，一共有三种流程方式：

  • 顺序 —— 从上向下，顺序执行代码

  • 分支 —— 根据条件判断，决定执行代码的 分支

  • 循环 —— 让 特定代码 重复 执行

   

• 

02. while 循环基本使用

• 循环的作用就是让 指定的代码 重复的执行

• while 循环最常用的应用场景就是 让执行的代码 按照 指定的次数 重复 执行

• 需求 —— 打印 5 遍 Hello Python

• 思考 —— 如果要求打印 100 遍怎么办？

2.1 while 语句基本语法

初始条件设置 —— 通常是重复执行的 计数器
​

while 条件(判断 计数器 是否达到 目标次数):
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...
    
    处理条件(计数器 + 1)

注意：

• while 语句以及缩进部分是一个 完整的代码块

第一个 while 循环

需求

• 打印 5 遍 Hello Python

# 1. 定义重复次数计数器
i = 1
​
# 2. 使用 while 判断条件
while i <= 5:
    # 要重复执行的代码
    print("Hello Python")
​
    # 处理计数器 i
    i = i + 1
​
print("循环结束后的 i = %d" % i)

注意：循环结束后，之前定义的计数器条件的数值是依旧存在的

死循环

由于程序员的原因，忘记 在循环内部 修改循环的判断条件，导致循环持续执行，程序无法终止！

2.2 赋值运算符

• 在 Python 中，使用 = 可以给变量赋值

• 在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符

• 注意：赋值运算符中间不能使用空格

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
%=	取 模 (余数)赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a

2.3 Python 中的计数方法

常见的计数方法有两种，可以分别称为：

• 自然计数法（从 1 开始）—— 更符合人类的习惯

• 程序计数法（从 0 开始）—— 几乎所有的程序语言都选择从 0 开始计数

因此，大家在编写程序时，应该尽量养成习惯：除非需求的特殊要求，否则 循环 的计数都从 0 开始

2.4 循环计算

在程序开发中，通常会遇到 利用循环 重复计算 的需求

遇到这种需求，可以：

1. 在 while 上方定义一个变量，用于 存放最终计算结果

2. 在循环体内部，每次循环都用 最新的计算结果，更新 之前定义的变量

需求

• 计算 0 ~ 100 之间所有数字的累计求和结果

# 计算 0 ~ 100 之间所有数字的累计求和结果
# 0. 定义最终结果的变量
result = 0
​
# 1. 定义一个整数的变量记录循环的次数
i = 0
​
# 2. 开始循环
while i <= 100:
    print(i)
​
    # 每一次循环，都让 result 这个变量和 i 这个计数器相加
    result += i
​
    # 处理计数器
    i += 1
​
print("0~100之间的数字求和结果 = %d" % result)
​

需求进阶

• 计算 0 ~ 100 之间 所有 偶数 的累计求和结果

开发步骤

1. 编写循环 确认 要计算的数字

2. 添加 结果 变量，在循环内部 处理计算结果

# 0. 最终结果
result = 0
​
# 1. 计数器
i = 0
​
# 2. 开始循环
while i <= 100:
​
    # 判断偶数
    if i % 2 == 0:
        print(i)
        result += i
​
    # 处理计数器
    i += 1
​
print("0~100之间偶数求和结果 = %d" % result)

​

03. break 和 continue

break 和 continue 是专门在循环中使用的关键字

• break 某一条件满足时，退出循环，不再执行后续重复的代码

• continue 某一条件满足时，不执行后续重复的代码

break 和 continue 只针对 当前所在循环 有效

 

3.1 break

• 在循环过程中，如果 某一个条件满足后，不 再希望 循环继续执行，可以使用 break 退出循环

i = 0
​
while i < 10:
​
    # break 某一条件满足时，退出循环，不再执行后续重复的代码
    # i == 3
    if i == 3:
        break
​
    print(i)
​
    i += 1
​
print("over")

break 只针对当前所在循环有效

3.2 continue

• 在循环过程中，如果 某一个条件满足后，不 希望 执行循环代码，但是又不希望退出循环，可以使用 continue

• 也就是：在整个循环中，只有某些条件，不需要执行循环代码，而其他条件都需要执行

i = 0
​
while i < 10:
​
    # 当 i == 7 时，不希望执行需要重复执行的代码
    if i == 7:
        # 在使用 continue 之前，同样应该修改计数器
        # 否则会出现死循环
        i += 1
​
        continue
​
    # 重复执行的代码
    print(i)
​
    i += 1

​

• 需要注意：使用 continue 时，条件处理部分的代码，需要特别注意，不小心会出现 死循环

continue 只针对当前所在循环有效

04. while 循环嵌套

4.1 循环嵌套

• while 嵌套就是：while 里面还有 while

while 条件 1:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...
    
    while 条件 2:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...
    
        处理条件 2
    
    处理条件 1

4.2 循环嵌套演练 —— 九九乘法表

第 1 步：用嵌套打印小星星

需求

• 在控制台连续输出五行 *，每一行星号的数量依次递增

*
**
***
****
*****

• 使用字符串 * 打印

# 1. 定义一个计数器变量，从数字1开始，循环会比较方便
row = 1
​
while row <= 5:
​
    print("*" * row)
​
    row += 1
​

第 2 步：使用循环嵌套打印小星星

知识点 对 print 函数的使用做一个增强

• 在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行

• 如果不希望末尾增加换行，可以在 print 函数输出内容的后面增加 , end=""

• 其中 "" 中间可以指定 print 函数输出内容之后，继续希望显示的内容

• 语法格式如下：

# 向控制台输出内容结束之后，不会换行
print("*", end="")
​
# 单纯的换行
print("")

end="" 表示向控制台输出内容结束之后，不会换行

 

假设 Python 没有提供 字符串的 * 操作 拼接字符串

需求

• 在控制台连续输出五行 *，每一行星号的数量依次递增

*
**
***
****
*****

开发步骤

• 1> 完成 5 行内容的简单输出

• 2> 分析每行内部的 * 应该如何处理？

  • 每行显示的星星和当前所在的行数是一致的

  • 嵌套一个小的循环，专门处理每一行中 列 的星星显示

row = 1
​
while row <= 5:
​
    # 假设 python 没有提供字符串 * 操作
    # 在循环内部，再增加一个循环，实现每一行的 星星 打印
    col = 1
​
    while col <= row:
        print("*", end="")
​
        col += 1
​
    # 每一行星号输出完成后，再增加一个换行
    print("")
​
    row += 1

​

 

第 3 步： 九九乘法表

需求 输出 九九乘法表，格式如下：

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
​

开发步骤

• 1. 打印 9 行小星星

*
**
***
****
*****
******
*******
********
*********

• 1. 将每一个 * 替换成对应的行与列相乘

# 定义起始行
row = 1
​
# 最大打印 9 行
while row <= 9:
    # 定义起始列
    col = 1
​
    # 最大打印 row 列
    while col <= row:
​
        # end = ""，表示输出结束后，不换行
        # "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
        print("%d * %d = %d" % (col, row, row * col), end="\t")
​
        # 列数 + 1
        col += 1
​
    # 一行打印完成的换行
    print("")
​
    # 行数 + 1
    row += 1
​

字符串中的转义字符

• \t 在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐

• \n 在控制台输出一个 换行符

制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本

转义字符	描述
\\	反斜杠符号
\'	单引号
\"	双引号
\n	换行
\t	横向制表符
\r	回车

列表生成式
 

运用列表生成式，可以快速生成 list，可以通过一个 list 推导出另一个 list，而代码却十分简洁。
 

'''
列表生成式


列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
'''
print(list(range(1,11)))

L = []
for x in range(1,11):
	L.append(x * x)
print(L)

print([x * x for x in range(1, 11)])

# for循环后面还可以加上if判断
print([x * x for x in range(1,11) if x % 2 == 0])

# 使用两层循环，可以生成全排列
print([m + n for m in 'ABC' for n in 'XYZ'])



# 运用列表生成式，可以写出非常简洁的代码。
# 例如，列出当前目录下的所有文件和目录名，可以通过一行代码实现：
import os
print([d for d in os.listdir('.')])

# for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value
d = {'x': 'A', 'y': 'B', 'z': 'C' }
for k,v in d.items():
	print(k,'=',v)




# 列表生成式也可以使用两个变量来生成list
d = {'x':'A','y':'B','z':'C'}
print([k + '=' + v for k,v in d.items()])


# 把一个list中所有的字符串变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])

x = 'abs'
y = 123
print(isinstance(x,str))
print(isinstance(y,str))

L1 = ['Hello', 'World', 18, 'Apple', None]
print([s.lower() for s in L1 if isinstance(s,str) ])

生成器generator

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，
列表容量肯定是有限的。而且，创建一个包含 100 万个元素的列表，不
仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面
绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循
环的过程中不断推算出后续的元素呢？这样就不必创建完整的 list，从而节省大量的空间。在 Python 中，这种一边循环一边计算的机制，称为生成器： generator。

generator 是非常强大的工具，在 Python 中，可以简单地把列表生成式
改成 generator，也可以通过函数实现复杂逻辑的 generator。
要理解 generator 的工作原理，它是在 for 循环的过程中不断计算出下一
个元素，并在适当的条件结束 for 循环。对于函数改成的 generator 来说，
遇到 return 语句或者执行到函数体最后一行语句，就是结束 generator
的指令， for 循环随之结束

 

'''
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

'''

'''
要创建一个generator，有很多种方法。

第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。
'''
L = [x * x for x in range(10)]
print(L)
g = (x * x for x in range(10))
print(g,type(g))
# 如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print('----')

g = (x * x for x in range(10))
for n in g:
	print(n)
print('====================')

def fib(max):
	n,a,b = 0,0,1
	while n < max:
		print(b)
		a,b = b, a+b
		n= n+1
	return 'done'
fib(10)
'''
generator和函数的执行流程不一样。

函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中
g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break

'''
print('===========================')
def fib2(max):
	n,a,b = 0,0,1
	while n < max:
		yield b
		a,b = b, a+b
		n= n+1
	return 'done'
for n in fib2(10):
	print(n)



def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

o = odd()
next(o)
next(o)
next(o)

迭代器

我们已经知道，可以直接作用于 for 循环的数据类型有以下几种：
一类是集合数据类型，如 list、 tuple、 dict、 set、 str 等；
一类是 generator，包括生成器和带 yield 的 generator function。
这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable。
可以使用 isinstance()判断一个对象是否是 Iterable 对象：

而生成器不但可以作用于 for 循环，还可以被 next()函数不断调用并返
回下一个值，直到最后抛出 StopIteration 错误表示无法继续返回下一个值了。
可以被 next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用 isinstance()判断一个对象是否是 Iterator 对象：

 

凡是可作用于 for 循环的对象都是 Iterable 类型；
凡是可作用于 next()函数的对象都是 Iterator 类型，它们表示一个惰性
计算的序列；
集合数据类型如 list、 dict、 str 等是 Iterable 但不是 Iterator，不过可
以通过 iter()函数获得一个 Iterator 对象。
Python 的 for 循环本质上就是通过不断调用 next()函数实现的，例如：
 

 

'''
迭代器

可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。



这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用 isinstance() 判断一个对象是否是Iterable对象
'''
from collections import Iterable

print(isinstance([], Iterable))
print(isinstance({}, Iterable))
print(isinstance('abc', Iterable))
print(isinstance((x for x in range(10)), Iterable))
print(isinstance(100, Iterable))

print('-----------------')


'''
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以使用isinstance()判断一个对象是否是Iterator对象.

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数.
'''
from collections import Iterator

print(isinstance((x for x in range(10)), Iterator))
print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abc', Iterator))

print(isinstance(iter([]), Iterator))
print(isinstance(iter({}), Iterator))
print(isinstance(iter('abc'), Iterator))