Python语言程序设计_第三周

第三周

• 3.1 数字类型及操作
• 3.2 实例3
• 3.3 字符串类型及操作
• 3.4 time库的使用
• 3.5 实例4

方法论：

• 理解Python语言数字及字符串类型

实践能力：

• 操作字符

---

3.1 数字类型及操作

整数类型

• 可正可负，没有取值范围限制
• pow(x,y)函数：计算 x^y ,想算多大都可以

4种进制表示形式

• 十进制：
• 二进制：以0b或者0B开头（0b010，-0B101）
• 八进制：以0o或者0O开头（0o123，-0O456）
• 十六进制：以0x或者0X开头（0x9a，-0X89）

浮点类型

• 与数学中实数的概念一致，带有小数点及小数的数字
• 浮点数取值范围和小数精度存在限制，取值范围在-10³⁰⁸ 到 10³⁰⁸，精度数量级 10^-16
  谈谈关于Python里面小数点精度控制的问题
• 浮点数间运算存在不确定尾数，不是bug

>>> 0.1 + 0.3
0.4
>>> 0.1 + 0.2
0.30000000000000004

30000000000000004 不确定尾数

Python中采用53位二进制表示小数部分，约10^-16

0.1 在对应的二进制中，是一个无限小数。

计算机采用53位二进制表示小数部分，在转换成十进制时，只输出前16位。

所以，0.1 + 0.2在二进制计算时，会无限接近0.3，但可能存在尾数

>>> 0.1 + 0.2 == 0.3
False

#使用round()函数
>>>round(0.1+0.2,1) == 0.3
True

round(x,d)：对x四舍五入，d是小数截取位数

• 浮点数间运算以及比较用round()函数辅助
• 不确定尾数一般发生在10^-16左右，round()十分有效

浮点数可以用科学计数法表示

• 使用字母e或E作为幂对符号，以10为基数， 表示a*10^b
• 如：4.3e^-3值为0.0043

Python复数类型

• 与数学中复数概念一致，a+bj
• z.real获得实部
• z.imag获得虚部

空间变换及复变函数相关

数值运算操作符

操作符以及使用	描述
x + y	加
x - y	减
x * y	乘
x / y	除，取浮点数商
x // y	整数除，取整数商
+ x	x本身
- y	y的负数
x % y	模运算，取余
x ** y	幂运算，xy；当y是小数时，进行开方运算

对应的增强赋值操作符

增强操作符以及使用	描述
x op y	x += y； x -= y； x *= y； x /= y……

不同数字类型混合运算

• 结果取最“宽”的类型
• 整数 -> 浮点数 -> 复数
• 如：127.0 + 4 = 131.0

数值运算函数

函数及使用	描述
abs(x)	x取绝对值
divmod(x,y)	同时输出x//y和x%y，divmod(10,3) = (3,1)
pow(x,y [,z])	幂余，(x**y)%z，z可以省略
round(x [,d])	四舍五入，d是保留小数位数，默认值为0
max(x1,x2,…xn)	最大值
min(x1,x2,…xn)	最小值

例子：计算3 ^ 3⁹⁸ 的后四位

pow(3,pow(3,98),10000)

为了解决大数运算，取余可以始终让值保留在可表示范围内

数据类型转换

函数	描述
int(x)	x转为整数类型，int(“123”) = 123
float(x)	x转为浮点数类型，float(“1.23”) = 1.23
complex(x)	x转为复数类型，增加虚数部分

---

实例3 天天向上的力量

问题描述：持续的价值

一年365天，每天进步1%。，累计进步多少？ - 1.001³⁶⁵

一年365天，每天退步1%。，累计剩下多少？- 0.999³⁶⁵

如果是“三天打鱼两天晒网呢”？

如果加入双休日呢，双休日不退步不进步？

第一问

dayup = pow(1.001,365)
daydown = pow(0.999,365)
print("up: {:.2f} , down: {:.2f}".format(dayup,daydown)}

第二问

5%。和1%的力量

dayfactor = 0.005
dayup = pow(1 + dayfactor,365)
daydown = pow(1 - dayfactor,365)

dayfactor = 0.01

>>> dayup = 37.78343433288728

第三问

一年365天，一周五个工作日，每天进步1%

一年365天，一周两个工作日，每天退步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%一样

A：一年365天，每天进步1%
B：一年365天，工作日进步，休息日下降1%

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:
    dayfactor += 0.001
print("{:.3f}".format(dayfactor))

>>> 0.019

不积硅步无以至千里

举一反三

计算思维：抽象和自动化相结合的结果

• 抽象：抽象一个问题的形式化逻辑
• 自动化：通过程序自动化执行抽象的结果

---

3.4 字符串类型以及操作

• 字符串类型的表示
• 字符串操作符
• 字符串处理函数
• 字符串处理方法
• 字符串类型的格式化

字符串的表示

A. 字符串有两类 共四种表示方式：

1. 由一对单引号或双引号表示，仅表示单行字符串

   如：“双引号字符串” 或者 ‘单引号字符串’

2. 由一对三单引号或者三双引号表示，可表示多行字符串

   如：

   '''
   多行
   字符 
   '''
   

3. 如果在字符串中包含双引号或者单引号？

   ‘这里有一个双引号"’ 或者 “这里有一个单引号’”

4. 如果希望字符串中既包含单引号又包含双引号？

   ‘’‘这里既有单引号’ 又有双引号" ‘’’

B. 字符串的序号

• 正向递增序号 和 反向递减序号

C. 字符串的使用

• 索引

  返回字符串中单个字符，<字符串>[M]

