【Python程序设计(三)】基本数据类型

1 数字类型及操作

1.1 整数类型

整数类型与数学中整数的概念一致，可正可负，没有取值范围限制。

pow(x,y) 函数：计算 x^y ，想算多大算多大

>>> pow(2,100)
1267650600228229401496703205376

有 4 种进制表示形式

• 十进制：1010, 99, -217
• 二进制，以 0b 或 0B 开头：0b010, -0B101
• 八进制，以 0o 或 0O 开头：0o123, -0O456
• 十六进制，以 0x 或 0X 开头：0x9a, -0X89

1.2 浮点数类型

浮点数类型与数学中实数的概念一致

• 浮点数取值范围和小数精度都存在限制，但常规计算可忽略
• 取值范围数量级约-10³⁰⁷ 至10³⁰⁸，精度数量级10^-16

浮点数间运算存在不确定尾数，不是 bug

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

0.1 用 53 位二进制表示小数部分，约 10^-16
二进制表示为：0.00011001100110011001100110011001100110011001100110011010
十进制表示为：0.1000000000000000055511151231257827021181583404541015625

用二进制表示小数，可以无限接近，但不完全相同，0.1 + 0.2 的结果无限接近0.3，但可能存在尾数，不确定尾数一般发生在10^-16 ，所以浮点数相等判断不能直接用 == 符号

>>> 0.1 + 0.2 == 0.3
False
>>> round(0.1+0.2, 1) == 0.3
True

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

浮点数可以采用科学计数法表示，使用字母 e 或 E 作为幂的符号，以 10 为基数，格式如下：

<a>e<b> 表示 a*10^b

例如：4.3e-3 值为 0.0043，9.6E5 值为 960000.0

关于 Python 浮点数，需要知道这些：

1. 取值范围和精度基本无限制
2. 运算存在不确定尾数 round()
3. 科学计数法表示

1.3 复数类型

与数学中复数的概念一致
z = 1.23e-4+5.6e+89j
z.real 获得实部，z.imag 获得虚部

1.4 数值运算操作符

操作符及使用	描述
x + y	加，x 与 y 之和
x – y	减，x 与 y 之差
x * y	乘，x 与 y 之积
x / y	除，x 与 y 之商 10/3结果是3.3333333333333335
x // y	整数除，x 与 y 之整数商 10//3 结果是 3

增强操作符及使用	描述
x op= y	即 x = x op y，其中，op为二元操作符
	x += y， x -= y， x *= y， x /= y， x //= y， x %= y， x **= y

类型间可进行混合运算，生成结果为"最宽"类型

• 三种类型存在一种逐渐"变宽"的关系：
  整数 -> 浮点数 -> 复数
• 例如：123 + 4.0 = 127.0 (整数+浮点数 = 浮点数)

1.5 数值运算函数

