python程序设计

• 本文是网课：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（）不是必须的

• 默认在窗口正中心

---

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】

"这里有个双引号(\")"
#结果为 这里有个双引号(")

• 转义符形成一些组合，表达一些不可打印的内容

  转义符	表示内容
  \b	回退
  \n	换行
  \r	回车

  5 字符串操作符

• 由0个或者多个字符组成的有序字符序列

操作符及使用	描述
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存在，则返回相应值，不在则返回
d.pop	键k存在，则取出相应值，不在则返回
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 一维数据的格式化和处理

由对等关系的有序或无序数据构成，采用线性方式组织

• 对应列表，数组和集合等概念

7.4 二维数据的格式化和处理