• 切片

  返回从M到N-1的子串，<字符串>[M:N]

  用法：

  <字符串>[M:N:K]

  • M或者N可以缺失，M缺失表示至开头，N缺失表示至结尾

  如：“0123456789”[:3] 结果是 “012”

  • 可以根据步长K对字符串切片

  如：“0123456789”[1:8:2] 结果是"1357"
  如：字符串逆序，“0123456789”[::-1] 结果是"9876543210" 这里的步长-1表示从后向前逐一取出

D. 字符串转义

• 双引号：\ "
• 回退：\b 光标移动至前一个字符
• 换行：\n
• 回车：\r 光标移动至本行首

字符串操作符

操作符及使用	描述
x + y	字符串连接
n * x 或者 x * n	复制n次字符串x
x in s	如果x是s的子串，返回True，否则返回False

小例子：

用户输入整数1-7，输出对应的星期字符串

#根据用户的输入在字符串中切片，返回切片结果
weekStr = "星期一星期二星期三星期四星期五星期六星期日"

weekId = eval(input("请输入对应星期数字（1-7）"))

pos = (weekId - 1) * 3

print(weekStr[pos : pos + 3])

weekStr = "一二三四五六日"

weekId = eval(input("请输入对应星期数字（1-7）")

print("星期" + weekStr[weekId - 1])

字符串处理函数

函数及使用	描述
len(x)	返回字符串x长度
str(x)	将任意类型的x 变成字符串，如str(1.23) = “1.23”；str([1,2])结果为"[1,2]"，与eval()相反
hex(x) 或 oct(x)	返回整数x的十六进制或八进制小写形式字符串，如hex(425)结果为"0x1a9"，oct(425)结果为"0o651"
chr(u)	返回unicode编码u对应的字符
ord(x)	返回字符x对应的unicode编码

python3内部使用unicode编码

字符串处理方法

方法及使用	描述
str.lower() 或者 str.upper()	返回字符串，全部小写/大写
str.split([分隔符])	以分隔符为标志，分割字符串，返回在列表类型中，如 “A,B,C”.split(",") 结果为 [‘A’,‘B’,‘C’]
str.count(sub)	返回子串sub在str中出现的次数
str.replace(old,new)	将str中的old子串替换为new，如：“python”.replace[“n”,“n123.io”] 结果为"python123.io"
str.center(width[,fillchar])	字符串str根据宽度width居中，如"python".center(20,"=") 结果为"======= python ======="
str.strip(chars)	从str中去掉在其左侧和右侧chars中列出的字符，如："= python = “.strip(” =np")结果为"ytho"
str.join(iter)	在iter变量除最后一个元素外每个元素后增加一个str，如：",".join(“12345”) 结果为"1,2,3,4,5"

字符串格式化

字符串格式化使用.format()方法：

• 槽

占位信息符，用{}表示，只在字符串中有用

“{1}:计算机{0}的CPU占用率为{2}%”.format(“2020-04-03”,“C”,10)

• {<参数序号>:<格式控制标记>}

<格式控制标记>的六种类型

>>> "{0:=^20}".format("python")
'=======python======='

>>> "{0:*>20}".format("BIT")
'*****************BIT'

>>> "{:10}".format("BIT")
'BIT       '

>>> "{:,.2f}".format(12345.6789)
'12,345.68'

>>> "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
'110101001,Ʃ,425,651,1a9,1A9'
# b二进制，c unicode对应字符形式，d十进制，o八进制，x十六进制，X大写十六进制

>>> "{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'

3.4 time库的使用

• time库基本介绍
• 时间获取
• 时间格式化
• 程序计时应用

time库简介

• python标准库
• 精准计时，可以用于程序性能分析
• 可以格式化输出系统时间

import time

• 时间获取：time()、ctime()、gmtime()
• 时间格式化：strftime()、strptime()
• 程序计时：sleep()、perf_counter()

time库获取时间

函数	描述
time()	time.time() 获取当前时间戳，计算机内部时间值，是一个浮点数，表示从1970年1月1日零点开始到现在隔了多少秒
ctime()	time.ctime() 获取当前时间字符串，以易读方式表示
gmtime()	time.gmtime() 返回一个结构体，里面存储具体时间信息

time库时间格式化

strftime(tpl,ts)

>>>t = time.gmtime()
>>>time.strftime("%Y-%m-%d %H:%M:%S",t)
'2020-04-06 04:53:02'

• tpl 输出格式化模版字符串
• ts 时间类型对象

字符串转成时间变量

strptime(str,tpl)

    timeStr = '2020-04-06 04:53:02'
    t = time.strptime(timeStr,"%Y-%m-%d %H:%M:%S")
    #与strftime互补

• str 字符串形式的时间
• tpl 格式化模版字符串

程序计时应用

• 测量时间：perf_counter() 单位是纳秒
• 产生时间：sleep() 单位是秒

    start = time.perf_counter()
    end = time.perf_counter()
    end - start

    time.sleep(3)

实例4：文本进度条

采用字符串方式打印可以动态变化的文本进度条

进度条需要能在一行中逐渐变化

简单的版本

import time
scale = 10
print("----start----")
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("----end----")

“文本进度条” 单行动态刷新

• 不能换行：print()需要被控制
• 要能回退：打印后光标退回到之前位置

import time
for i in range(101):
    print("\r{:3}%".format(i),end = "") #\r 光标回退
    time.sleep(0.1)

print参数[end ], 输出完后字符串想要增加什么信息写在end中，加入了end参数，print输出完不会换行

“文本进度条”完整效果

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,'-'))

举一反三

• perf_counter()