Python程序语言设计：笔记汇总（上）
Python程序语言设计：笔记汇总（上）
- 第【1】周：Python基本语法元素
- 1.1 程序设计基本方法
- 1.2 Python开发环境配置
- 1.3 实例1：温度转换
- 1.4 Python语法元素分析
- 第【2】周：Python基本图形绘制
- 2.1 Python语言
- 2.2 实例2：Python蟒蛇绘制
- 2.3 模块1：turtle库的使用
- 2.4 turtle库程序语法元素分析
- 第【3】周：Python基本数据类型
- 3.1 数据类型及操作
- 3.2 实例3：天天向上的力量
- 3.3 字符串类型及操作
- 3.4 模块2：time库的使用
- 3.5 实例4：文本进度条
- 第【4】周：程序的控制结构
- 4.1 程序的分支结构
- 4.2 实例5：身体质量指数BMI
- 4.3 程序的循环结构
- 4.4 模块3：random库
- 4.5 实例6：圆周率计算
第【1】周：Python基本语法元素
1.1 程序设计基本方法
(1) 基本概念
计算机：根据计算机指令而进行的操作。具有功能性+可编程性的特点，按照摩尔定律发展，表现为指数形式。
程序设计：是计算机可编程性的体现。
程序设计语言：用于交互的人造语言。
(2) 执行方式
编译：compiler，将源代码一次性转换成目标代码的过程。静态语言：c/c++, java，执行速度更快。
解释：interpreter，将源代码逐步转换成目标代码，同时逐条运行的过程。脚本语言：python, js, php，维护更灵活。
源代码：采用某种编程语言编写的计算机程序，人类可读
eg: result=2+3
目标代码：计算机可直接执行，人类不可读
eg: 11010010, 00111011
(3) 编写方法: IPO
① I: input，输入。以文件，网络，控制台等方式输入
② P: process，处理。算法，将‘I’进行计算产生‘O’的过程
③ O: output，输出。以文件，图片，网络，控制台等方式展示运算结果的方式
(4) 编程步骤
两种：
① 分析问题→划分边界→设计算法→编写程序→调试测试→升级维护
② 确定IPO→编写程序→调试程序
(5) 计算思维
计算思维：区别逻辑思维和实证思维的第三种思维
1.2 Python开发环境配置
IDLE：集成开发语言环境
编程方式：文件式、交互式
① 交互式：
② 文件式：以文件的形式
1.3 实例1：温度转换
(1) 问题分析
I: 输入带摄氏或华氏的温度值
P: 温度转化算法
O: 输出转换后带华氏或摄氏的温度值
转换公式：
C = ( F − 32 ) / 1.8 C=(F-32)/1.8 C=(F−32)/1.8 F = 1.8 C + 32 F=1.8C+32 F=1.8C+32
(2) 相关代码
#TempConvert.py
TempStr = input("请输入带有符号的温度值：")
if TempStr[-1] in ['F','f']:
C=(eval(TempStr[0:-1])-32)/1.8
print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C','c']:
C=1.8*eval(TempStr[0:-1])+32
print("转换后的温度是{:.2f}C".format(C))
else:
print("输入格式有误")
(3) 举一反三
研究思路：确定框架结构→逐行分析→逐词理解
应用场景：货币问题、长度问题
1.4 Python语法元素分析
(1) 程序的格式框架
① 缩进：
表示代码间的所属关系，用4个空格或1个TAB键表示。
② 注释：提高可读性，不被执行
单行注释：#
多行注释：’’’
③ 代码高亮：
颜色不同，方便阅读
(2) 命名与保留字
① 变量：用来保存和表示数据的占位符。
a.占位符
b.用<=>赋值，tempstr=‘82f’
② 命名：关联标识符的过程
a.大小写字母、数字、下划线和汉字组合
b.大小写敏感
③ 保留字：内部定义并保留使用的标识符
a.33个
b.大小写不同，Python≠python
| and | elif | import | raise | global |
|---|---|---|---|---|
| as | else | in | return | nonlocal |
| assert | except | is | try | True |
| break | finally | lambda | while | False |
| class | for | not | with | None |
| continue | from | or | yield | |
| def | if | pass | del |
保留字：不会出现本次课程
(3) 数据类型
① 字符串：由0或多个字符组成的有序字符序列
a.编号从0开始
b.序号：正向递增(从0开始)和反向递减(从-1开始)
c.索引：<字符串>[M]
d.切片：<字符串>[M: N]
'11011101'
② 数字类型：整数、浮点数
10011101 #整数
2.34 #浮点数
③ 列表类型：由0或多个数据组成的有序字符序列
a. [], 采用<,>分隔元素
b. in -判断一个元素是否在列表中
['f','F']
1 in [1,2,3,4]
(4) 语句与函数
a. 赋值语句<=>
a=5
b. 分支语句 -由判断条件决定程序运行方向的语句
-if，elif，else
-<:>是语句的一部分
c. 函数 -根据输入参数产生不同输出的功能过程
-<函数名>(<参数>)
#输入函数
s=input()
#输出函数
print('转换后的温度是{:.2f}C'.format(s)) #格式化
d. eval函数
评估函数：去掉参数最外侧引号并执行余下语句的函数
eval('1') #得到1
eval('2+3') #得到5
eval("'2+3'") #得到'2+3'
eval('print("hello")') #得到hello
(5) 练习
| 输入 | 输出 |
|---|---|
| 1239876543210 | 一二三九八七六五四三二一零 |
template='零一二三四五六七八九'
s=eval(input())
for i in s:
print(template[s],end='')
第【2】周：Python基本图形绘制
2.1 Python语言
(1) 演进历程
1946年：第一台计算机诞生
① 1946-1981：结构时代，解决计算机能力问题
② 1981-2008：网络和视窗时代，解决交互问题
③ 2008-2016：复杂信息系统时代，解决数据问题
④ 2016-：人工智能时代，解决人类问题
(2) Python特点与优势
-强制可读性 -较少的底层语法元素 -多种编程方式 -支持中文字符
-C代码量的10% ->13万第三方库 -快速增长的计算生态
-避免重复造轮子 -开放共享 -跨操作系统平台
总结：语法简洁+生态高产+通用性
(3) 编程语言种类
机器语言：代码直接执行，与CPU型号有关
汇编语言：有助记符，汇编器，与CPU型号有关，add 2,3 result
高级语言：更接近自然语言，result=2+3
超级语言：庞大计算生态，result=sum(2,3)
2.2 实例2：Python蟒蛇绘制
#PythonDraw.py
import turtle
turtle.setup(650,350,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor('purple')
turtle.seth(-40)
for i in range(4):
turtle.circle(40,80)
turtle.circle(-40,80)
turtle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40*2/3)
turtle.done()
#用来停止画笔绘制，但绘图窗体不关闭
#建议在每个turtle绘图最后增加turtle.down()
应用场景：圆形、五角星、国旗、机器猫
2.3 模块1：turtle库的使用
(1) 绘图窗体
turtle.setup(width,height,startx,starty)
#width:窗体宽度，height:窗体高度，startx:窗体距离左侧屏幕的值，starty:窗体距离上侧屏幕的值
(2) 空间坐标体系
① 绝对坐标
turtle.goto(x,y)
② 海龟坐标
turtle.goto(x,y)
(3) 角度坐标体系
① 绝对角度
turtle.seth(angle)
#seth：只改变方向
② 海龟角度
turtle.left(angle)
turtle.right(angle)
(4) RGB色彩体系
红+绿+蓝
turtle.colormode(mode)
#0-1:小数模式
#0-255：整数模式
2.4 turtle库程序语法元素分析
(1) 库引用与import
① import <库名>
import turtle
turtle.penup()
优点：不会出现函数重名的情况
② from <库名> import <函数名>
from turtle import penup
penup()
#引入所有函数
from turtle import *
应用：适合程序代码少的情况
③ import <库名> as <库别名>
import turtle as t
t.penup()
综合①②的优点
(2) turtle画笔控制函数
turtle.penup()
#简写turtle.pu(), 抬起画笔
turtle.pendown()
#简写turtle.pd(), 落下画笔
turtle.pensize(width)
#简写turtle.width(width), 画笔宽度
turtle.pencolor(color)
# color为字符串或r,g,b值
# turtle.pencolor('purple')
# turtle.pencolor(0.63,0.13,0.94)
(3) turtle运动控制函数
turtle.forward(d)
#简写turtle.fd(d), 走直线
turtle.circle(r,extent=None)
# r半径，后者为弧度， 走曲线
(4) turtle方向控制函数
turtle.setheading(angle)
#简写turtle.seth(), 绝对角度
turtle.left(angle)
turtle.right(angle)
#海龟角度
(5) 循环语句和range函数
① 循环语句：
for <变量> in range(<参数>)：
<被执行参数>
② range函数：
#产生循环计数序列
range(N)
#产生[0,N-1]的整数序列，共N个
range(M,N)
#产生[M,N-1]的整数序列，共N-M个
第【3】周：Python基本数据类型
3.1 数据类型及操作
(1) 整数类型
① 可正可负，没有取值范围
② 4种进制
十进制：1010, 99
二进制：以0b或0B开头 -0b010
八进制：以0o或0O开头 -0o123
十六进制：以0x或0X开头 -0x9a
(2) 浮点数类型
① 带有小数点及小数的数字
取值范围[-10308,10308]，精度数量级为10-16,无限范围
② 浮点数运算存在不确定尾数，不是bug
→0.1+0.2==0.3
False
→round(0.1+0.2,1)==0.3
True
-round(x,d): 对x四舍五入，d是小数截取位数
③ 可以采用科学计数法表示
< a > e < b >: a × 10 b, e或E均可
4.3 e -3 = 0.0043
9.6 E 5 = 960000
(3) 复数类型
a+bj，a为实部，b为虚部，j=sqrt(-1)
z=1.23e-4+5.6e+8j
#z.real获取实部
#z.image获取虚部
(4) 数值运算操作符
① +加 -减 *乘 /浮点除 //整数除
10/3=3.333...5
10//3=3
② +x正数;-y负数;x%y余数;x**y幂运算
10%3=1
10**0.5=sqrt(10)
③ x op = y
二元操作符
x**=3
#等价于x=x**3
(5) 数字类型的关系
类型间可进行混合运算，生成结果为“最宽”类型
整数→浮点数→复数
6.0+0j → 6.3+0j → 6.3+5j
eg: 123+4.0=127.0
(6) 数值运算函数
abs(x) #|x|
#abs(-10.01)=10.01
divmod(x,y) #商余(x//y,x%y)
#divmod(10,3)=(3,1)
pow(x,y[,z]) # 幂余(x**y[%z])
#pow(3,pow(3,99),1000)=4587
#[]可省略
round(x[,d]) #四舍五入
max(x1,x2,...,xn)
min(x1,x2,...,xn)
int(x) #将x变成整数
#int(123.12)=123; int('123.12')=123
float(x) #将x变成浮点数
#float(12)=12.0;float('12.3')=12.3
complex(x) #将x变成复数
#complex(4)=4+0j
(7) 总结
①整数类型：无限范围，四种进制
②浮点数类型：近似无限范围，小尾数，科学计数法
③数值运算操作符：±
④数值运算函数：abs()
3.2 实例3：天天向上的力量
(1) 基本问题：持续的价值
-一年365天，每天进步1%，累计进步多少呢？
1.0 1 365 = 37.78 1.01^{365}=37.78 1.01365=37.78
-一年365天，每天退步1%，累计退步多少呢？
0.9 9 365 = 0.03 0.99^{365}=0.03 0.99365=0.03
(2) 相关代码
#进步或退步1%的力量
dayup=pow(1.01,365)
daydown=pow(0.99,365)
print('向上：{:.2f},向下：{:2f}'.format(dayup,daydown))
#进步或退步0.5%的力量
dayfactor=0.005
dayup=pow(1+dayfactor,365)
daydown=pow(1-dayfactor,365)
print('向上：{:.2f},向下：{:2f}'.format(dayup,daydown))
#工作日的力量
#工作日进步1%，休息日退步1%
dayup=1.0
dayfactor=0.01
for i in range(365):
if i%7 in [6,0]:
dayup=dayup*(1-dayfactor)
else:
dayup=dayup*(1+dayfactor)
print('工作日的力量：{:.2f}'.format(dayup))
#工作日的努力
#工作日要达到什么水平，才能与每天努力1%一样
dayfactor0=0.01
dayup0=(1+dayfactor0)**365
def dayUP(df):
dayup=1
for i in range(365):
if i%7 in [6,0]:
dayup=dayup*(1-0.01)
else:
dayup=dayup*(1+df)
return dayup
dayfactor=0.01
while dayUP(dayfactor)<dayup0:
dayfactor=dayfactor+0.001
print("工作日的努力参数: {:.3f}".format(dayfactor))
3.3 字符串类型及操作
(1) 字符串类型及操作
① 由0或多个字符组成的有序字符序列
有序序列，可索引，从0开始
② 有两类共四种表示方式
-单/双引号： ’ ’ 或 " "
-单/双三引号：’’’ ‘’’ 或 “”" “”"
③ 序号：正向递增、返现递减
④ 索引和切片
-索引：<字符串>[M]
-切片：<字符串>[M : N]
-使用：[M : N : k]根据步长对字符串切片
M='01234567890'
M[:3]='012'
M[1:8:2]='1357'
M[::-1]='09876543210' #逆序
⑤ 转义符
-表达特定字符的本意
'(这里有个双引号\")'
#等价：这里有个双引号(\)
-形成组合
\b #回退，向前一格
\n #换行，下一行
\r #回车，光标移动到本行行首
(2) 字符串操作符
x+y: 连接两个字符串x,y
n * x 或 x * n： 复制n次字符串x
x in s: 如果x是s的字符串，返回True; 否则False
#获取星期字符串
#-输入：1-7的整数，表示星期几
#-输出：输入整数对应的星期字符串
#-例如：输入3，输出星期三
WeekStr='一二三四五六七'
WeekId=eval(input('请输入星期数字(1-7):'))
print('星期'+WeekStr[WeekId-1])
(3) 字符串处理函数
len(x): 长度
len('一二三四五六')
#输出6
str(x): 任意类型→字符串类型，与eval函数相反
str(1.23)
#输出'1.23'
str([1,2])
#输出'[1,2]'
hex(x) or oct(x): 整数x→十六进制或八进制小写形式字符串
hex(425)
#输出'0x1a9'
oct(425)
#输出'0o651'
chr(x) or ord(x): uniclde→单字符 或 单字符→uniclde
(4) Unicode编码
-Python字符串的编码方式
-统一字符编码，即覆盖几乎所有字符的编码形式
-从0到1114111(0X10FFFF)空间，每个编码对应一个字符
一些有趣的例子：
'1+1=2'+chr(10004)
#输出'1+1=2√'
'这个x字符的Unicode的值是：'+strlord('x')
#输出这个x字符的Unicode的值是：
for i in range(12):
print(chr(9800+i),end='')
#输出12星座的特殊符号
(5) 字符串处理方法
< a >.< b >(): < 对象 >.<方法>()
str.lower() or str.upper(): 全部字符小写或大写
'Abc'.lower() #输出'abc'
str.split(sep=None): 返回列表，由sep分隔
'A,B,C'.spilt(',') #输出['A','B','C']
str.count(sub): 返回字符串在str中出现的字数
'an apple a day'.count('a') #输出4
str.replace(old,new): 替换
'Python'.replace('n','n123.io') #输出'Python123.io'
str.center(width[,fillchar]): 设置格式，宽度 填充
'Python'.center(20,'=') #输出'=======Python======='
str.strip(chars): 从str中去掉在其左侧和右侧chars中列出的字符
'= Python=.strip(' =np') #输出'yhtho'
str.join(iter): 在iter变量除最后元素外每个元素后增加一个str
','.join('12345') #输出'1,2,3,4,5'
(6) 字符串类型格式化
<模板字符串>.format(<逗号分隔的参数>)
槽：{} ——参数序号
槽内部对格式化的配置方式：{<参数序号>:<格式控制标记>}
| : | < 填充 > | < 对齐 > | <宽度> | < , > | < .精度 > | < 类型 > |
|---|---|---|---|---|---|---|
| 引导符号 | 用于填空的单个字符 | <>^:左/右/居中对齐 | 槽设定的输出宽度 | 数字的千位分隔符 | 浮点数小数精度或字符串最大输出长度 | 整数类型: bcdoxX;浮点数类型: eEf% |
'{0:=^20}'.format('PYTHON')
#输出'=======PYTHON======='
'{0:,.2f}'.format(12345.6789)
#输出'12,345.68'
'{0:b},{0:c},{0:d},{0:x},{0:X},'.format(425)
#输出'11010101,∑,425,651,1a9,1A9'
#c表示输出Unicode
(7) 总结
①正向递增 反向递减，<字符串>[M:N:K]
②+ * len str hex oct chr oct
③lower upper split count replace center strip join
④.format()格式化
3.4 模块2：time库的使用
(1) 基本介绍
功能：处理时间的标准库
① import time
② 三类函数
-时间获取：time(), ctime(), gmtime()
-时间格式化：strftime(), strptime()
-程序计时：sleep(), perf_counter()
(2) 时间获取
① time()：获取当前时间戳 19700101 00:00:00 以s为单位的数值，‘浮点数’
time.time()
#输出1516939876.6022282
② ctime()：易读方式的当前时间，‘字符串’
time.ctime()
#输出'Fri Jan 26 12:11:16 2018'
③ gmtime()：当前时间，表示为计算机可处理的时间格式
time.gmtime()
#输出time.struct_time(tm_year=2018,tm_mon=1,tm_mday=26,tm_hour=12,tm_min=11,tm_sec=16,tm_wday=4,tm_yday=26,tm_isdst=0)
(3) 时间格式化
功能：将时间以合理的方式展示出来
① strftime(tpl,ts)
-tpl：格式化模板字符串，用来定义输出效果
-ts：计算机内部时间类型变量
t=time.gmtime()
time.strftime('%Y-%m-%d %H:%M:%S',t)
#输出 '2018-01-26 12:55:20'
| 格式化字符串 | %Y | %m | %B | %b | %d | %A |
|---|---|---|---|---|---|---|
| 说明 | 年份 | 月份 | 月份 | 月份 | 日期 | 星期 |
| 范围 | 0000-9999 | 01-12 | January-December | Jan-Dec | 01-31 | Monday-Sunday |
| 实例 | 2020 | 10 | March | Apr | 11 | Monday |
| 格式化字符串 | %a | %H | %I | %P | %M | %S |
|---|---|---|---|---|---|---|
| 说明 | 星期 | 小时 | 小时 | 上下午 | 分钟 | 秒 |
| 范围 | Mon-Sun | 00-23 | 01-12 | AM-PM | 00-59 | 00-59 |
| 实例 | Mon | 10 | 8 | AM | 11 | 20 |
② strptime(str,tpl)
-tpl：格式化模板字符串，用来定义输出效果
-ts：计算机内部时间类型变量
t='2018-01-26 12:11:16'
time.strptime('%Y-%m-%d %H:%M:%S')
#输出 time.struct_time(tm_year=2018,tm_mon=1,tm_mday=26,tm_hour=12,tm_min=11,tm_sec=16,tm_wday=4,tm_yday=26,tm_isdst=0)
(4) 程序计时
功能：测量起止动作所经历时间的过程。
① sleep(s)
功能：产生时间。s表示拟休眠的时间。
def wait:
time.sleep(3.3)
wait() #程序将等待3.3s后再退出
② perf_counter()
功能：返回一个CPU级别的精确时间计数值，单位为s。由于这个计数值起点不确定，连续调用差值才有意义。
start=time.perf_counter()
end=time.perf_counter()
end-start #测量时间
3.5 实例4：文本进度条
(1) 需求分析
① 采用字符串方式打印可以动态变化的文本进度条
② 进度条需要能在一行中逐渐变化
(2) 问题分析
如何获得文本进度条的变化时间？
-采用sleep()模拟一个持续的进度
(3) 相关代码
① 简单的开始
#TextProBarV1.py
import time
scale=10 #文本宽度
print("------执行开始------")
for i in range(scale+1):
a="*"*i #*复制次数
b="+"*(scale-i) #·复制的次数
c=(i/scale)*100 #输出当前的百分比
print("{:^3.0f}%[{}->{}]".format(c,a,b))
time.sleep(0.1)
print("------执行结束------")
② 单行动态刷新
-刷新本质：用后打印的字符覆盖之前的字符
-不能换行：print()需要被控制
-要能回退：打印后光标要退回之前的位置 \r
#TextProBarV2.py
import time
for i in range(101): # 0%-100%
print("\r{:3}%".format(i),end="") #\r-单行刷新的关键
time.sleep(0.1)
③ 完整效果
#TextProBarV3.py
import time
scale=50
print("执行开始".center(scale//2,"-"))
start=time.perf_counter() #程序计时显示
for i in range(scale+1):
a="*"*i
b="+"*(scale-i)
c=(i/scale)*100
dur=time.perf_counter()-start #记录每次打印文本的消耗时间
print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end="")
time.sleep(0.1)
print("\n"+"执行结束".center(scale//2,'-'))
#IDLE不能提供\r的效果
#通过控制台cmd直接输入：python TextProBarV3.py
(4) 举一反三
① 计算问题扩展。比较不同算法时间，统计程序运行时间
② 进度条扩展：用户体验
③ 文本进度条的不同设计函数。下载效果（符合用户体验）
第【4】周：程序的控制结构
4.1 程序的分支结构
(1) 单分支结构
if <条件>:
<语句块>
guess=eval(input())
if guess==99:
print('猜对了')
(2) 二分支结构
if <条件>:
<语句块1>
else：
<语句块2>
guess=eval(input())
if guess==99:
print('猜对了')
else：
print('猜错了')
(3) 多分支结构
if <条件>:
<语句块1>
elif：
<语句块2>
......
else：
<语句块n>
guess=eval(input())
if guess==99:
print('猜对了')
elif guess>99：
print('猜大了')
else：
print('猜小了')
(4) 条件判断与组合
① 条件判断：<; <=; >=; >; ==; !=
② 条件组合：and,; or; not
(5) 异常处理
① 一般处理
try:
<语句块1>
except:
<语句块2>
#标注异常类型
try:
<语句块1>
except<异常类型>:
<语句块2>
try:
num=eval(input('请输入一个整数：'))
print(num**2)
except: #或者except NameError:
print('输入不是整数')
② 高级处理
try:
<语句块1>
except: #发生异常时执行
<语句块2>
else: #不发生异常时执行
<语句块3>
finally: #一定执行
<语句块4>
(6) 小结
分支结构：单分支，二分之，多分支，条件判断及组合，异常处理
4.2 实例5：身体质量指数BMI
B M I ( B o d y M a s s I n d e x ) = 体 重 ( k g ) / 身 高 2 ( m ) . BMI(Body Mass Index) = 体重(kg)/身高^{2}(m). BMI(BodyMassIndex)=体重(kg)/身高2(m).
| 标准 | 偏瘦 | 正常 | 偏胖 | 肥胖 |
|---|---|---|---|---|
| 国际 | <18.5 | 18.5-25 | 25-30 | ≥30 |
| 国际 | <18.5 | 18.5-24 | 24-28 | ≥28 |
(1) 问题需求
-输入：给定体重和身高值
-输出：BMI指标分类信息（国际和国内）
(2) 研究思路
-难点：同时输出国际和国内对应的分类
-思路1：分别计算并给出国际和国内对应的分类
-思路2：混合计算并给出国际和国内对应的分类
(3) 相关代码
#BMI.py
height,weight=eval(input())
bmi=weight/pow(height,2)
print('BMI数值为:{:.2f}'.format(bmi))
nat,who='',''
if bmi<18.5:
nat,who='偏瘦','偏瘦'
elif bmi>=18.5 and bmi<24:
nat,who='正常','正常'
elif bmi>=24 and bmi<25:
nat,who='正常','偏胖'
elif bmi>=25 and bmi<28:
nat,who='偏胖','偏胖'
elif bmi>=28 and bmi<30:
nat,who='偏胖','肥胖'
elif bmi>=30:
nat,who='肥胖','肥胖'
print("BMI指标为:国际'{}',国内'{}'".format(nat,who))
注意：
-条件之间的覆盖
-程序可运行，但不正确，要注意多分支
-分支结构是程序的重要框架，对程序看分支
4.3 程序的循环结构
(1) 遍历循环(for)
① 程序语句
for <循环变量> in <遍历结构>:
<语句块>
② 应用场景
a. 计数循环
for i in range(N):
<语句块>
for i in range(5):
print(i)
#例子，输出0 1 2 3 4
for i in range(M,N,k):
<语句块>
for i in range(1,6,2):
print(i)
#例子，输出1 3 5
b. 字符串循环
for c in S:
<语句块>
for c in 'abc':
print(c,end=',')
#例子，输出a,b,c
c. 列表循环
for item in ls:
<语句块>
for item in [123,'PY',456]:
print(item,end=',')
#例子，输出123,PY,456
d. 文件循环
for line in fi:
<语句块>
#fi为文件标识符，遍历其每行（line）
(2) 无限循环(while)
while <条件>:
<语句块>
#反复执行语句块，直到条件不满足时结束
#Ctrl+C：强制退出执行
a=3
while a>0:
a=a-1
print(a)
#输出2 1 0（换行）
(3) 循环控制保留字(break, continue)
-break：跳出并结束当前整个循环，执行循环结束后的语句（只能跳出内层的循环）
-continue：结束档次循环，继续执行后续次数循环
for c in 'PYTHON':
if c=='T':
continue
print(c,end='')
#输出 PYHON
S='PYTHON'
while S!='':
for c in s:
print(c,end='')
S=S[:-1]
#输出 PYTHONPYTHOPYTHPYTPYP
S='PYTHON'
while S!='':
for c in s:
if c=='T':
break
print(c,end='')
S=S[:-1]
#输出 PYPYPYPYPYP
(4) 循环的高级用法(else)
for <循环变量> in <遍历结构>:
<语句块1>
else:
<语句块2>
while <条件>:
<语句块1>
else:
<语句块2>
#当循环没有被break语句退出时，循环结束后正常执行else语句
(5) 小结
for in遍历循环；while无限循环；break和continue保留字；与else的搭配
4.4 模块3：random库
(1) 基本介绍
① random：使用随机数的Python标准库。
-伪随机数：采用梅森旋转算法
-import random
② 包含两类函数，常用共8个
-基本随机数函数：seed(), random()
-扩展随机数函数：randint(), getrandbits(), uniform(), randrange(), choice(), shuffle()
③ 功能
-能够利用随机数种子产生“确定”伪随机数
-能够产生随机整数
-能够对序列类型进行随机操作
(2) 基本随机数函数
随机数生成过程：随机数种子→梅森旋转算法→随机序列
-seed(a=None)：初始化给定的随机数种子
-random()：生成一个[0.0,1.0)之间的随机数
import random
random.seed(10)
random.random()
(3) 扩展随机数函数
-randint(a,b): 生成一个[a,b]之间的整数
-randrange(m,n[,k]): 生成一个[m,n)之间以k为步长的随机整数
-getrandbits(k): 生成一个k比特长的随机整数
-uniform(a,b): 生成一个[a,b]之间的随机整数
-choice(seq): 从序列seq中随机选择一个元素
-shuffle(seq): 将序列seq中元素随机排列，返回打乱后的序列
4.5 实例6：圆周率计算
(1) 问题分析
有两种方法可以计算圆周率：近似计算公式和蒙特卡洛法
(2) 相关代码
#公式法
pi = 0
N = 100
for k in range(N):
pi += 1/pow(16,k)*( \
4/(8*k+1) - 2/(8*k+4) - \
1/(8*k+5) - 1/(8*k+6) )
print("圆周率值是: {}".format(pi))
#蒙特卡罗法
from random import random
from time import perf_counter
DARTS = 1000*1000
hits = 0.0
start = perf_counter()
for i in range(1, DARTS+1):
x, y = random(), random()
dist = pow(x ** 2 + y ** 2, 0.5)
if dist <= 1.0:
hits = hits + 1
pi = 4 * (hits/DARTS)
print("圆周率值是: {}".format(pi))
print("运行时间是: {:.5f}s".format(perf_counter() - start))
(3) 举一反三
① 理解方法思维
-数学思维：找到公式，利用公式求解
-计算思维：抽象成一种过程，用计算机自动化求解
② 程序运行时间分析
-time库
-程序性能分析方法
③ 计算问题的扩展