master
/ 2.ipynb

2.ipynb @master — view markup · raw · history · blame

Notebook

第 2 章 数值类型

教学目的和要求

  1. 掌握三种数值类型
  2. 掌握数值类型的方法与类型转换
  3. 掌握数值运算
  4. 常用数值运
  5. math模块 用 其应用

重点难点

重点：

  1. 整型、浮点型的应用与类型转换
  2. 数学运算函数

难点：

  1. 数据类型转换
  2. 表达式与运算优先级

教学安排

预习及预习检验（25分钟）

  1. 本章数字教程 5分钟
  2. 阅读教材 5分钟
  3. 数值类型翻转教学设计 15分钟

课堂教学（2学时共90分钟）

复习： （2分钟）

  1. 输入函数的接收到的只能是字符串类型
  2. 字符串不能参与数值运算
  3. 引出数值类型转换

讲授：

  1. 数值类型及其转换函数（15分钟）
    整型int()
    浮点型float()
    复数类型complex()
  2. 赋值运算（3分钟）
  3. 数值运算（10分钟）
  4. 常用数值运算函数（15分钟）
  5. 数值计算案例教学（15分钟）
  6. math库（20分钟）
  7. 常用运算（20分钟）

本章小节

  1. 所有客观对象都要抽象成数据，才能在计算机中进行存储和处理
  2. 参与数值运算的对象必须转为数值类型，主要是应用int()和float()函数转为整型或浮点类型
  3. 数据类型、运算符和表达式是程序设计的基本概念，必须熟练运用
  4. math库中的函数不需要背记，可依赖IDE的提示使用
  5. 常用运算要注意运算的优先级

作业

Python第二章作业（初级）（7关约30-90分钟）

实验项目(建议90分钟)

  1. 矩形面积运算(project)（6关约20分钟）
  2. 地球数据计算闯关(project)（5关约20分钟）
  3. 计算弓形的面积(project)（2关约10分钟）
  4. 计算几何形状的表面积与体积(project)（7关约20分钟）
  5. 学费计算(project)（2关约10分钟）
  6. 弧田术(project)（6关约20分钟）

备注

  1. 演示编写程序，强调输入的数据必须转数值型才能参与数值运算
  2. math库不用多讲，了解会用即可
  3. 常用运算中可放在本章讲也可放到下一章讲

问题总结

  1. eval()函数效率不高且存在安全性问题，建议学生不要滥用
  2. 明确根据要求转整型或浮点型
  3. 复杂数值公式转表达式可重点讲一下
  4. 本章部分内容可采取翻转教学，由学生课上完成翻转教学项目，培养学生自学能力。

本章教学内容案例

2.1 数值类型

整数（int）
浮点数（float）
复数（complex）

2.1.1 整数（int）

整数常被称为整型或整数类型
不包含小数点的数字
十进制： 0 、123、-45
二进制：0b1101、0B1100
八进制：0o17、0O777
十六进制：0xff、0X123456789ABCDEF

整数特点
大小无限制，可精确表示超大数

In [1]:
import math  # 导入 math 库
# 计算100的阶乘,158位整数

print(math.factorial(100))

输出： 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

整数子类--bool值

True和False
以整数“1”和“0”为值参与数值运算

In [ ]:
print(False + 2)          # 2
print(True * 2 + 3)       # 5
print((67 > 60) * 5 + 8)  # 13

2.1.2 浮点数（float, 实数）

十进制表示 由整数部分、小数点与小数部分组成

123.45、23.0、0.78、 12. (12.0)、.15 (0.15)

科学记数法表示 e(n为整数)

0.48e-5、2e3、2.53e3 2.53e3（2.53 × 103 = 2530.0） 等价于a×10n

浮点数无法保证完全精确，输出时只保留17位有效数字

In [2]:
print(43.02 * 7)

预期输出：301.14 实际结果：301.14000000000004

In [3]:
print(5.02 / 0.1)

预期输出：50.20 实际结果：50.199999999999996

浮点数表示的数字最大值约为1.7× 10308

