- images
- results
- .gitignore
- 1.1概论.ipynb
- 1.2 环境配置.pdf
- 1.3数据类型.ipynb
- 1.4 人机交互.ipynb
- 1.5 对象与变量.ipynb
- 1.6 编码与命名规范.ipynb
- 2.1 数值类型.ipynb
- 2.2 数值类型转换.ipynb
- 2.3 数值元算.ipynb
- 2.4常用数学运算函数.ipynb
- 2.5 math 模块及其应用.ipynb
- 2.6.1 逻辑值测试.ipynb
- 2.6.2 成员运算.ipynb
- 2.6.3 比较运算.ipynb
- 2.6.4 布尔运算.ipynb
- 2.6.5 运算优先级.ipynb
- 2.ipynb
- 3.1 流程控制结构.ipynb
- 3.3.1 for 循环语句.ipynb
- 3.3.3 rang.ipynb
- 3.3.3 while 循环语句.ipynb
- 3.4 and 3.5 分支结构和条件.ipynb
- 3.6 and 3.7 .ipynb
- 3.9 异常处理.ipynb
- 4 函数和模块化编程.ipynb
- 4.1 函数的定义、调用与返回值.ipynb
- 4.2 函数的参数传递.ipynb
- 4.3 变量的作用域.ipynb
- 4.4 匿名函数.ipynb
- 4.5 递归.ipynb
- 4.6 内置函数.ipynb
- 4.7 模块化程序设计.ipynb
- 5.1 序列通用操作.ipynb
- 5.1.1 索引.ipynb
- 5.1.2 切片.ipynb
- 5.1.3 序列拼接与重复.ipynb
- 5.1.4 成员测试.ipynb
- 5.2.1 字符串的创建.ipynb
- 5.2.2 字符串常量.ipynb
- 5.2.4 字符串的遍历.ipynb
- 5.2.5 文件遍历.ipynb
- 5.2.6 字符串的处理方法.ipynb
- 5.2.7 字符串格式化.ipynb
- 5.2.8 转义字符.ipynb
- 5.3 random 模块及其应用.ipynb
- 6.1 元组.ipynb
- 6.2 列表.ipynb
- 6.2.1 列表的创建.ipynb
- 6.2.2 列表的更新.ipynb
- 6.2.3 列表的删除.ipynb
- 6.2.4 列表的排序.ipynb
- 6.2.5 列表赋值与复制.ipynb
- 6.2.6 列表推导式.ipynb
- 6.2.8 常用内置函数.ipynb
- 6.2.9 列表嵌套及其排序.ipynb
- 6.3 列表综合应用.ipynb
- 7.1.1 集合的创建.ipynb
- 7.1.2可变集合类型的操作.ipynb
- 7.1.3 成员关系.ipynb
- 7.1.4 集合关系.ipynb
- 7.1.5 集合运算.ipynb
- 7.2.1 字典创建.ipynb
- 7.2.2 获取字典值.ipynb
- 7.2.3 修改字典值.ipynb
- 7.2.4内置函数与方法.ipynb
- 7.2.5字典排序输出.ipynb
- 7.3 集合与字典的应用.ipynb
- 8 中 numpy 概述.ipynb
- 8 中panda 库.ipynb
- 8.1 文件的打开与关闭.ipynb
- 8.2 文件读写操作.ipynb
- 8.3 文件的应用.ipynb
- 8.4 numpy 文件操作.ipynb
- 8.4.2 and 3.ipynb
- 8.5.1 pandas文件读写.ipynb
- 8.5.2 and 3 and 4.ipynb
- 9.1 matplotlib 线性图.ipynb
- 9.1.5 数据文化绘图.ipynb
- 9.2 非线性图.ipynb
- 9.3 词云.ipynb
- _overview.md
- _readme.ipynb
- coding_here.ipynb
- dream.png
- score.txt
- score_total.csv
- 成绩分析综合.json
3.3.3 while 循环语句.ipynb @master — view markup · raw · history · blame
3.4 while循环¶
循环结构表示程序__重复执行__某个或某些操作,直到某__条件为假(或为真)__时才可终止循环。 在问题求解过程中,很多时候需要重复做一件事情很多次。这时可以选择__重复使用这些语句__来解决问题,也可以使用__循环控制结构__来完成。
人类重复做某件事情次数越多,出错的概率越大,所以数学家们研究了各种等差数列、等比数列的求和公式、求积公式,把重复多次的工作变成一个表达式的求解,以降低出错的概率。 计算机与人不同,计算机可以快速精准的完成重复性的工作,而循环结构的使用,既可以__减少代码行数__、又可以__简化业务逻辑__,提高程序的__可读性__。
Python中控制循环有两种结构:
1. while 循环
2. for...in 遍历循环
while循环语句一般用于__循环次数不确定__的情况下,通过判断是否满足某个指定的__条件__来决定是否进行下一次循环,也称为条件循环语句。
判断条件的返回值为__布尔型__,即__True__ 或 __False__,任何__非0__或__非空__的值均为True。
当判断__条件表达式__的结果为__True__时,执行while下面缩进部分语句块中的全部语句,然后再次检查判断条件的值,重复以上操作,直到判断条件的结果为False时结束循环。
在循环体的语句中,一定有一条语句会使循环判断__条件__的__结果发生变化__,使之在经过有限次运行后能够变__“假”__,从而__结束循环__。或在循环体中设定一个__边界条件__,当条件满足时,执行__break语句__直接终止当前循环。
while循环的语法如下:
while 判断条件:
语句块(使判断条件表达式的值趋向于False)
实例 4.3 斐波那契数列前n项¶
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,……
斐波那契数列又称黄金分割数列,这个数列从第3项开始,后一项的值总是与他前面两项的和的值相等。
在数学上,以递推的方法定义:
F(1)=1
F(2)=1
F(n)=F(n - 1)+F(n - 2) (n ≥ 3,n ∈ N*)
根据数学上的递推公式,可以先把变量名a,b指向开始两个值 1 和 1,然后构建一个循环。
在循环中输出 a 的值,然后计算 a + b 的和,将标签 a 指向对象 b,将标签 b 指向加和产生的新对象上作为新的一项,这个操作可以用__同步赋值语句__实现:
a, b = b, a + b