函数及使用	描述
abs(x)	绝对值，x的绝对值 abs(-10.01) 结果为 10.01
divmod(x,y)	商余，(x//y, x%y)，同时输出商和余数 divmod(10, 3) 结果为 (3, 1)
pow(x, y[, z])	幂余，(x**y)%z，[] 表示参数 z 可省略 pow(3, pow(3, 99), 10000) 结果为 4587
round(x[, d])	四舍五入，d 是保留小数位数，默认值为 0 round(-10.123, 2) 结果为 -10.12
max(x1 ,x2 , … ,xn )	最大值，返回 x1 ,x2 , … ,xn 中的最大值，n 不限 max(1, 9, 5, 4, 3) 结果为 9
min(x1 ,x2 , … ,xn )	最小值，返回 x1 ,x2 , … ,xn 中的最小值，n 不限 min(1, 9, 5, 4, 3) 结果为 1
int(x)	将 x 变成整数，舍弃小数部分 int(123.45) 结果为 123； int(“123”) 结果为 123
float(x)	将 x 变成浮点数，增加小数部分 float(12) 结果为 12.0； float(“1.23”) 结果为 1.23
complex(x)	将 x 变成复数，增加虚数部分 complex(4) 结果为 4 + 0j

2 实例: 天天向上的力量

问题 1： 1‰ 的力量

• 一年 365 天，每天进步 1‰，累计进步多少呢？
• 一年 365 天，每天退步 1‰，累计剩下多少呢？

dayfactor = 0.001
dayup = pow(1 + dayfactor, 365)
daydown = pow(1 - dayfactor, 365)
print("向上：{:.2f},向下：{:.2f}".format(dayup, daydown))

运行结果：

向上：1.44,向下：0.69

问题2： 工作日的力量

• 一年365天，一周5个工作日，每天进步1%
• 一年365天，一周2个休息日，每天退步1%，这种工作日的力量，如何呢？

dayup = 1.0
dayfactor = 0.01
for i in range(365):
    if i%7 in [6, 0]:
        dayup *= (1 - dayfactor)
    else:
        dayup *= (1 + dayfactor)
print("工作日的力量：{:.2f}".format(dayup))

运行结果：

工作日的力量：4.63

问题3： 工作日的努力

• 工作日模式要努力到什么水平，才能与每天努力1%一样？
• A君: 一年 365 天，每天进步 1%，不停歇
• B君: 一年 365 天，每周工作 5 天休息 2 天，休息日下降 1%，要多努力呢？

我们这里采用笨办法，一点点的试，从 0.01 开始，每次增加 0.001，看什么时候和每天进步 1%，不停歇的进步水平相同。

def dayUP(df):
    dayup = 1.0
    for i in range(365):
        if i%7 in [0, 6]:
            dayup *= (1 - 0.01)
        else:
            dayup *= (1 + df)
    return dayup;
dayfactor = 0.01
while dayUP(dayfactor) < 37.78:
    dayfactor += 0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))

运行结果

工作日的努力参数是：0.019

3 字符串类型及操作

3.1 字符串类型的表示

字符串有 2类共4种 表示方法

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

"abc" 
或者
'abc'
或者
''' Python
语言 '''

注：三单引号或三双引号也是注释，Python 中注释本质上就是一个字符串

• 索引：返回字符串中单个字符 <字符串>[M]
  “abc”[0] 或者 TempStr[-1]
• 切片：返回字符串中一段字符子串 <字符串>[M: N]
  "abc "[1:3] 或者 TempStr[0:-1]

字符串切片高级用法：使用[M: N: K]根据步长对字符串切片

• <字符串>[M: N]，M 缺失表示至开头，N 缺失表示至结尾
  “〇一二三四五六七八九十”[:3] 结果是 “〇一二”
• <字符串>[M: N: K]，根据步长 K 对字符串切片
  “〇一二三四五六七八九十”[1:8:2] 结果是 “一三五七”
  “〇一二三四五六七八九十”[::-1] 结果是 “十九八七六五四三二一〇”

特殊字符：转义符 \

• 转义符表达特定字符的本意
  “这里有个双引号(\”)" 结果为 这里有个双引号(")
• 转义符形成一些组合，表达一些不可打印的含义
  “\b” 回退
  “\n” 换行(光标移动到下行首)
  “\r” 回车(光标移动到本行首)

3.2 字符串操作符

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

example：获取星期字符串

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])

3.3 字符串处理函数

操作符及使用	描述
len(x)	长度，返回字符串 x 的长度 len(“一二三456”) 结果为 6
str(x)	任意类型 x 所对应的字符串形式 str(1.23) 结果为 “1.23”，str([1,2]) 结果为 “[1,2]”
hex(x) 或 oct(x)	整数 x 的十六进制或八进制小写形式字符串 hex(425) 结果为 “0x1a9” oct(425) 结果为 “0o651”
chr(u)	x 为 Unicode 编码，返回其对应的字符
ord(x)	x 为字符，返回其对应的 Unicode 编码

3.4 字符串处理函数

