- 本文是网课：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 一维数据的格式化和处理
由对等关系的有序或无序数据构成，采用线性方式组织
- 对应列表，数组和集合等概念
3517
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