a, b = 1, 1 # 初始两项的值
while a < 1000: # 设定终止条件,当a值大于或等于1000时终止循环
print(a, end=',') # 输出当前a 值,不换行,用逗号结束输出
a, b = b, a + b # 将 b 和 a + b 值分别赋值给变量名a和b
# 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
while循环还有一个重要的应用就是构造__无限次循环__,在循环体中使用__if语句__判定是否__达到结束循环的条件__,当满足条件时,用__break语句__终止循环。
此时需要注意,在程序执行过程中,__务必要有__使if 语句中的表达式结果__趋于False__的语句,以避免程序__陷入无限循环__。
实例 4.4 Leibniz公式计算圆周率¶
历史上有许多计算圆周率$pi$的公式,其中,格雷戈里和莱布尼茨发现了下面的公式(可由等比数列求和公式变换并积分获得):

这个公式累加1项是4.00,累加2项是2.67,累加3项是3.47...趋进于圆周率值。编程对其各项进行累加,直到最后一项的绝对值小于$10^{-6}$为止,输出此时的圆周率值。
公式中每一项的分母数字正好相差2,符号正负交替,可以利用循环结构求解。
因循环次数未知,但知道终止条件,所以可以用while加判断条件控制循环,条件为True时进入循环,在循环里使判断条件值发生改变,待判断条件值为False时,不再进入循环。
pi, i = 0, 1 # 设定pi初值0, i为分母变量名
sign = 1 # sign用于改变符号
while 1 / i >= 1e-6: # 条件表达式值为True时进入循环
pi = pi + sign * 1 / i # 累加,每次循环加上最后一项
sign = - sign # 每循环一次改变一次符号,实现正负项交替
i = i + 2 # 下一项分母比当前项大2,此语句也会使1/i值变小
print(pi * 4) # 乘4得以π的计算值,放循环外只输出一次
也可用while加True或一个结果为True的表达式,使循环判断条件永远为True,构建无限次循环。
在循环体中,判断循环控制条件1/i < $10^{-6}$的结果为False时,用break__结束循环__,使循环可以在有限次数内结束。
此处brek作用是程序执行到此语句时,提前__结束循环__。
pi, i = 0, 1 # 设定pi初值0, i为分母变量名
sign = 1 # sign用于改变符号
while True: # 构建无限循环
if 1 / i < 1e-6: # 最末项大于等于10-6时
break # 结束循环
else: # 否则执行累加语句
pi = pi + sign * 1 / i # 累加,每次循环加上最后一项
sign = - sign # 每循环一次改变一次符号,实现正负项交替
i = i + 2 # 下一项分母比当前项大2
print(pi * 4) # 乘4得以π的计算值,放循环外只输出一次
输出:
3.141590653589692
这个公式简单而优美,但收敛的较慢。
增加计算的项数可以提高计算精度,将终止条件设为$10^{-9}$时可以提高3位数的精度,再想提高精度,时间就难以接受了。
3.141592651589258
user_name = input()
while user_name: # 当输入非空时执行循环
print(f'欢迎你,{user_name}同学!') # 输出
user_name = input() # 循环体内的输入语句可重复接收输入
# 可用无限循环方法,用break结束程序
while True:
user_name = input()
if user_name != '': # 当user_name为非空字符串时,即输入非空时
print(f'欢迎你,{user_name}同学!') # 输出
else:
break
while True:
user_name = input()
if user_name: # 当user_name为非空字符串时,即输入非空时
print(f'欢迎你,{user_name}同学!') # 输出
else:
break
# 可用前面讲过的赋值表达式更简洁的实现
while user_name := input(): # 当输入非空时执行循环
print(f'欢迎你,{user_name}同学!') # 输出
练一练
# 补充你的代码
4.5 应用之二分法¶
对于区间[a,b]上连续不断且f(a)·f(b)<0的函数y=f(x),通过不断地把函数f(x)的零点所在的区间一分为二,使区间的两个端点逐步逼近零点,进而得到零点近似值的方法叫二分法。