In [4]:
print(pow(809.0, 106))  # 输出809的106次幂的值
# 输出 1.748007496839708e+308
In [5]:
print(pow(810.0, 106))  # 输出810的106次幂的值
# OverflowError: (34, 'Result too large')

2.1.3 复数

由实数部分和虚数部分构成
实部虚部都是浮点数
用a + bj 或 complex(a, b)表示

In [6]:
print((3.0 + 4.0j).real)   # 输出实部 3.0
print((3.0 + 4j).imag)    # 输出虚部 4.0
print(abs(3.0 + 4.0j))    # 输出复数的模 5.0

2.2 数值类型转换

In [1]:
side = input()         # 输入 '5'
perimeter = side * 4  # 等价于 '5' * 4
print(perimeter)       # 输出 '5555'

2.2.1 字符串转整数 (int)

int('x') 可将整数字符串'x'转为整数 x

输入整数，表示正方形的边长， 计算并输出其周长

In [ ]:
side = input()     # 输入'5'
perimeter = int(side) * 4  # 字符串转整数 (int)，变成数值 5 * 4
print(perimeter)  # 输出 20

输入整数，表示正方形的边长， 计算并输出其周长

In [2]:
side = int(input())   # 输入'5'，字符串转整数 (int)，int('x') 可将整数字符串'5'转为整数 5
perimeter = side * 4  # 相当于5 * 4
print(perimeter)      # 输出20

int('x') 可将整数字符串'x'转为整数 x，无法将浮点数字符串转为整数

In [2]:
side = int(input())  # 输入浮点数，表示正方形的边长， 计算并输出其周长，输入'3.5'
# int() 无法将浮点数字符串转为整数
perimeter = side * 4  
print(perimeter)
# ValueError: invalid literal for int() with base 10: '3.5'

24

2.2.1 字符串转浮点数 (float)

float('x') 可将浮点数字符串'x'转为浮点数 x
float('x') 可将整数'x'转为浮点数 x

输入浮点数，表示正方形的边长， 计算并输出其周长

In [4]:
side = float(input())  # float('x')可将浮点数字符串'x'转为浮点数 x，输入3.5
perimeter = side * 4   # 3.5 * 4
print(perimeter)        # 输出 14.0
In [6]:
side = float(input())  # float('x')可将整数字符串'x'转为浮点数 x.0，输入 3
perimeter = side * 4   # 3.0 * 4
print(perimeter)       # 输出 12.0

eval('x')可将整数字符串'x'转为整数 x
eval('x')可将浮点数字符串'x'转为浮点数 x

side = eval(input()) # eval('x')可将整数字符串'x'转为整数 x,输入3 perimeter = side 4 # 3 4 print(perimeter) # 12

In [7]:
side = eval(input())   # eval('x')可将浮点数字符串'x'转为浮点数 x,输入3.0
perimeter = side * 4   # 3.0 * 4
print(perimeter)       # 12.0

float('x')去除字符串开头和结尾的空白字符， 包括：空格、\n、\t 等

In [8]:
print(float(3))            # 输出 0.678
print(float('  0.678\n'))  # 输出 3.0

int('x')去除字符串开头和结尾的空白字符， 包括：空格、\n、\t 等
int(x.b)可截取浮点数x.b的整数部分 x

In [9]:
print(int(3.99))       # 输出 3
print(int('  678\n'))  # 输出 678

int('x', base=10))将其他进制字符串转为十进制整数
base 为整数，此参数缺省时为十进制
其他进制字符串转整数 (int)

In [ ]:
print(int('20'))            # 输出 20
print(int('20', base=10))   # 输出 20
print(int('20', 10))         # 输出 20

其他进制字符串转整数 (int)
int('x', base=10) )
2、8、10、16代表二进制、八进制、十进制和十六进制

In [10]:
print(int('11111111', base=2))  # 输出 255
print(int('11111111', 2))       # 输出 255
print(int('17', 8))             # 输出 15
print(int('FF', 16) )           # 输出 255

