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】

"这里有个双引号(\")"
#结果为 这里有个双引号(")
  • 转义符形成一些组合,表达一些不可打印的内容

    转义符表示内容
    \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
%S00-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 一维数据的格式化和处理

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

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

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

  • 6
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值