当数据量很大适宜采用该方法。
采用二分法查找时,数据需是排好序的。
基本思想:
假设数据是按升序排序的,对于给定值key,从序列的中间位置k开始比较,
如果当前位置arr[k]值等于key,则查找成功;
若key小于当前位置值arr[k],则在数列的前半段中查找,arr[low,mid-1];
若key大于当前位置值arr[k],则在数列的后半段中继续查找arr[mid+1,high],
直到找到为止,时间复杂度:O(log(n))
二分法求平方根¶
设计一个用二分法计算一个大于或等于 1 的实数 n 的平方根的函数sqrt_binary(n),计算精度控制在计算结果的平方与输入的误差不大于1e-6。 注:初始区间取[0,n]
num = float(input()) # 输入一个大于1的数
low, high = 0, num # 初始化二分查找的上下界
while True: # 开始无限循环
x = (high + low) / 2 # 计算上下界的中点
if abs(x ** 2 - num) <= 1e-6: # 如果中点的平方与输入的数的差的绝对值小于等于1e-6
print(x) # 打印中点的值
break # 结束循环
elif x ** 2 - num < 0: # 如果中点的平方小于输入的数
low = x # 将中点设为新的下界
else: # 如果中点的平方大于输入的数
high = x # 将中点设为新的上界
import math
def sqrt_binary(num):
low, high = 0, num
while True:
x = (high + low) / 2
if abs(x ** 2 - num) <= 1e-6:
return x
elif x ** 2 - num < 0:
low = x
else:
high = x
num = float(input())
if num >= 1:
print(sqrt_binary(num))
print(math.sqrt(num))
二分法求函数的零点¶
现有方程: $ f(x) = x^5-15x^4+85x^3-225x^2+274x-121p $ 已知f(x)在[1.5,2.4]区间有且只有一个根,用二分法求解该根。
n = int(input()) # 输入一个整数n,表示小数点后的位数
low, high = 1.5, 2.4 # 初始化二分查找的上下界
while True: # 开始循环
x = (low + high) / 2 # 计算上下界的中点
# 计算多项式的值
y = x ** 5 - 15 * x ** 4 + 85 * x ** 3 - 225 * x ** 2 + 274 * x - 121
if abs(y) < 1 * 10 ** -n: # 如果多项式的值的绝对值小于10的-n次方
print('{:.6f}'.format(x)) # 打印中点的值,保留6位小数
break # 结束循环
elif y < 0: # 如果多项式的值小于0
high = x # 将中点设为新的上界
else: # 如果多项式的值大于0
low = x # 将中点设为新的下界
def f(x):
return x ** 5 - 15 * x ** 4 + 85 * x ** 3 - 225 * x ** 2 + 274 * x - 121
def bisection_method(low, high):
while True:
mid = (low + high) / 2
if abs(f(mid)) < 1 * 10 ** -n:
return '{:.6f}'.format(mid)
elif f(mid) < 0:
high = mid
else:
low = mid
if __name__ == '__main__':
n = int(input())
Low, High = 1.5, 2.4
print(bisection_method(Low, High))
二分法猜数游戏¶
写一个1-1024之间的整数,猜测这个数字,每欠猜测后给出“大了”“小了”“猜中”的提示
import random
x = random.randint(1, 1024) # 随机产生一个0-1024之间的整数
for i in range(10): # 允许猜10次
guess = int(input()) # 输入猜的整数
if guess == x:
print('猜中了') # 猜中则终止循环
break
elif guess > x:
print('猜的数大了')
else:
print('猜的数小了')
else:
print('你用完了十次机会也没猜中哦')
True+1
print(bool(""))