- 本文是网课:Python语言程序设计国家精品——(北京理工大学 嵩天 、 黄天羽 、 礼欣)的学习笔记。
1. 程序设计基本方法
1. 计算机和程序设计
1.1 计算机的概念
- 功能性:对数据的操作,表现为数据计算、输入 输出处理和结果存储等
- 可编程性:根据一系列指令自动的,可预测准确的完成操作者的意图
1.2计算机的发展
-
计算机的发展按照摩尔定律,变现为指数
-
摩尔定律
- 计算机历史上最重要的预测法则
- Intel公司创始人之一戈登-摩尔在1965年提出
- 单位面积集成电路上可以容纳晶体管的数量约每两年翻一番
- CPU\GPU、内存硬盘电子产品价格都遵循摩尔定律
1.3 程序设计
- 程序设计是计算机可编程性的体现
- 程序设计语言是一种用于交互(交流)的人造语言
- 程序设计语言,亦称为编程语言,程序设计的具体实现方式
- 编程语言相比于自然语言更加简单、严谨、精确
- 编程语言主要用于人类和计算机之间的交互
1.4 编译和解释
-
编译语言的执行方式
- 源代码和目标代码(计算机可以直接执行)
-
编译:将源代码一次性转化成目标代码的过程(一次性的翻译)
-
解释:将源代码逐条转换成目标代码同时逐条运行的过程(每次都需要 源代码参与)
执行解释过程的程序叫做解释器
-
根据执行方式不同,编程语言可以分为两类
-
静态语言:使用编译执行的编程语言(例如C)
编译器一次性生成目标代码,优化更充分,程序运行速度更快
-
脚本语言:使用解释执行的编程语言(例如Python)
维护更灵活,可跨多个操作系统平台
-
2. Python语言
2.1 Python语言简介
- 荷兰人Guido 1989年发明,1991年正式发行
- 面向对象的解释型计算机程序设计语言
- 设计哲学是“优雅”“简单”
- 自由软件
- 可以移植到多平台上
2.2 Python的两种编程方式
- 交互式:对于每个输入语句即时运行结果,适合语法练习
- 文件式:批量执行一组语句并运行结果,是编程的主要方式
【eg.1】根据半径计算圆的面积
#文件式
r=25
area=3.14*r*r
print(area)
print("{:.2f}".format(area)) #保留两位小数
【eg.2】绘制多个同切圆
#交互式
import turtle
turtle.pensize(2)
turtle.circle(10)
turtle.circle(40)
turtle.circle(80)
turtle.circle(160)
【eg.3】五角星绘制
#交互式
from turtle import*
color('red','red')
begin_fill()
for i in range(5):
fd(200)
rt(144)
end_fill()
#文件式
from turtle import*
color('red','red')
begin_fill()
for i in range(5):
fd(200)
rt(144)
end_fill()
done()
【eg.4】温度转化实例
#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']:
F= 1.8*eval(TempStr[0:-1])+32
print("转化后的温度是{:.2f}F".format(f))
else:
print("输入格式错误")
3. Python程序语法元素分析
3.1 程序的格式框架
【eg.4】温度转化实例
#TempConvert.py
TempStr = input ("请输入带有符号的温度值:")
if TempStr[-1] in ['F','f']: #用保留字in判断TempStr的最后一个字符为F或者f
C= (eval(TempStr[0:-1]) -32)/1.8 #TempStr[0:-1]:TempStr除去最后一个字符
print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C','c']:
F= 1.8*eval(TempStr[0:-1])+32
print("转化后的温度是{:.2f}F".format(f))
else:
print("输入格式错误")
- 代码高亮:编程辅助的字体色彩
- 缩进:
- 严格明确:缩进是语法的一部风,缩进不正确程序运行错误
- 所属关系:代表代码间包含和层次关系的唯一手段
- 长度一致
- 注释
- 单行注释:#
- 多行注释:以‘’‘开头和结尾
3.2 命名和保留字
-
变量:用来保存和表示数据的占位符号
- 变量采用标识符(名字)来表示,关联标识符的过程叫做命名
- 可以使用等号(=)向变量赋值或者修改值,=被称为赋值符号
-
命名:关联标识符的过程
- 命名规则:大小写字母、数字、下划线和汉字等字符及组合
- 注意事项:大小写敏感,首字母不能是数字,不能与保留字相同
-
保留字:被编程语言内部定义并保留使用的标识符
-
Python语言有33个保留字(也叫关键字)
例如:if, elif,else,in,True,Flase,None
-
保留字是编程语言的基本单词大小写敏感
例如:if是保留字,If是变量
-
3.3 数据类型
- 数据类型:字符串,整数,浮点数,列表
3.3.1 字符串
-
字符串:由0个或多个字符组成的有序字符序列
- 字符串由一对单引号或一对双引号表示(单双引号没有区别)
- 字符串是字符的有序序列,可以对其中的字符进行索引,第一个字符是第0号字符
-
正向递增序号(从0开始)和反向递减序号(从-1开始)
-
使用[]获取字符串中的一个或多个字符
-
索引:返回字符串中的单个字符 <字符串>[M]
eg:TempStr[-1]:返回TempStr倒数第一个字符
-
切片:返回字符串中一段字符子串 <字符串>[M:N]
eg:TempStr[0:-1]:表示从 TempStr第0个字符到 不到最后一个字符 左闭右开
-
3.3.2 列表类型
-
由0个或多个数据组成的有序序列
-
使用[]表示,采用逗号(,)分隔各元素
-
使用保留字in判断一个元素是否在列表中
eg:TempStr[-1] in [‘C’,‘c’]: 判断前者(TempStr最后一个字符)是否与列表中某个元素相同
3.4 语句与函数
3.4.1. 赋值语句:
-
由赋值符号构成的一行代码
-
赋值语句用来给变量赋予新的数据值
eg: C= (eval(TempStr[0:-1]) -32)/1.8 #右侧运算结果赋给变量C
-
赋值语句右侧的数据类型同时作用于变量
3.4.2. 分支语句:
-
由判断条件决定运行程序方向的语句
-
使用保留字if elif else 构成条件判断的分支结构
eg: if TempStr[-1] in [‘F’,‘f’]: #如果条件为True则执行冒号后语句
if x > y: a = x else: a = y #三元
3.4.3. 函数:
-
根据输入参数产生不同输出的功能过程
-
类似于数学中的函数
eg: print(“输入格式错误”) #打印输出"输入格式错误"
-
函数采用<函数名>(<参数>)方式使用
eg:eval(TempStr[0:-1]) #TempStr[0:-1] 是参数
3.5 Python程序的输入和输出
3.5.1 输入函数 input()
-
从控制台获取用户输入的函数
-
input()函数的使用格式
<变量> =input (<提示信息字符串>)
-
用户输入的信息以字符串类型保存在<变量>中
3.5.2 输出函数 print()
-
以字符形式向控制台输出结果的函数
-
print()函数的基本使用格式:
print(<拟输出字符串或字符串变量>)
-
print()函数的格式化:
print("转化后的温度是{:.2f}F".format(f))
3.5.3 评估函数 eval()
-
去掉参数最外侧引号并执行余下语句的函数
-
eval()函数的基本使用格式:
eval(<字符串或字符串变量>)
2. python程序设计实例
2.1 深入理解Python语言
- 计算机技术的演进
- 计算机系统结构时代
- 网络和视窗时代
- 复杂信息系统时代
- 人工智能时代
- 编程语言的多样初心
2.2 实例2:Python蟒蛇绘制
【eg.1】用程序绘制蟒蛇
#PythonDraw.py
import turtle #引入turtle库
turtle.setup(650,350,200,200) #设置窗体大小和位置
turtle.penup() #抬起画笔
turtle.fd(-250) #让海龟倒退行进250
turtle.pendown() #落下画笔
turtle.pensize(25) #设置画笔大小
turtle.pencolor("red")
turtle.seth(-40) #设置画笔方向
for i in range(4):
turtle.circle(40,80) #左40像素为半径,绘制80度
turtle.circle(-40,80) #右40像素为半径,绘制80度
turtle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40*2/3)
turtle.done() #程序不会自动退出
- Python蟒蛇颜色
- Python蟒蛇的长度
- Python蟒蛇的方向
2.3 模块一:turtle库的使用
1.turtle库基本介绍
turtle库基本介绍
-
turtle库是turtle绘图体系的Python实现
1969年诞生
-
是标准库之一
-
Python计算生态=标准库+第三方库
- 标准库:随解释器直接安装到操作系统中的功能模块
- 第三方库:需要安装下能使用的功能模块
- 库Library,包Package,模块Module,统称模块
-
turtle是一种真实的存在
turtle绘图窗口布局
- setup()设置窗体大小及位置
turtle.setup(width,height,startx,staty)
-
四个参数中后两个可选
-
setup()不是必须的
-
<startx,staty>默认在窗口正中心
turtle空间坐标体系
- 绝对坐标
turtle.goto(x,y)
【eg.2】
#狐狸脸绘制
import turtle
turtle.goto(100,100)
turtle.goto(150,-50)
turtle.goto(100,-100)
turtle.goto(0,-150)
turtle.goto(-100,-100)
turtle.goto(-150,-50)
turtle.goto(-100,100)
turtle.goto(0,0)
- 相对坐标
turtle.circle(r,angle)#曲线运行
turtle.bk(d) #向前
turtle.fd(d) #向后
turtle角度坐标体系
- 绝对角度
turtle.seth(angle)
turtle.left(angle)
turtle.right(angle)
- seth()改变海龟行进方向
- seth()只改变方向但不行进
- angle为绝对度数
RGB色彩体系
- 红绿蓝三原色
2.4 turtle程序语法元素分析
2.4.1 库引用和import
- 扩程序功能的方式
- 使用import保留字完成,采用a.b ()编码风格
import <库名>
<库名>.<函数名>(<函数参数>) #不会出现函数重名的问题
- 使用from和import保留字共同完成
from <库名> import <函数名>
from <库名> import*
<函数名>(<函数参数>) #会出现重名问题
【eg.2】改编用程序绘制蟒蛇
import turtle
turtle.setup(650,350,200,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("red")
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()
from turtle import*
setup(650,350,200,200)
penup()
fd(-250)
pendown()
pensize(25)
pencolor("red")
seth(-40)
for i in range(4):
circle(40,80)
circle(-40,80)
circle(40,80/2)
fd(40)
circle(16,180)
fd(40*2/3)
done()
- 但可能会出现函数名重复的情况
- 使用import 和as保留字共同完成
import <库名> as <库别名>
<库别名>.<函数名>(<函数参数>)
-
- 给调用的外部关联库关联一个更短,更适合自己的名字
- 冗余量最小且不会出现函数名重复
import turtle as t
t.setup(650,350,200,200)
t.penup()
t.fd(-250)
t.pendown()
t.pensize(25)
t.pencolor("red")
t.seth(-40)
for i in range(4):
t.circle(40,80)
t.circle(-40,80)
t.circle(40,80/2)
t.fd(40)
t.circle(16,180)
t.fd(40*2/3)
t.done()
2.4.2 turtle 画笔控制函数
- 画笔操作一直有效,一般成对出现
#抬起画笔
turtle.penup() #别名 turtle.pu()
#落下画笔
turtle.pendown() #别名 turtle.pd()
- 画笔设置后一直有效,直至下次重新设置
#画笔宽度
turtle.pensize(widle) #别名 turtle.width(width)
#画笔颜色
turtle.pencolor(color) #color为颜色字符串或rgb值
pencolor(color)的color参数可以有三种形式
-
颜色字符串 :turtle.pencolor(“red”),red为字符串形式且要小写
RGB的小数值 :turtle.pencolor(0.63,0.13,0.94)
RGB的元组值 : turtle.pencolor((0.63,0.13,0.94))
2.4.3 运动控制函数
控制海龟行进:走直线和走曲线
turtle.forward(d) #别名:turtle.fd(d)
- 向前行进,海龟走直线
- d:行进距离,可以为负数(倒退行进)
turtle.circle(r,extent=None)
- 根据半径r绘制extent角度的弧形
- r:默认圆心在海龟左侧r距离的位置
- extent:绘制角度,默认是360度整圆
2.4.4 turtle方向控制函数
控制海龟面对方向:绝对角度和海龟角度
只改变运动方向,不动海龟
turtle.setheading(angle) #别名:turtle.seth(angle)
- angle:改变行进方向,海龟走角度
turtle.left(angle) #海龟向左转
turtle.right(angle) #海龟向右转
- angle:在海龟当前行进方向上旋转的角度
2.4.5 循环语句与range()函数
5.1 循环语句
- 按照一定次序循环执行的一组语句
for <变量> in range (<参数>) #参数表示循环的次数
<被循环执行的语句>
-
变量 表示每次循环的计数,0到 循环的次数-1
-
print输出加逗号输出有个空格喔
5.2 range()函数
- 产生循环计数序列
range(N)
- 产生 0 到 N-1的整数序列,共N个
range(M,N)
- 产生 M到 N-1的整数序列,共N-M个
#python learning
#range是Python内置函数,用作范围、区间的定义,有以下三种用法
#用法1:只有一个参数,表示从0到这个参数内的所有整数,不包括参数
ran=range(10)
#定义一个list,用来将range的范围的所有数进行陈放为list形式
arr_str=list(ran)
print(ran)
print(arr_str)
#用法2:两个参数,第一个表示左边界,第二个表示右边界,range表示从左边界到右边界的所有整数,左闭右开。
ran=range(1,15)
arr_str=list(ran)
print(ran)
print(arr_str)
#用法3:三个参数,第一个表示左边界,第二个表示右边界,第三个表示步长step,即两个整数之间相差的数,左闭右开。
ran=range(1,15,2)
arr_str=list(ran)
print(ran)
print(arr_str)
3. 基本数据类型
3.1 数字类型及操作
1. 整数类型
- 与数学中概念完全一致
- 可正可负,没有取值范围限制
pow(x,y) #pow(x,y)函数,计算x的y次方
- 4种进制表示形式
- 十进制:1010,99,-217
- 二进制,以0b或者0B开头:0b010,-0B101(C语言没有喔)
- 八进制,以0o或者0O开头:0o123,-0O456
- 十六进制,以0x或者0X开头
2. 浮点类型
-
与数学中实数的概念完全一致
-
带有小数点及小数的数字
-
浮点数取值范围和小数精度都存在限制,但常规计算可以忽略
-
取值范围数量级约为-10的308次方到10的308次方,精度数量级10的-16次方
-
浮点数间运算存在不确定尾数,不是bug
解决不确定尾数,引进
round(x,d) # 对x四舍五入,d是小数截取位数
浮点数间运算及比较用round()函数辅助
不确定尾数一般发生在10的-16次方左右,round() 函数十分有效
- 浮点数可以采用科学计数法表示
- 使用字母e或者E作为幂的符号,以10 为基数,格式如下
<a>e<b> #表示a*10的b次方
3. 复数类型
- z.real 获得实部
- z.imag 获得虚部
4. 数值运算操符
-
操作符是完成运算的一种符号体系
-
/ (除):产生的浮点数结果
//(整除):产生整数
-
数值类型的关系
-
类型间可以进行混合运算,生成结果为“最宽”类型
-
三种类型之间存在一种逐渐扩展或变宽的关系
-
整数->浮点数->复数(最宽喔)
比如:整数+浮点数=浮点数
-
-
5. 数值运算函数
一些以函数形式提供的数值运算功能
函数及使用 | 描述 |
---|---|
abs(x) | 绝对值,x的绝对值 |
divmod(x,y) | 商余,同时输出商和余数(x//y,x%y) |
pow(x,y[,z]) | 幂余,(x**y)%z,[…]表示参数z可以省略 |
round(x[,d]) | 四舍五入,d是保留最小数位数,默认值是0,取整 |
max(x1,x2,x3…xn) | 最大值,返回x1,x2,x3…xn中的最大值,n不限 |
min(x1,x2,x3…xn) | 最小值,返回x1,x2,x3…xn中的最小值,n不限 |
一些以函数形式提供的数值运算功能
函数及使用 | 描述 |
---|---|
int(x) | 将x(小数或者字符串)变成整数,舍弃小数部分 |
float(x) | 将x(小数或者字符串)变成浮点数,增加小数部分 |
complex(x) | 将x变成复数,增加虚数部分 |
3.2 实例3:天天向上的力量
- 一年365天,每天进步0.1%,累计进步多少呢
- 一年365天,每天退步0.1%,累计剩下多少呢
#DayupQ1.py
dayup =pow(1.001,365)
daydown =pow(0.999,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))
- 一年365天,每天进步0.5%或者1%,累计进步多少呢
- 一年365天,每天退步0.5%或者1%,累计退步多少呢
#DayupQ2.py
dayfactor = 0.005
dayup = pow(1+dayfactor,365)
daydown = pow(1-dayfactor,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))
dayfactor = 0.01
dayup = pow(1+dayfactor,365)
daydown = pow(1-dayfactor,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))
- 一年365天,一周五个工作日,每天进步1%
- 一年365天,一周两个休息日,每天退步1%
- 这种工作日的力量,如何呢
#DayupQ3.py
dayup =1.0
dayfactor = 0.01
for i in range(365): #0-364
if i%7 in [6,0]: #用in 判断周六或者周日
dayup = dayup*(1-dayfactor)
else:
dayup = dayup*(1+dayfactor)
print("工作日的力量:{:.2f}".format(dayup))
- 工作模式要努力到什么水平,才能和每天努力1%一样
- A君:一年365天,每天进步1%,不停歇
- B君:一年365天,每周工作5天休息2天,休息日下降1%,要多努力呢
#DayupQ4
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)<37.78: # A君:一年365天,每天进步1%,不停歇的累计结果
dayfactor+=0.001
print("工作日的努力参数:{:.3f}".format(dayfactor))
3.3 字符串类型及其操作
1 字符串
-
由0个或者多个字符组成的有序字符序列
- 字符串由一对单引号或者一对双引号表示(单双引号无区别)
- 字符串是字符的有序序列,可以对其中的字符进行索引(从0 开始编号)
-
字符串有2类共4种表示方法
- 由一对单引号或者双引号表示,仅表示单行字符串
- 由一对三单引号(作用可以作为多行注释)或者三双引号表示,可表示多行字符串
-
如果希望在字符串中包含双引号和单引号
- ‘这里有个双引号(")’
- “这里有个单引号(‘)”
- ’‘’这里既有双引号(“)也有单引号(’) ‘’‘
2 字符串的编号
-
正向递增序号(第一位是0)和反向递减序号(倒数第一位是-1)
-
使用[]获取字符串中一个或者多个字符
- 索引:返回字符串中的单个字符
<字符串>[M]
- 切片:返回字符串中的一段字符子串
<字符串>[M:N] #从M到N-1
3 字符串切片高级用法
-
使用[M:N:K]根据步长对字符串切片
-
<字符串>[M:N] #M缺失表示至开头,N缺失表示至结尾 "0123456789"[:3]结果是"012"
-
<字符串>[M:N:K] #根据步长K对字符串切片 "0123456789"[1:8:2]结果是"1357" #将字符串逆序输出 "0123456789"[::-1]J结果是"9876543210"
4 字符串的特殊字符
- 转义符\
- 转义符表示特定字符的本意
【eg.1】
"这里有个双引号(\")"
#结果为 这里有个双引号(")
操作符及使用 | 描述 |
---|---|
x+y | 连接两个字符串x和y |
x in s | 如果x是s的子串,返回True,否则返回Flase |
【eg.2】获取星期字符串
- 输入:1-7的整数,表示星期几
- 输出:输入整数对应的星期字符串
- 例如:输入3,输出星期三
#WeekNamePrintV1.py
weekStr = "星期一星期二星期三星期四星期五星期六星期日"
weekId = eval(input("请输入星期数字(1-7):"))
pos = (weekId-1)*3 #复制三次字符串“weekId-1”
print(weekStr[pos:pos+3]) #取weekStr字符串以pos开头pos+3结尾
#WeekNamePrintV2.py
weekStr = "一二三四五六日"
weekId = eval(input("请输入星期数字(1-7):"))
print("星期" +weekStr[weekId-1])
6 字符串处理函数
- 一些以函数形式提供的字符串处理功能
函数及使用 | 描述 |
---|---|
len(x) | 长度,返回字符串x的长度 |
str(x) | 任意类型x所对应的字符串形式(与eval (x)作用相反) |
hex(x)或oct(x) | 整数x的十六进制或八进制小写形式字符串 |
chr(u) | u为Unicode编码,返回其对应的字符 |
ord(x) | x为字符,返回其对应的Unicode编码 |
- Unicode编码
- Python字符串的编码方式
- 统一字符编码,即覆盖率几乎所有字符的编码方式
【eg.3】星座转换
for i in range(12):
print(chr(9800 + i),end="")
7 字符串处理方法
-
方法在编程中是一个专有名词
方法特指<a>.<b>()风格中的函数<b>() 方法本身也是函数,但与<a>有关,<a>.<b>()风格
-
一些以方法形式提供的字符串处理功能
方法及使用 描述 str.lower()或str.upper() 返回字符串的副本,全部字符小写或者大写 str.split(sep=None) 返回一个列表,由str根据sep被分隔的部分组成 str.count(sub) 返回字串sub在str中出现的次数 str.replace(old,new) 返回字符串str的副本,所有old子串被替换成new str.center(width,[,fillchar]) 字符串str根据宽度width居中,fillchar可选 str.strip(chars) 从str中去除其左侧和右侧chars中列出的字符 str.join(iter) 在iter变量除最后元素外每个元素后增加一个str
8 字符串类型的格式化
-
格式化是对字符串进行格式化表达的方法
-
字符串格式化使用.format()方法,用法如下
<模板字符串>.format(<逗号分隔的参数>)
-
槽{}利用格式化的控制标记参数
槽内部对格式化的配置方式
{<参数序数>:<格式控制标记>}
3.4 模块二:time库的使用
1 time库基本介绍
- time库是python中处理时间的标准库
- 计算机时间的表示
- 提供获取系统时间并格式化输出功能
- 提供系统级精确计时功能,用于程序性能分析
import time
time.<b>()
- time库表示三类函数
time() ctime() gmtime() #时间获取
strftime() strptime() #时间格式化
sleep() perf-counter() #程序计时
2 时间获取
函数 | 描述 |
---|---|
time() | 获取当前时间戳,即计算机内部时间值,输出浮点数 |
ctime() | 获取当前时间并以易读方式表示,返回字符串(人可读) |
gmtime() | 获取当前时间,表示为计算机可以处理的时间格式 |
3 时间格式化
- 将时间以合理的方式展示出来
- 格式化:类似字符串格式化,需要有展示模板
- 展示模板由特定的格式化控制符组成
- strftime()方法
函数 | 描述 |
---|---|
strftime(tql,ts) | tql是格式化模板字符串,用来定义输出效果,ts是计算机内部时间类型变量 |
strptime(str,tql) | str是字符串形式的时间值,tql是格式化模板字符串,用来定义输入效果(与strftime互补) |
格式化字符串 | 日期/时间说明 | 值范围和实例 |
---|---|---|
%Y | 年份 | 0000~9999,例如:1900 |
%m | 月份 | 01~12,例如:10 |
%B | 月份名称 | January~December,例如:April |
%b | 月份名称缩写 | Jan~Dec,例如:Apr |
%d | 日期 | 01~31,例如:25 |
%A | 星期 | Monday~Sunday,例如:Wednesday |
%a | 星期缩写 | Mon~Sun,例如:Wed |
%H | 小时(24h制) | 00~23,例如:12 |
%h | 小时(12h制) | 01~12,例如:7 |
%p | 上/下午 | AM,PM,例如:PM |
%M | 分钟 | 00-59,例如:26 |
%S | 秒 | 00-59,例如:26 |
4 程序计时应用
- 程序计时应用广泛
- 程序计时指测量起止动作所经历时间的过程
- 测量时间:perf-counter()
- 产生时间:sleep()
函数 | 描述 |
---|---|
perf_counter() | 返回一个CPU级别的精确时间计数值,单位为秒,由于这个计数值起点不确定,连续调用差值才有意义 |
sleep() | s拟休眠的时间,单位是秒,可以是浮点数 |
def wait():
time.sleep(3.3) #程序将等待3.3秒后再退出
3.5 实例4:文本进度条
-
采用字符串方式打印的可以动态变化的文本进度条
-
采用sleep()模拟一个持续的进度
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("------执行结束------")
-
文本进度条的单行刷新
刷新的本质:用后打印的字符覆盖之前的字符
不能换行
要能回退:\r
import time
for i in range(101):
print("\r{:3}%".format(i),end="") #\r在打印输出之前,可以定位到行首,end=""不会换行
time.sleep(0.1)
- 文本进度条的完整效果
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}%[{}->{}]".format(c,a,b,dur),end="")
time.sleep(0.1)
print("\n"+"执行结束".center(scale//2,"-"))
4. 程序的控制结构
4.4 程序的循环结构
1. 遍历循环(for)
遍历某个结构形成的循环运行方式
for <循环变量> in <遍历结构>:
<语句块>
- 由保留字for 和 in组成,完整遍历所有元素后结束
- 每次循环,所获得元素放入循环变量,并执行一次语句块
#计数循环
for i in range(N): #遍历由range()函数产生的数字序列,产生循环
<语句块>
#计数循环
for i in range(M,N,K): #遍历由range()函数产生的数字序列,产生循环
<语句块>
#字符串遍历循环
for c in s: #s是字符串,遍历字符串的每个字符,产生循环
<语句块>
#列表遍历循环
for item in ls: #ls是一个列表,遍历每个元素,产生循环
<语句块>
#文件遍历循环
for line in fi: #fi是一个文件标识符,遍历其每行,产生循环
<语句块>
2. 无限循环
由条件控制的循环运行方式
while <条件>:
<语句块>
3. 循环保留字
- break:跳出并结束当前整个循环,执行循环后的语句
- continue:结束当次循环,继续执行后续循环次数循环
4.5 模块3:random库的使用
- random库是使用随机数的Python标准库
函数 | 描述 |
---|---|
seed(a=None) | 初始化给定的随机数种子,默认为当前系统时间 random.seed(10) |
random() | 生成一个[0.1,1.0]之间的随机小数 random.random() |
- 扩展随机数函数
函数 | 描述 |
---|---|
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.6 实例6:Π值的计算
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("pi:{}".format(pi))
print("运行时间是{:.5f}".format(perf_counter()-start))
4.7 程序的异常处理
try:
<语句块1>
except <异常类型>:
<语句块2>
异常处理的高级应用
try:
<语句块1>
except <异常类型>:
<语句块2>
else: #对应语句块在不发生异常时执行
<语句块3>
finally: #一定执行
<语句块4>
5. 函数和代码复用
5.1 函数的基本使用
- 函数的定义:一段具有特定功能的,可以重用的语句组
def<函数名>(<参数>(0个或多个)):
<函数体>
return<返回值>
-
函数定义时,所指定的参数是一种占位符
-
函数定义后,如果不经过调用,不会被执行
-
函数定义时,参数是输入,函数体是处理、结果是输出(IPO)
-
函数的使用及调用过程
定义代码不被执行,调用被执行
5.2 函数的参数传递
-
参数个数:
函数可以有参数,也可以没有,但必须保留括号
-
可选参数传递
函数定义时可以为某些参数指定默认值,构成可选参数
def<函数名>(<非可选参数>,<可选参数>):
<函数体>
return<返回值>
-
可变参数传递
函数定义时可以设计可变数量参数,既不确定参数总数量
def <函数体>(<参数>,*b):
<函数体>
return<返回值>
-
函数传递的两种方式
函数调用时,参数可以按照位置或名称方式传递
1. lambda函数
- lambda函数返回函数名作为结果
- 是一种匿名函数,即没有名字的函数
<函数名> = lambda <参数>:<表达式>
5.3 模块3:datetime库的使用
5.4 实例7:七段数码管的绘制
5.5 代码复用和模块化设计
1. 代码复用
把代码当成资源进行抽象
- 代码资源化:程序代码是一种用来表达计算的“资源”
- 代码抽象化:使用函数等方法对代码赋予更高级别的定义
- 代码复用:同一份代码在需要时可以被重复使用
2. 模块化分析
分而治之
5.6 函数的递归
-
递归的定义
两个关键特征
- 链条:计算过程存在递归链条
- 基例:存在一个或者多个不需要再次递归的实例
-
函数递归的实现过程
3. 字符串反转
将字符串s反转后输出
s[::-1]
def rvs(s):
if s=="":
return s
else:
return rvs(s[1:])+s[0]
5.7 实例8:科赫曲线的绘制
使用递归和海龟作图体系
5.8 Python内置函数
6. 组合数据类型
6.1.1序列类型
序列类型定义
-
序列:具有先后关系的一组元素
-
序列是一维向量,元素类型可以不同
-
元素间由序号引导,通过下标来访问元素的特定元素
-
序列是一个基类类型
字符串类型、元组类型、列表类型
操作符及应用 | 描述 |
---|---|
x in S | 如果x是序列s的元素,返回True,否则返回Flase |
x not in S | 如果x是序列s的元素,返回Flase,否则返回True |
s +t | 连接两个序列s和t |
s*n | 将序列s复制n次 |
s[i] | 索引,返回s中的第i个元素,i是序列的序号 |
s[i:j]或s[i:j:k] | 切片,返回序列s中第i到j以k为步长的元素子序列 |
- 序列类型通用函数和方法
函数和方法 | 描述 |
---|---|
len(s) | 返回序列s的长度 |
min(s) | 返回序列s的最小元素,s中元素需要可比较 |
max(s) | 返回序列s的最大元素 |
s.index(x)或s.index(x,i,j) | 返回序列s从i到j位置中第一次出现元素x的位置 |
s.count(x) | 返回序列中x出现的次数 |
6.1.2 集合操作类型
集合是多个元素的无序组合
-
集合类型与数学中的集合概念一致
-
集合元素之间无序,每个元素唯一,不存在相同元素
-
集合元素不可更改,不能是可变数据类型
-
集合用**大括号{}**表示,元素间用逗号来分隔
-
建立集合类型用{}(但不能生成空集合)或者set()
不可变集合需要通过frozenset()创建
-
自动去重
-
集合元素之间无序
-
集合间操作符
操作符及应用 | 描述 |
---|---|
S|T | 返回一个新集合,包括在集合S和集合T中的所有元素 |
S-T | 返回一个新集合,包括在集合S但不在集合T中的元素 |
S&T | 返回一个新集合,包括同时在集合S和集合T中的元素 |
S^T | 返回一个新集合,包括集合S和集合T中的非相同元素 |
- 集合的处理方法
操作方法 | 描述 |
---|---|
s.add(x) | 如果x不在集合S中,将x增加到S |
s.discard(x) | 移除S中元素x,如果x不在集合S中,不报错 |
s.remove(x) | 移除S中元素x,如果x不在集合S中,产生KeyError异常 |
s.clear() | 移除S中所有元素 |
S.pop() | 随机返回S中的一个元素删除这个元素,更新S,若S为空,产生KeyError异常 |
S.copy() | 返回集合S的一个副本 |
len(S) | 返回集合S的元素个数 |
x in S | 判断S中元素x,x在集合S中,返回True,否则返回Flase |
x not in S | 判断S中元素x,x不在集合S中,返回True,否则返回Flase |
set(x) | 将其他类型变量x转变成集合类型 |
- 集合类型应用场景
- 数据去重
6.1.3 映射类型
理解映射
- 映射是一种键(索引)和值(数据)的对应
字典类型是“映射”的体现
- 键值对:键是数据索引 的扩展
- 字典是键值对的集合,键值对之间无序
- 采用{}和dict()创建,键值对用冒号表示
6.2 序列操作类型
1. 元组类型(tp)
元组是序列类型的一种扩展
-
元组是一种序列类型,一旦创建就不能被修改
-
使用**小括号()或者tuple()**创建,元素间用逗号分隔
-
可以使用或者不使用小括号
-
元组类型操作
元组继承了序列的全部通用操作
-
元组创建后不能修改,因此没有特殊操作
操作符及应用 | 描述 |
---|---|
x in S | 如果x是序列s的元素,返回True,否则返回Flase |
x not in S | 如果x是序列s的元素,返回Flase,否则返回True |
s +t | 连接两个序列s和t |
s*n | 将序列s复制n次 |
s[i] | 索引,返回s中的第i个元素,i是序列的序号 |
s[i:j]或s[i:j:k] | 切片,返回序列s中第i到j以k为步长的元素子序列 |
- 序列类型通用函数和方法
函数和方法 | 描述 |
---|---|
len(s) | 返回序列s的长度 |
min(s) | 返回序列s的最小元素,s中元素需要可比较 |
max(s) | 返回序列s的最大元素 |
s.index(x)或s.index(x,i,j) | 返回序列s从i到j位置中第一次出现元素x的位置 |
s.count(x) | 返回序列中x出现的次数 |
2. 列表操作(ls)
列表是序列类型的一种扩展
-
列表是一种序列类型,创建后可以随意被修改
-
使用**方括号[]或者list()**创建,元素间用逗号分隔
-
列表中各元素类型可以不同,无长度限制
-
列表类型操作函数和方法
函数或者方法 | 描述 |
---|---|
ls[i]=x | 替换列表ls第i个元素为x |
ls[i:j:k] = lt | 用列表lt替换切片后所对应元素子列表 |
del ls[j] | 删除列表ls中第i元素 |
del ls[i:j:k] | 删除列表ls中第i到第j以k为步长的元素 |
ls+=lt | 更新列表ls,将列表lt元素增加到列表ls中 |
ls*=n | 更新列表ls,其元素重复n次 |
函数或方法 | 描述 |
---|---|
ls.append(x) | 在列表ls最后增加一个元素x |
ls.clear() | 删除列表ls中所有元素 |
ls.copy() | 生成一个新列表,赋值ls中所有元素 |
ls.insert(i,x) | 在列表ls的第i位置增加元素x |
ls.pop(i) | 将列表ls中第i位置元素取出并删除该元素 |
ls.remove(x) | 将列表ls中出现的第一个元素x删除 |
ls.reverse() | 将列表ls中的元素反转 |
操作符及应用 | 描述 |
---|---|
x in S | 如果x是序列s的元素,返回True,否则返回Flase |
x not in S | 如果x是序列s的元素,返回Flase,否则返回True |
s +t | 连接两个序列s和t |
s*n | 将序列s复制n次 |
s[i] | 索引,返回s中的第i个元素,i是序列的序号 |
s[i:j]或s[i:j:k] | 切片,返回序列s中第i到j以k为步长的元素子序列 |
- 序列类型通用函数和方法
函数和方法 | 描述 |
---|---|
len(s) | 返回序列s的长度 |
min(s) | 返回序列s的最小元素,s中元素需要可比较 |
max(s) | 返回序列s的最大元素 |
s.index(x)或s.index(x,i,j) | 返回序列s从i到j位置中第一次出现元素x的位置 |
s.count(x) | 返回序列中x出现的次数 |
-
序列类型的应用场景
元素遍历
for item in ls:
<语句块>
for item in tp:
<语句块>
6.3 实例9:基本统计值计算
def getNum():
nums =[]
iNumStr = input("请输入数字(回车退出):")
while iNumStr!="":
nums.append(eval(iNumStr)) #在列表ls最后增加一个元素x
iNumStr = input("请输入数字(回车退出):")
return nums
def mean(numbers): #计算平均值
s =0.0
for num in numbers:
s =s+num
return s/len(numbers)
def dev(numbers,mean): #计算方差
sdev = 0.0
for num in numbers:
sdev = sdev +(num-mean)**2
return pow(sdev/(len(numbers)-1),0.5)
def median(numbers): #计算中位数
sorted(numbers) #对列表进行排序
size = len(numbers)
if size%2 ==0:
med = (number[size//2-1]+numbers[size//2]/2)
else:
med = numbers[size//2]
return med
n= getNum()
m =mean(n)
print("平均值:{},方差:{},中位数:{}.".format(m,dev(n,m),median(n)))
6.4 字典类型及操作
6.4.1 字典类型定义
理解映射
- 映射是一种键(索引)和值(数据)的对应
字典类型是“映射”的体现
- 键值对:键是数据索引 的扩展
- 字典是键值对的集合,键值对之间无序
- 采用{}和dict()创建,键值对用冒号表示
{<键1>:<值1>,<键2>:<值2>,<键3>:<值3>,,,<键n>:<值n>}
- 在字典变量中,通过键获得值
<字典变量>={<键1>:<值1>,<键2>:<值2>,<键3>:<值3>,,,<键n>:<值n>}
<值> = <字典变量>[<键>]
<字典变量>[<键>] = <值>
- []用来向字典变量中索引或增加新元素
6.4.2 字典处理函数及方法
函数 | 描述 |
---|---|
del d[k] | 删除字典d中对键k对应的数据值 |
k in d | 判断键k是否在字典d中,如果在返回True,否则Flase |
d.keys() | 返回字典d中所有键信息 |
d.values() | 返回字典d中所有值信息 |
d.items() | 返回字典d中所有的键值对信息 |
函数或者方法 | 描述 |
---|---|
d.get | 键k存在,则返回相应值,不在则返回<default 值 |
d.pop | 键k存在,则取出相应值,不在则返回<default 值 |
d.popitem() | 随机从字典d中取出一个键值对,以元组形式返回 |
d.clear() | 删除所有的键值对 |
len(d) | 返回字典d中元素的个数 |
d.update(e) | 将e中键-值对添加到字典d中,e可能是字典,也可能是键-值对序列 |
6.5 模块5:jieba库的使用
7. 文件和数据格式化
-
字符串格式化:“{}{}{}”.format()
将字符按照一定规则和式样进行规范
-
数据格式化
将一组数据按照一定规格和式样进行规范:表示,存储和运算等
7.1 文件的使用
1.文件的类型
文件是数据的抽象和集合
-
文件是存储在辅助存储器上的数据序列
-
文件时数据存储的一种形式
-
文件展示状态:文本文件和二进制文件
-
文件的理解
- 文本文件和二进制文件只是文件的展示方式
- 本质上,所有文件都是以二进制形式存储的
- 形式上,所有文件采用两种方式展示
-
文本文件
文件是数据的抽象和集合
- 由单一特定编码组成的文件,如UTF-8编码
- 由于存在编码,也被看成是存储的长字符串
- 适用于例如:.txt文件,.py文件
-
二进制文件
文件是数据的抽象和集合
-
直接由比特0和比特1组成,没有统一字符编码
-
一般存在二进制0和1 的组织结构,即文件格式
-
适用于:.png文件,.avi文件等
2. 文件的打开关闭
文件处理的步骤:打开-操作-关闭
# 读文件
a.read(size) #读出全部内容,如果给出参数,读入前size长度
a.readline(size) #读入一行内容,如果给出参数,读入前size长度
a.readlines(hint) #读入文件所有行,以每行为元素形成列表,如果给出参数,读入前hint行
# 写文件
a.write(s)
a.writelines(lines)
a.seek(offset)
- 文件的打开
<变量名> = open(<文件名>,<打开模式>)
- 打开模式
文件的打开模式 | 描述 |
---|---|
‘r’ | 只读模式,默认值,如果文件不存在,返回FileFoundError |
‘w’ | 覆盖写模式,文件不存在则创建,存在则完全覆盖 |
‘x’ | 创建写模式,文件不存在则创建,存在则返回FileExistsError |
‘a’ | 追加写模式,文件不存在则创建,存在则在问价最后追加内容 |
‘b’ | 二进制文件模式 |
‘t’ | 文本文件模式,默认值 |
‘+’ | 与r/w/a/x一同使用,在原功能基础上增加同时读写功能 |
3. 文件内容的读取
# 读文件
a.read(size) #读出全部内容,如果给出参数,读入前size长度
a.readline(size) #读入一行内容,如果给出参数,读入前size长度
a.readlines(hint) #读入文件所有行,以每行为元素形成列表,如果给出参数,读入前hint行
- 遍历全文本
fname = input ("请输入要打开的问价名称:")
fo = open(fname,"r")
txt = fo.read #一次读入,全部处理
fo.close()
fname = input ("请输入要打开的问价名称:")
fo = open(fname,"r")
txt = fo.read(2) #读入两个字节
while txt !="":
txt = fo.read(2)
fo.close()
- 文件的逐行操作
fname = input("")
fo = open(fname,"r")
for line in fo.readlines():
print(line)
fo.close()
fname = input("")
fo = open(fname,"r")
for line in fo: #分行输入,逐行处理
print(line)
fo.close()
4. 数据的文件写入
a.write(s) #向文件中写入一个字符出或者字节流
a.writelines(lines) #将一个元素全为字符串的列表写入文件
a.seek(offset) #改变当前文件操作指针的位置,offset:0-文件开头;1-当前位置;2-文件结尾
7.2 实例11:自动轨迹的绘制
7.3 一维数据的格式化和处理
由对等关系的有序或无序数据构成,采用线性方式组织
- 对应列表,数组和集合等概念