字符串处理函数	描述
str.lower() 或 str.upper()	返回字符串的副本，全部字符小写/大写 "AbCdEfGh".lower() 结果为 “abcdefgh”
str.split(sep=None)	返回一个列表，由 str 根据 sep 被分隔的部分组成 "A,B,C".split(",") 结果为 [‘A’,‘B’,‘C’]
str.count(sub)	返回子串 sub 在 str 中出现的次数 "an apple a day".count(“a”) 结果为 4
str.replace(old, new)	返回字符串 str 副本，所有 old 子串被替换为 new "python".replace(“n”,“n123.io”) 结果为 “python123.io”
str.center(width[,fillchar])	字符串 str 根据宽度 width 居中，fillchar 可选 "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" #主要用于字符串分隔等

3.5 字符串类型的格式化

格式化是对字符串进行格式表达的方式，字符串格式化使用 .format()方法，用法如下：

• <模板字符串>.format(<逗号分隔的参数>)

槽内部对格式化的配置方式
{ <参数序号> ： <格式控制标记>}

:	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	用于填充的单个字符	< 左对齐 > 右对齐 ^ 居中对齐	槽设定的输出宽度	数字的千分隔符	浮点数小数精度或 字符串最大输出长度	整数类型 b, c, d, o, x, X 浮点数类型 e, E, f, %

4 time 库的使用

time 库是 Python 中处理时间的标准库，包括三类函数

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

import time
time.()

4.1 时间获取

4.2 时间格式化

将时间以合理的方式展示出来，类似字符串格式化，需要有展示模板，展示模板由特定的格式化控制符组成

函数	描述
strftime(tpl, ts)	tpl是格式化模板字符串，用来定义输出效果 ts是计算机内部时间类型变量 >>>t = time.gmtime() >>>time.strftime("%Y-%m-%d %H:%M:%S",t) ‘2018-01-26 12:55:20’

格式化字符串	日期/时间说明	值范围和实例
%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
%I	小时（12h制）	01~12，例如：7
%p	上/下午	AM, PM，例如：PM
%M	分钟	00~59，例如：26
%S	秒	00~59，例如：26

函数	描述
strptime(str, tpl)	str是字符串形式的时间值 tpl是格式化模板字符串，用来定义输入效果 >>>timeStr = ‘2018-01-26 12:55:20’ >>>time.strptime(timeStr, “%Y-%m-%d %H:%M:%S”) time.struct_time(tm_year=2018, tm_mon=1, tm_mday=26, tm_hour=4, tm_min=11, tm_sec=16, tm_wday=4, tm_yday=26, tm_isdst=0)

4.3 程序计时

函数	描述
perf_counter()	返回一个CPU级别的精确时间计数值，单位为秒 由于这个计数值起点不确定，连续调用差值才有意义 >>>start = time.perf_counter() 318.66599499718114 >>>end - start 22.724523540384666
sleep(s)	s拟休眠的时间，单位是秒，可以是浮点数 >>>def wait(): time.sleep(3.3) >>>wait() #程序将等待3.3秒后再退出

5 实例: 文本进度条

需求分析：采用字符串方式打印可以动态变化的文本进度条，进度条需要能在一行中逐渐变化

要在一行中逐渐变化就要实现动态刷新，不能换行，用之后打印的字符覆盖之前的字符，打印后光标退回到之前的位置，这里使用 \r 来实现。

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() 语句打印完一行自动换行，end=''可以不换行
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end = '')
    time.sleep(0.1)
print("\n" + "执行结束".center(scale//2, '-'))

运行结果：

6 小结

1、数字类型及操作

• 整数类型的无限范围及 4 种进制表示
• 浮点数类型的近似无限范围、小尾数及科学计数法
• +、-、*、/、//、%、**、二元增强赋值操作符
• abs()、divmod()、pow()、round()、max()、min()
• int()、float()、complex()

2、字符串类型及操作

• 正向递增序号、反向递减序号、<字符串>[M:N:K]
• +、*、in、len()、str()、hex()、oct()、ord()、chr()
• .lower()、.upper()、.split()、.count()、.replace()
• .center()、.strip()、.join(）、.format() 格式化