资源简介

(共41张PPT)
课时29 迭代与递归
一、迭代
1. 迭代是重复反馈过程的活动，其目的通常是为了使结果符合目标需求。
2. 迭代算法。
（1）迭代算法利用计算机运算速度快、适合做重复性操作的特点，让计算机
　　　　执行一组指令（或一些步骤），这组指令（或这些步骤）每执行一次时，都会将变量从原值递推出一个　　　　。
重复
新值
方面 含义
确定迭代 1　　　　 在能够用迭代算法处理的问题中，至少具有一个直接或间接地不断由旧值递推出新值的变量，该变量为迭代变量
建立迭代关系式 迭代关系式是指如何从变量的前一个值推出其下一个值的公式（或关系）
控制迭代过程 ①迭代过程在经过若干次重复执行以后要能结束，因此，要设定迭代结束的条件
②若所需的迭代次数是个确定的值，可以计算出来，则可构建一个固定次数的循环来实现对迭代过程的控制
③若所需的迭代次数无法确定，则需要进一步分析出用来结束迭代过程的条件
（2）利用迭代算法处理问题，需要考虑三个方面。
变量
（3）迭代通常用　　　　结构实现。其基本格式为：
迭代变量赋初值
while (迭代终止条件):
根据迭代表达式，由旧值计算出新值
新值取代旧值，为下一次迭代做准备
（4）代码示例：迭代法计算 n 的阶乘。
def f1(n):
i=1;x=1
while i<=n:
x*=i
i+=1
return x
循环
1. 递归：在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法，通过函数自己调用　　　　来实现，即一个函数在其定义中直接或间接调用自身的一种方法。
2.递归算法。
（1）递归算法能使函数的定义和算法的描述简洁且易于理解，极大地减少程序代码量。
（2）递归算法的思想是设法将规模为 N 的问题分解成规模较小的问题，然后从这些小问题的解中方便地构造出大问题的解，并且这些规模较小的问题也能采用同样的分解和综合方法。当递归到某个边界，如问题规模缩为 0 或 1 时，能直接得解。
自己
二、递归
（3）设计递归算法时，要满足两个条件：确定递归公式和递归　　　　条件。
（4）递归调用必须是有限的。在进行算法描述时必须设置相关的控制条件，使其成为有限的。这可以通过条件语句来实现，即只有在设定的条件成立时递归才能继续，否则终止递归。
（5）递归算法的执行分为　　　　和　　　　两个阶段。
结束
递推
回归
阶段 含义
递推阶段 把较复杂的问题（规模为n）的求解递推到一些简单问题（规模小于n）的求解，必须要有终止递推的情况
回归阶段 当获得最简单情况的解后，逐级返回依次得到稍复杂问题的解
3.递归程序执行的过程。
（1）程序进入递归函数，开始运算。
（2）运算结束后，开始判断输出是否满足退出递归的条件。
（3）若满足退出条件，则退出递归，执行后续代码。
（4）否则继续递归调用，只是递归调用的参数发生变化。
4.举例：递归法计算 n 的阶乘。
（1）由数学知识可知，n 的阶乘等于 n 乘以 n-1的阶乘，即 n!=n×(n-1)!，并且规定 0!=1。设函数 f2(n)=n!，则当 n=0 时，f2(n)=1；当 n>0时，f2(n)= n×f2(n-1)。
（2）可以将求 n!的问题转化成求(n-1)!的问题，而求(n-1)!的问题又可以转化成求(n-2)!的问题……直到最后转化成求 0!的问题。再反过来，依次求出 1!，2!，……，直到最后求出 n!。
（3）得到递归公式为 f2(n)=n×f2(n-1)，当 n=0 时递归结束。相应的程序及递归图示如下：
def f2(n):
if n==0:
return 1
else:
return n*f2(n-1)
print(f2(4))
5.递归与栈。
（1）计算机在执行递归程序时，是通过　　　　的调用来实现的。
（2）递归程序是将复杂问题分解为一系列简单的问题，从要解的问题起，逐步分解，并将每步分解得到的问题放入“栈”中，运用栈的“后进先出”的性质，这样栈顶是最后分解得到的最简单的问题，解决了这个问题后，次简单的问题可以得到答案，以此类推。所以，分解问题可以看作是　　　　的过程，而解决问题则是　　　　的过程。
栈
进栈
出栈
典例 1 有如下 Python 程序段：
digit s={"0":0,"1":1,"2":2,"3":3,"4": 4,"5":5,"6":6,"7":7,"8":8,"9":9}
str="12345"
s=0
j=len(str)-1
for i in str:
s=s+digits[i]*(10**j)
j-=1
print(s)
执行该程序段后，输出的结果是 （　　）
A.54321 B.5400321 C.15 D.12345
D
√
题型导向一　迭代算法的应用
胜券点拨1
明考向 本题主要考查迭代算法
审关键 重复执行
考场思 维快闪 该程序段通过迭代i和j的值，求出字符串str对应的整数，当i等于"1"时，s的值为0+1*10000；当i等于"2"时，s的值为10000+2*1000=12000，以此类推
典例 2 有如下 Python 程序段：
i=1;x=1;n=5
while i<=n:
x*=i
i+=1
print(x)
下列关于该程序段的说法，不正确的是 （　　）
A.执行该程序段后，输出的结果是 120
B.该程序段的迭代变量是 x 和 i
C.该程序段的迭代关系是 x→x*i，i→i+1
D.该程序段实现迭代方式求 n 的阶乘
C
√
胜券点拨2
明考向 本题主要考查迭代算法的基本要素以及应用
审关键 迭代算法的三个注意事项：迭代变量、迭代关系式、迭代结束条件
考场思 维快闪 一般循环体中出现由旧值递推出新值的变量，该变量为迭代变量。迭代关系为迭代关系式→新值，赋值语句中“=”左边为新值，右边为迭代关系式，迭代结束条件一般为循环结束条件
典例 3 已知 s=1 1/3!+1/5! 1/7!+…+( 1)n 11/(2n 1)!，其中 n 为正整数，计算 s 值的 Python 程序如下：
s=1
i=1
t=1
n=5
while i<2*n-1:
　　　　　　　
print(s)
方框处的代码由如下三部分组成：
①s=s+t ②i=i+2 ③t=-t/(i*(i-1))
则方框处应填入代码的正确顺序是 （　　）
A.③①② B.①②③ C.②①③ D.②③①
D
√
胜券点拨3
明考向 本题主要考查迭代算法
审关键 迭代关系式
考场思维快闪 分析计算s的表达式，可知代码③表示迭代关系式，用于计算每项的值，代码①表示将各项的值累加到变量s中，代码②用于控制循环的步长和计算迭代关系式，i、t和s的初始值均为1，因此while循环要从表达式的第2项开始计算，故要先执行代码②，再执行代码③迭代每项的值，最后执行代码①累加到s中
典例 4 ［2023.1浙江选考］定义如下函数：
def rf(n):
if n<3:
return n
return rf(n-1)+rf(n-3)
执行语句 v=rf(5)，函数 rf被调用的次数是（　　）
A.11 B.5 C.7 D.15
C
√
题型导向二　递归算法的应用
胜券点拨4
明考向 本题主要考查递归算法
审关键 递归算法的执行过程分为递推和回归，递推过程调用函数自身
考场思维快闪 递归函数rf()中，递归结束条件为n<3，递归公式为rf(n)=rf(n-1)+rf(n-3)，则当传入的参数为5时（调用1次递归函数），计算过程为：rf(5)= rf(4)+rf(2)（调用2次递归函数），rf(4)=rf(3)+ rf(1)（调用2次递归函数），rf(3)=rf(2)+rf(0)（调用2次递归函数）
典例 5 ［2023.6 浙江选考］定义如下函数：
def f(a,s):
if a>=s:
return a
else:
return f(a+1,s-a)
执行语句 k=f(6,21)后，k 的值为 （　　）
A.6 B.7
C.8 D.9
C
√
胜券点拨5
明考向 本题主要考查递归算法
审关键 递归结束条件
考场思维快闪 根据给定的递归函数f(a,s)，若a大于等于s，则返回a；否则，递归调用f(a+1,s-a)。首先，执行f(6,21)，a=6，s=21，因为a小于s，所以进入else语句，调用f(6+1,21-6)=f(7,15)。接下来，执行f(7,15)，a=7，s=15，因为a小于s，所以进入else语句，调用f(7+1,15-7)=f(8,8)。继续执行f(8,8)，a=8，s=8，因为a等于s，所以返回a，即8
典例 6 定义如下函数：
def f(n):
if n==1:
return 1
if n%2==1:
return f(n-1)
else:
return n-2*f(n//2)
执行语句 k=f(11)后，k 的值为 （　　）
A.0 B.2 C.4 D.8
B
√
胜券点拨6
明考向 本题主要考查递归算法
审关键 递归调用过程
考场思 维快闪 k=f(11)=f(10)=10-2*f(5)=10-2*f(4)=10-2*(4-2*f(2))=10-2*(4-2*(2-2*f(1)))=2
典例 7 定义如下函数：
def move(n,a,b,c):
if n==1:
print(a,"->",c)
return
move(n-1,a,c,b)
move(1,a,b,c)
move(n-1,b,a,c)
执行语句 move(2,"A","B","C")后，输出的第一行内容是 （　　）
A.a -> c B.A -> C C.a -> b D.A -> B
D
√
胜券点拨7
明考向 本题主要考查递归算法
审关键 汉诺塔模型
考场思 维快闪 函数move(n,a,b,c)表示将n个圆盘从a柱经过b柱移动到c柱。执行语句move(2,"A","B","C")，参数n的值为2，a、b、c的值分别为"A"、"B"、"C"。首先调用move(n-1,a,c,b)，即move(2-1,"A","C","B")，此时参数n的值为1，a、b、c的值分别为"A"、"C"、"B"，故执行输出语句print("A","->","B")，输出的结果是“A -> B”
典例8　［2026绍兴模拟］甲乙两名玩家按如下规则轮流进行游戏：桌上有n枚硬币，玩家每次可以从中拿走1枚或者2枚。谁拿走最后一枚硬币谁就输掉了游戏。为求出胜者，定义如下函数：
def g(n,cur):
if n<=0:
return cur
if cur=="甲":
nxt="乙"
elif cur=="乙":
nxt="甲"
if g(n-1,nxt)==cur or g(n-2,nxt)==cur:
return cur
else:
return nxt
执行如下语句后，s的值与其他三个选项不同的是 （　　）
A.s=g(3,"甲") B.s=g(4,"甲")
C.s=g(5,"甲") D.s=g(6,"甲")
B
√
胜券点拨8
明考向 本题主要考查递归算法
审关键 每次拿走1枚或者2枚、最后一枚硬币
考场思维快闪 游戏规则为“谁拿走最后一枚硬币谁就输”，即拿到最后一枚硬币的玩家为败者。函数g(n,cur)用于计算剩n枚硬币且当前玩家为cur时，谁会获胜。g(3,"甲")返回"甲"，g(4,"甲")返回"乙"，g(5,"甲")返回"甲"，g(6,"甲")返回"甲"
典例 9 ［2025.1浙江选考］对于任意非空字符串 s，甲、乙程序段输出结果相同，则乙程序段加框处的正确代码为 （　　）
A.r=s[n-i]+r
B.r=r+s[n-i-1]
C.r=r+s[i]
D.r=s[i]+r
D
√
def f(s,t):
if t>=len(s)-2:
return s[t]
return f(s,t+2)+s[t]
print(f(s,0))
甲程序段
r=""
n=len(s)
for i in range(0,n,2):
　　　　　　　
print(r)
乙程序段
题型导向三　迭代与递归
胜券点拨9
明考向 本题主要考查迭代与递归
审关键 递归算法思想、字符串处理
考场思 维快闪 甲程序段是一个递归函数，如果t>=len(s)-2，则返回字符s[t]，否则递归调用f(s,t+2)，并将结果与s[t]拼接，因此函数f(s,0)的作用是从字符s[0]开始，每隔一个字符取一个字符（偶数索引），并将这些字符逆序拼接成结果字符串。乙程序段则是采用循环递推的方式，从索引0开始遍历字符串，步长为2（跳过一个字符），再逆序拼接成结果字符串，故填入代码为r=s[i]+r
算法 编程思想 区别
迭代 利用已知的变量值，根据迭代公式不断演进得到变量新值 迭代时，循环代码中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值
递归 程序调用自身，即一个函数调用本身 迭代是有去无回，而递归则是有去有回（因为存在终止条件）
通法一　辨析迭代与递归
过程 实现
抽象与建模 欧几里得算法又称辗转相除法，用于计算两个整数的最大公约数。首先确定整数m和整数n，整数m、n的最大公约数等于n和m除以n的余数的最大公约数
设计算法 从问题的抽象与建模中可以发现，m、n是迭代变量，迭代关系是n→m和m%n→n，即gcd(m,n)=gcd(n,m mod n)，由旧值推出新值，然后循环执行，直到余数为0，结束迭代
编写程序 def gcd(m,n):
while n!=0:
temp=n
n=m%n
m=temp
return m
a=int(input("请输入整数a："))
b=int(input("请输入整数b："))
print(gcd(a,b))
测试结果 请输入整数a：156
请输入整数b：24
12
通法二　迭代算法的应用举例：欧几里得算法
1.抽象与建模。
（1）汉诺塔游戏可抽象为：从左到右有 A、B、C 三个柱子，其中 A 柱子从下往上放着从大到小的 n个圆盘，按照一定的要求，将 A 柱子上的圆盘移到 C 柱子上去。
（2）如图所示为汉诺塔抽象模型。要将 3 个圆盘从 A 柱移动到 C 柱，需要借助 B 柱进行过渡。一个可行的移动方案是：A→C（表示将 A柱上的最上面的一个圆盘移动到 C 柱上），A→B，C→B，A→C，B→A，B→C，A→C。
通法三　递推算法的应用举例：汉诺塔游戏
（3）考虑一般情形，将 n 个圆盘从 A 柱经过 B 柱移动到 C 柱，建立模型如下：
①将 n-1 个圆盘从 A 柱经过 C 柱移动到 B 柱。
②将 A 柱中剩下的一个圆盘移动到 C 柱。
③将 n-1 个圆盘从 B 柱经过 A 柱移动到 C 柱。
2.设计算法。
从问题的抽象与建模中可以发现，原来与 n 有关的问题变成了与 n-1 有关的问题，重复这个过程，每次 n 减 1，最后当 n=1 时，直接移动该圆盘。用递归算法实现步骤如下：
步骤 说明
定义一个实现圆盘移动的函数move 将n个圆盘从A柱经过B柱移动到C柱，可调用函数move(n,a,b,c)，其中n表示A柱上的圆盘个数，a、b、c分别表示A柱、B柱、C柱
将n个圆盘从A柱经过B柱移动到C柱 move(n-1,a,c,b)
a→c
move(n-1,b,a,c)
n的值减1，重复上一步操作 直到n=1时，直接移动圆盘，递归结束
3.编写程序。
根据算法，编写的程序及测试结果如下：
程序 测试结果
def move(n,a,b,c): if (n==1): print(a,"->",c) return move(n-1,a,c,b) move(1,a,b,c) move(n-1,b,a,c) move(3,"A","B","C") A -> C
A -> B
C -> B
A -> C
B -> A
B -> C
A -> C
1.有如下Python程序段：
list_1=[10,"Safa",15,"Aman",1]
length_list=len(list_1)
x=0
while xprint(list_1[x])
x+=1
执行该程序段后，输出结果的个数是　　　 　。
迭代变量x通过while循环迭代list1_1中的下标，并逐个输出对应的元素值，故输出的结果个数是5。
一、迭代算法的应用
5
2.用迭代法求1+(1*2)+(1*2*3)+…+(1*2*…*n)(n≥5)的值。程序运行结果如图所示，代码如下，请在画线处填入合适的代码。
n=int(input("请输入n的值："))
c,s,i=1,0,1
while 　　　①　　　:
c=c*i
s=　　　②　　　1
　　　③　　　1
print("1+(1*2)+(1*2*3)+…+(1*2*…*",n,")=",s)
①已知i的初始值为1，终值为n，题目限定了n的范围，故判断条件是i<=n。②处已知s每次循环与c累加，故填入代码为s=s+c。③处通过i的迭代i=i+1实现循环。
i<=n
请输入n的值：6
1+(1*2)+(1*2*3)+…+(1*2*…* 6 )= 873
s+c
i+=1
3.定义如下函数：
def f(m,n):
if m<=n:
return m
else:
return f(m-1,n+2)+1
执行语句k=f(12,5)后，k的值为 （　　）
A.9 B.10
C.11 D.12
D
√
k=f(12,5)=f(11,7)+1=f(10,9)+2=f(9,11)+3=9+3=12。
二、递归算法的应用
4.有如下Python程序段：
def f(x):
if x==1 or x==2:
return 1
else:
return f(x-1)+f(x-2)
s=0
for i in range(1,5):
s+=f(i)
执行该程序段后，函数f被调用的次数是 （　　）
A.10 B.9 C.8 D.7
A
√
当i的值为1、2时，各调用1次函数f。当i的值为3时，f(3)=f(2)+f(1)，共调用1+1+1=3次函数f。当i的值为4时，f(4)=f(3)+f(2)，共调用1+3+1=5次函数f。故函数f总共被调用的次数是10。
5.［2025浙江名校协作体］有如下Python程序段：
def fact1(n):
s=0
while n!=0:
s+=n%2
n=n//2
return s
def fact2(n):
if n==1:
return 1
else:
return 　　　　　　　
对于任意正整数n（n≥2），两个函数的返回值相等，则方框处应填入的正确代码是 （　　）
A.n%2+fact2(n//2) B.str(n%2)+fact2(n//2)
C.fact2(n%2)+str(n//2) D.n//2+fact2(n%2)
函数fact1的功能是统计n的二进制表示中“1”的个数。已知对于任意正整数n（n≥2），两个函数的返回值相等，则函数fact2与函数fact1的功能相同，区别是函数fact1是通过迭代的方式计算，函数fact2是通过递归的方式计算。n为十进制数，若m为n转换成二进制数的结果，则n%2表示m的最后一位，n//2等于m去掉最后一位再转换为十进制数的结果（例如，10D=1010B，10//2=5，5D=101B），因此，统计n的二进制表示中“1”的个数，可以转换成统计n%2与n//2的二进制表示中“1”的个数之和，即fact2(n)=n%2+fact2(n//2)（n≥2）。
A
√
三、迭代与递归
6.定义如下函数：
def f(m,n):
if m>=n:
return m
else:
return f(m+m%2+1,n-1)+1
执行语句k=f(6,12)后，k的值是 （　　）
A.11 B.12 C.13 D.14
k=f(6,12)=f(7,11)+1=f(9,10)+2=f(11,9)+3=11+3=14。
D
√
7.定义如下函数：
def f(j,t,b):
if t<0:
return "no answer"
elif j*2+t*4==b:
return str(j)+" "+str(t)
else:
return f(j+1,t-1,b)
执行语句print(f(0,10,36))后，输出的结果是 (　　)
A.1 9 B.2 8
C.3 7 D.no answer
B
f(0,10,36)=f(1,9,36)=f(2,8,36)=str(2)+" "+str(8)="2 8"。
√
8.定义如下函数：
def f(x,y,flag):
if flag==False:
return x*y//f(x,y,not flag)
if x==y:
return x
elif xreturn f(x,y-x,flag)
else:
return f(x-y,y,flag)
执行语句w=f(6,9,False)后，w的值为 （　　）
A.18 B.9
C.6 D.3
A
w=f(6,9,False)=54//f(6,9,True)=54//f(6,3,True)=54//f(3,3,True)=54//3=18。
√
9.有如下Python程序段：
def hs(m):
if m<=1:
f=1
else:
f=hs(m-1)+hs(m-2)
return f
ans=0
for i in range(5):
if hs(i)%2==1:
ans+=1
print(ans)
执行该程序段后，输出的结果是 （　　）
A.2 B.10
C.4 D.5
C
√
hs(0)=1，hs(1)=1，hs(2)=hs(1)+hs(0)=2，hs(3)=hs(2)+hs(1)=3，hs(4)=hs(3)+hs(2)=5，ans表示hs(0)~hs(4)中奇数的个数，故输出的结果是4。
10.将二进制整数转换成十六进制数的Python程序段如下：
ch=["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]
x=int(input("请输入一个二进制整数："))
y=0
k=0
while True:　#将二进制转换为十进制
k+=1
i=x%10
if i==1:
y=y+2**(k-1)
x=x//10
if x==0:
break
z=""
while True:　#将十进制转为十六进制
k=y%16
z=　　　　　　　1
y=y//16
if y==0:
break
print(z)
若输入的二进制整数为11011，则画线处应填入的代码和输出的结果分别是 （　　）
A.z+ch[k]和37
B.ch[k]+z和2C
C.ch[k]+z和1B
D.z+ch[k]和46
C
该程序段先通过从右往左的顺序提取二进制数11011的每一位，然后每一位都乘以对应的权值，之后相加得到十进制数。将十进制数整除16得到商和余数，直到余数为0退出循环，最后逆向连接余数，因此画线处填入的代码是ch[k]+z，输出的结果是1B。
√
11.用迭代法求自然对数的底数e的值，e≈1+ 1/1! + 1/2! + 1/3! + … + 1/n! ，直到最后一项的值小于0.00001为止。实现上述功能的Python程序如下，请在画线处填入合适的代码。
　　　①　　　1
jc=1;i=0
while 1/jc>=0.00001:
e=　　　②　　　1
i=i+1
jc=jc*i
'''使用round函数，将e以保留5位小数的格式输出'''
print(　　　③　　　)
e=0
①处根据公式及代码可知，此处为迭代变量e赋初值0。②处使用变量jc存储阶乘作为分母，分子为1，变量e存储累加的结果，故填入代码为e=e+1/jc。③处使用round()函数保留计算结果e的5位小数，故填入代码为round(e,5)。
e+1/jc
round(e,5)
12.编写如下Python程序，实现输入一个十进制数，将它转换为八进制数后输出。例如，输入十进制数为15，输出结果如图所示。
请在画线处填入合适的代码。
y=int(input("输入要转换的十进制数："))
s=""
while y!=0:　#除8取余，逆序排列
r=　　　①　　　1
s=　　　②　　　1
y=y//8
print("转换为八进制数后：",s)
①处根据提示，除8取余，逆序排列，r表示余数，故填入代码为y%8。②处是将余数逆序添加到字符串s中，由于r的数据类型为整型，所以使用函数str()将其转换为字符串类型后拼接在s的左边，故填入代码为str(r)+s。
输入要转换的十进制数：15
转换为八进制数后： 17
y%8
str(r)+s
13.输入两个正整数，使用递归算法求这两个正整数的最大公约数。具体步骤为：给定两个整数，若这两个整数相等，则最大公约数是其本身；若不相等，则取这两个整数的差和这两个数中较小的那个数进行比较，相等则为最大公约数，不相等则重复上面的步骤，直到相等。实现上述功能的Python程序如下：
def gcd(x,y):
if 　　　①　　　:
return x
else:
small=min(x,y)
　　　②　　　1
a=int(input("输入第一个整数："))
b=int(input("输入第二个整数："))
print(gcd(a,b))
　　　　　　
x==y
return gcd(small,abs(x-y))
请回答下列问题：
（1）请在画线处填入合适的代码。
（2）执行该程序段后，输入两个整数分别为48和36，则输出的结果是　　　　　　　。
（3）已知a与b的乘积等于它们的最大公约数与最小公倍数的乘积，若要输出两个整数的最小公倍数，则加框处应填入的代码是　　　　　　　。
（1）①处用于判断两个整数相等的情况，故填入代码为x==y。②处是两个整数不相等时，取两个整数的差和两个数中较小的那个数，重新求解这两个整数的最大公约数。　（2）整数48和36的最大公约数是12。　（3）最小公倍数为两个整数的乘积除以最大公约数得到的整数部分，故应填入的代码为print(a*b//gcd(a,b))。
12
print(a*b//gcd(a,b))
14.三次函数f(x)=x3/3-2x2+3x-2的图像如图所示。
　　观察图像可知，在[0,4]区间内，存在一个局部极大点P（在P附近的函数值都小于f(P)）和局部极小点Q（在Q附近的函数值都大于f(Q)）。寻找P和Q近似值的方法如下：在[0,4]区间内，每隔e（e=0.001）取一个值逐一枚举，若找到某个值x能同时满足f(x)>f(x-e)和f(x)>f(x+e)，则x可作为P的近似值；若找到某个值x能同时满足f(x)def f(x):
y=x**3/3-2*x**2+3*x-2
return y
e=0.001
x=0
while x<5:
a=　　　①　　　　#前一个函数值
b=f(x)　#当前函数值
c=f(x+e)　#后一个函数值
if 　　　②　　　:
print(f"当x={x}时，函数的极大值近似值为{b}")
if a>b and c>b:
print(f"当x={x}时，函数的极小值近似值为{b}")
x=　　　③　　　1
f(x-e)
b>a and b>c
x+e
①处根据题干每隔e取一个值逐一枚举可知，前一个函数值为f(x-e)。②处是b为极大值近似值的条件，也就是当它的前一个函数值和后一个函数值都比它小时，表达式为b>a and b>c。③处更新x的值，每次累加e。

展开更多......

收起↑