实例 2.1 计算矩形面积
矩形的面积等于其长与宽的乘积，用户输入长和宽的值，按输入要求编程计算矩形的面积，输入要求如下：
（1） 输入两个正整数，输出结果为整数int()
（2） 输入两个浮点数，输出结果为浮点数float()
（3） 输入两个正数，要求输出的数据类型与输入的数据类型保持一致eval()
输入：输入长和宽的数值
处理：利用短形面积公式计算面积
输出：输出面积

In [ ]:
# 输入整数表示的矩形的长和宽， 计算并输出矩形的面积
width = int(input())   # 用int()函数将输入转成整数，例如输入：3
length = int(input())  # 用int()函数将输入转成整数，例如输入：4
area = width * length  # 利用面积公式计算面积
print(area)            # 输出：12
In [ ]:
# 输入浮点数表示的矩形的长和宽， 计算并输出矩形的面积

width = float(input())   # float()转成浮点数，输入：2.456
length = float(input())  # float()转成浮点数，输入：3.58
area = width * length    # 计算面积
print(area)              # 输出：8.79248
print(round(area, 2))    # 保留2位小数，输出：8.79
In [ ]:
# 输入两个正数，要求输出的数据类型与输入的数据类型保持一致eval()， 计算并输出矩形的面积

width = eval(input())   # 用eval()函数将输入转成数值型
length = eval(input())  # 用eval()函数将输入转成数值型
area = width * length   # 利用面积公式计算面积
print(area)             
# 输入3，4时，输出：12；
# 输入3.0，4.0时，输出12.0

数值运算

数学运算符：+、 -、 、 /、 //、 %、 ** a = 8 b = 5 print(a + b) # 结果为 13 print(a - b) # 结果为 3 print(a b) # 结果为 40 print(a / b) # 精确除法，浮点数1.6 print(a ** b) # a 的 b 次幂，32768 加、减、乘、除、整除、取模、 幂

x1 = -b + b 2 - 4 a c 0.5 2 a x2 = -b - b 2 - 4 a c 0.5 2 a

数学运算符：+、 -、 *、 /、 //、 %、 ** 数学公式： 表达式：

整除（//）: 整除，结果为整数，向下取整算法

当有浮点数参与运算的时候，结果为浮点型的整数

print(11 // 4) print(99 // 10) print(99.0 // 10)

9 2.75 print(-11 // 4) -2.75 9.0 2 -3 除（/）: 除法，结果为浮点数 print(11 / 4) 2.75

取模（%）: 两个数整除的余数

模非零时，其符号与除数相同

a % b = a - (a // b) * b

判断整除

判断奇偶

a % 4 == 0 and a % 100 != 0

a % 2 == 0

使结果落在某区间 a % 7 a % 26 结果: 0, 1, 2, 3, 4, 5, 6 结果: 0, 1, 2……24, 25

幂（）: 两个星号表示幂运算 a b

print((1 / 2) ** 2)

print(3 2) print(3 (1 / 2)) print((-4) (1 / 2)) 9 1.732 0.25 (1.2246467991473532e-16+2j) a b 中 b 小于 1 时为开方，负数开偶次方结果为复数

实例 2.2 一元二次方程求解 现有一元二次方程：ax2 + bx + c = 0，当a，b，c的值分别为5，8，3时，编程求其实根。 a, b, c = 5, 8, 3 # 同步赋值，5，8，3分别赋值给a,b,c x1 = (-b + (b b - 4 a c) ** (1 / 2)) / (2 a) x2 = (-b - (b b - 4 a c) ** (1 / 2)) / (2 a) # x2 = (-b - (b 2 - 4 a c) 0.5) / (2 a) print(x1,x2) # 在一行内输出-0.6 -1.0，输出结果用空格分隔 此题中，判别式b2-4ac= 8 8 – 4 5 3 = 4 > 0 该方程有两个不相等的实数解 可利用一元二次方程的求根公式进行计算

实例 2.2 一元二次方程求解 现有一元二次方程：ax2 + bx + c = 0，当a，b，c的值分别为5，8，3时，编程求其实根。 a, b, c = eval(input()) if b b - 4 a c > 0: x1 = (-b + (b b - 4 a c) (1 / 2)) / (2 a) x2 = (-b - (b b - 4 a c) 0.5) / (2 * a) print(x1, x2) a,b,c的值由用户在一行内输入的3个逗号分隔的数字

实例 2.2 一元二次方程求解 现有一元二次方程：ax2 + bx + c = 0，当a，b，c的值分别为5，8，3时，编程求其实根。 a, b, c = eval(input()) if b b - 4 a c > 0: x1 = (-b + (b b - 4 a c) (1 / 2)) / (2 a) x2 = (-b - (b b - 4 a c) 0.5) / (2 a) print(x1, x2) elif b b - 4 a c == 0: print(-b / (2 a)) else: x1 = (-b + (b b - 4 a c) (1 / 2)) / (2 a) x2 = (-b - (b b - 4 a c) 0.5) / (2 * a) print(x1, x2)

常用数学运算函数

绝对值abs(x) print(abs(-3)) 3 print(abs(-3.45)) 3.45 print(abs(3 + 4j)) 5.0 x 为整数或浮点数时返回其绝对值 x 为复数时返回复数的模

返回 x的y次幂 print(pow(2, 3)) 8 print(pow(2, 1/2)) 1.4142135623730951 print(pow(-2, 1/2)) print(pow(1999, 1998, 1997)) 4
幂 pow(x, y) (8.659560562354934e-17+1.4142135623730951j) x 的 y 次幂计算结果再对z 取模，效率高 pow(x, y[, z]) 1999 ** 1998 % 1997

max(arg1,arg2,…) 从多个参数中返回其最大值 print(max(80, 100, 1000)) 1000 max(iterable) 从一个可迭代对象中返回其最大值 print(max([49, 25, 88])) 88 最大值 max()

min(arg1,arg2,…) 从多个参数中返回其最小值 print(min(80, 100, 1000)) 80 min(iterable) 从一个可迭代对象中返回其最小值 print(min((49, 25, 88))) 25 最小值 min()

sum(iterable) print(sum(range(11))) 55 print(sum([1, 2, 3, 4])) 10 将元素为数值的可迭代对象中的元素累加 加和 sum()

print(sum(range(11), start=10)) 65 print(sum([1, 2, 3, 4], 10)) 20 将元素为数值的可迭代对象中的元素累加到start上 sum(iterable, start=0) 加和 sum()

round(number, n)浮点数number保留n 位小数最短表示
print(round(3.14)) 3 print(round(3.84)) 4 print(round(3.125001, 2)) 3.13 print(round(3.125, 2)) 3.12 print(round(3.115, 2)) 3.12 四舍 print(round(3.84, 1)) 3.8 print(round(3.86, 1)) 3.9 五后非零就进一 五前为偶应舍去 五前为奇要进一 六入 五考虑

结果小数部分的末位为0 或n 超过小数位数时，返回该数的最短表示 print(round(3.0000, 2)) 期望输出3.00 print(round(3.14, 4)) 期望输出3.1400 实际输出其浮点数的最短表示3.0 实际输出3.14

多数浮点数无法精确转为二进制，会导致部分数字取舍与期望不符

print(round(3.1425, 3)) import decimal print(decimal.Decimal(2.675)) print(decimal.Decimal(3.1425))
2.67499999999999982236431605997495353221893310546875 3.1425000000000000710542735760100185871124267578125 print(round(2.675, 2)) 3.142 2.68 3.143 2.67

Math模块及应用

import math 导入 math 模块,引用时函数名前要加 'math.' https://docs.python.org/3/library/math.html

print(math.pi) # pi为圆周率常量 3.141592653589793 print(math.sqrt(2)) # sqrt为开平方函数 1.4142135623730951

from math import pi,sqrt 导入math中的常数pi和sqrt()函数或全部函数 from math import * print(pi)

3.141592653589793 print(sqrt(2)) 1.4142135623730951

math 数论与表示函数 24 个 幂与对数函数 8 个 三角函数 9 个 双曲函数 6 个 角度转换函数 2 个 特殊函数 4 个 常量 5 个 https://docs.python.org/zh-cn/3.9/library/math.html

math.fabs(x) 以浮点数形式返回x的绝对值 import math print(math.fabs(-6)) # 6.0

from math import fabs print(fabs(-6)) # 6.0 math.fabs(x) 以浮点数形式返回x的绝对值

math.factorial(x)：返回x的阶乘 print(math.factorial(6)) 720 要求x为非负整数，x为负数或浮点数时返回错误 print(math.factorial(-6)) ValueError: factorial() not defined for negative values print(math.factorial(6.5)) ValueError: factorial() only accepts integral values

math.fsum() 返回浮点数迭代求和的精确值 print(sum([.1, .1,.1, .1, .1, .1, .1, .1, .1, .1, .1]))
1.0999999999999999 import math

print(math.fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])) 1.0

math.gcd(*integers) 返回给定的整数参数的最大公约数 print(math.gcd(88, 44, 22)) 22 返回值是能同时整除所有参数的最大正整数 print(math.gcd(88, 44, 0)) 44 如果所有参数为零或无参数，则返回值为0 print(math.gcd(0, 0)) 0

math.lcm(*integers) 返回给定的整数参数的最小公倍数 print(math.lcm(5, 44, 22)) 220 如果参数之一为0，返回值为0 print(math.lcm(22, 44, 0)) 0 无参数时，返回值为1 print(math.lcm(0, 0)) 0 print(math.lcm()) 1

math.floor(x) 返回不大于x的最大整数 print(math.floor(9.99)) # 输出9

math.ceil(x) 返回不小于x的最小整数 print(math.ceil(9.01)) # 输出10

math. sqrt(x) # 返回非负整数 x 的平方根

import math print(math.sqrt(5)) # 5的平方根2.23606797749979 math. isqrt(x) # 返回非负整数 x 的整数平方根 print(math.isqrt(5)) # 非负整数 5 的整数平方根2

实例2.3 换披萨 程序员小明在披萨店订购了一个直径为12 英寸的披萨，送货前客服打电话来说“对不起，12 英寸的卖完了，为了补偿您，我们给你2 个直径7 英寸披萨好吗？” 这个更换方案是否合理取决于最终吃到的披萨的多少？ 披萨本身是近似于圆柱体的不规则的形状，不同直径披萨的用料、厚度、工艺等都可能不同，所以想用计算机计算，需要做一些近似和假设： 1.披萨是规则的圆柱形 2.厚度均匀 3.材料均匀 4.不同尺寸的披萨用料比例相同 5.不同尺寸的披萨厚度相同 这样可以将披萨抽象为一个圆柱体，前面假设的条件下，此问题简化为大、小披萨的面积计算。圆的面积计算公式：s = πr2

实例2.3 换披萨 程序员小明在披萨店订购了一个直径为12 英寸的披萨，送货前客服打电话来说“对不起，12 英寸的卖完了，为了补偿您，我们给你2 个直径7 英寸披萨好吗？”

import math # 导入math库，后面应用库中的pi值和ceil()函数 PI = math.pi # 圆周率π的值 # 计算12寸披萨面积与 2 个 7 寸披萨面积之差 profit = PI 12 12 / 4 - 2 PI 7 * 7 / 4 print(profit) # 输出面积差值36.128315516282626

实例2.3 换披萨

In [1]:
import math   # 导入math库，后面应用库中的pi值和ceil()函数


diameter_of_big = int(input())                     # 披萨直径为整数
diameter_of_small = int(input())                   # 披萨直径为整数

area_of_big = math.pi * (diameter_of_big / 2) ** 2      # 大寸披萨的面积
area_of_small = math.pi * (diameter_of_small / 2) ** 2  # 小寸披萨的面积
n = area_of_big / area_of_small   # 大披萨与小披萨面积比值
num = math.ceil(n) # num值为不小于n的最小整数
profit = area_of_small * math.ceil(num) - area_of_big  # 更换后多得的披萨的面积

print(num) # 输出合理的更换数量
print(f'{num}个{diameter_of_small}寸披萨与1个{diameter_of_big}寸披萨面积差值为{round(profit, 2)}平方英寸')
In [ ]: