数值类型

整数（int）
用int(x)将x转为整数出现异常可能是因为x是空字符串、浮点数字符串等原因
浮点数（float）
复数（complex）

能力点1：数据类型转换

a = eval(input())   #输入整数字符串，转换为整数；输入浮点数字符串，转换为浮点数
b = float(input())  #输入整数和浮点数，都转换为浮点数
c = int(input())    #只接受整数输入，输出为整数

示例2.1：计算矩形面积

输入格式
第一行输入一个数字，代表矩形的长‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
第二行输入一个数字，代表矩形的宽‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
（输入使用input()，不要增加额外的提示信息）‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
输出格式
输出矩形的面积，不限定小数位数

width = int(input())   # 4
length = int(input())  # 5
area = width * length
print(area)            # 20

width = float(input())   # 4   4.0
length = float(input())  # 5   5.0
area = width * length 
print(area)              # 20.0

width = eval(input())   # 4   4.0
length = eval(input())  # 5   5.0
area = width * length
print(area)             # 20  20.0

能力点2：数学运算

+、 -、 、 /、 //、 %、 *
加、减、乘、除、整除、取模（余）、 幂

能力点3：数值运算优先级

表 3.5 运算符的优先级（由高到低排列）

用括号保证计算顺序

x = () / ()       # 分子分母分别加括号，分号变除号
x = () / (2 * a)  # 完成分母
x = (-b + (b * b - 4 * a * c) ** (1 / 2)) / (2 * a)  # 开方内容加括号，分数加括号

a = float(input())
b = float(input())
c = float(input())
x = (-b + (b * b - 4 * a * c) ** (1 / 2)) / (2 * a)
x = (-b + (b * b - 4 * a * c) ** 0.5) / (2 * a)
print(x)

能力点4：精度控制

round(number[, ndigits]) # 保留n位小数的浮点数最短表示，3.000表示为3.0
'{:.nf}'.format(number)  # 严格保留n位小数，3.000表示为3.000
f'{number:.nf}'          # 严格保留n位小数 ，3.000表示为3.000

x = 3.14000926
print(round(x, 2))  # 3.14
print(f'{x:.2f}')   # 3.14
print(round(x, 4))  # 3.14,保留最短表示
print(f'{x:.4f}')   # 3.1400，精确保留n位小数

示例2.2：三角形周长及面积

描述
输入的三角形的三条边a、b、c 的长度，计算并依次输出三角形的周长和面积，结果严格保留2位小数。测试用例的数据保证三角形三边数据可以构成三角形。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
三角形面积计算公式： ，其中s=(a+b+c)/2。
输入输出格式
分三行输入 3 个浮点数，表示三角形的三个边长‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
输出格式
三角形的周长和面积，格式参考示例‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
输入输出示例

a = float(input())
b = float(input())
c = float(input())
s = (a + b + c) / 2
m = (s * (s - a) * (s - b) * (s - c)) ** 0.5
print("周长={:.2f}".format(a + b + c))
print("面积={:.2f}".format(m))
print(f"面积={m:.2f}")

def calculate():  # 定义函数，相当于给下面的代码段起个名字
    s = (a + b + c) / 2
    m = (s * (s - a) * (s - b) * (s - c)) ** 0.5
    print("周长={:.2f}".format(a + b + c))
    print("面积={:.2f}".format(m))
    print(f"面积={m:.2f}")  # :.2f控制精度，精确保留2位小数
if __name__ == '__main__':
    a = float(input())  # 输入转浮点数
    b = float(input())
    c = float(input())
    calculate()         # 调用函数

能力点5：利用数值运算相关内置函数计算

1. int()

int([x])
int(x, base=10)

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。
对于浮点数，它将向零舍入。

print(int(4.9))   # 4
print(int(-4.9))  # -4

如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的 整数字面值 的 bytearray 实例。
该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。
一个进制为 n 的数字包含 0 到 n-1 的数，其中 a 到 z （或 A 到 Z ）表示 10 到 35。
默认的 base 为 10 ，允许的进制有 0、2-36。
2、8、16 进制的数字可以在代码中用 0b/0B 、 0o/0O 、 0x/0X 前缀来表示。

print(int('010'))      # 10
print(int('010', 2))   # 2
print(int('01F', 16))  # 31
print(int('010', 8))   # 8
print(int('10', 8))    # 8
print(int('010', 8))   # 8

IP 地址二进制转十进制
11001100100101000001010101110010
204.148.21.114

print(int('11001100', 2))       # 204
print(int('10010100', 2))       # 148
print(int('00010101', 2))       # 21
print(int('01110010', 2))       # 114
print(int('01110010', base=2))  # 114

进制为 0 将安照代码的字面量来精确解释，最后的结果会是 2、8、10、16 进制中的一个。所以 int(‘010’, 0) 是非法的，但 int(‘010’) 和 int(‘010’, 8) 是合法的。

print(int('10', 0))    # 10
print(int('0xFF', 0))    # 10
print(int('010', 0))   # ValueError: invalid literal for int() with base 0: '010'

2. float()

float([x])

返回从数字或字符串 x 生成的浮点数。
如果参数是个字符串，则应包含一个十进制数字，前面可选带上符号，也可选前后带有空白符。
符号可以是’+’或 ‘-‘；’+’ 符号对值没有影响。

3. complex()

complex([real[, imag]])

返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。
如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。
第二个形参不能是字符串。
每个实参都可以是任意的数值类型（包括复数）。
如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。
如果两个实参都省略，则返回 0j。

4. eval()

eval(expression[, globals[, locals]])

实参是一个字符串，以及可选的 globals 和 locals。
globals 实参必须是一个字典。locals 可以是任何映射对象。
表达式解析参数 expression 并作为 Python 表达式进行求值（从技术上说是一个条件列表）
如果两个字典都被省略，则将使用调用 eval() 的环境中的 globals 和 locals 来执行该表达式。
返回值就是表达式的求值结果。

x = 1
print(eval('x+1'))  # 2

如果给出的源数据是个字符串，那么其前后的空格和制表符将被剔除。

print(eval('\t89840  \t '))  # 89840

eval()函数可将用逗号分隔的多个输入转为元组，并同步赋值给多个变量

width = eval(input())
length = 5
print(width * length)
# 4     # 输入整数，转换为整数
# 20    # 结果为整数
# 4.0   # 输入浮点数，转为浮点数
# 20.0  # 结果为浮点数

width, length = eval(input())  # 输入逗号分隔的两个数据
print(width * length)
# 4.25,80
# 340.0

a, b, c = eval(input())  # 输入逗号分隔的三个数据
s = (a + b + c) / 2
m = (s * (s - a) * (s - b) * (s - c)) ** 0.5
print(f"面积={m:.2f}")
# 3,4,5
# 面积=6.00

5. id()

id(object)
print(id(1024))  # 2296439367536

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

6. pow()

pow(base, exp[, mod])
print(pow(2, 10))             # 1024
print(pow(1998, 1997, 1999))  # 1998

print(pow(-2, 0.5))  # 可以对负数开偶次方
# (8.659560562354934e-17+1.4142135623730951j)

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。

7. round()

round(number[, ndigits])
print(round(3.6))
print(round(3.15,1))

返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。

8. abs()

abs(x)
print(abs(-5))      # 5
print(abs(-5.5))    # 5.5
print(abs(3 + 4j))  # 5.0

返回一个数的绝对值。 参数可以是整数、浮点数。 如果参数是一个复数，则返回它的模。
divmod()

divmod(a, b)
print(divmod(10, 3))    # (3, 1)
print(divmod(10.5, 3))  # (3.0, 1.5)

以两个（非复数）数字为参数，在作整数除法时，返回商和余数。
对于整数而言，结果与 (a // b, a % b) 相同。
对于浮点数则结果为(q, a % b)，其中 q 通常为 math.floor(a / b)，但可能比它小 1。
在任何情况下，q * b + a % b 都非常接近 a，
如果 a % b 非零，则结果符号与 b 相同，并且 0 <= abs(a % b) < abs(b)。

9. max()

max(iterable, *[, key, default])  # 参数是一个对象，要求是可迭代对象，如列表、元组、range等
print(max([56, 78, 98, 77]))      # 98

max(arg1, arg2, *args[, key])     # 多个对象
print(max(56, 78, 98, 77))        # 98

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最大元素，则此函数将返回第一个找到的。

10. min()

min(iterable, *[, key, default])
print(min([56, 78, 98, 77]))  # 56

min(arg1, arg2, *args[, key])
print(min(56, 78, 98, 77))    # 56

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最小元素，则此函数将返回第一个找到的。

11. sum()

sum(iterable, /, start=0)

从 start 开始自左向右对 iterable 的项求和并返回总计值。
iterable 的项通常为数字，而 start 值则不允许为字符串。
斜杠：“/”用来指明位于“/”前面的函数参数必须使用位置参数而非关键字参数的形式

score.csv

with open('../data/csv/score.csv','r',encoding='utf-8') as f:
    f.readline()
    ls = [list(map(int,x.strip().split(',')[1:])) for x in f]
print(ls)
# [[95, 96, 85, 63, 91], [75, 93, 66, 85, 88], [86, 76, 96, 93, 67], [88, 98, 76, 90, 89], [99, 96, 91, 88, 86]]

score = sum(ls[1:],[])
print(score)
# [75, 93, 66, 85, 88, 86, 76, 96, 93, 67, 88, 98, 76, 90, 89, 99, 96, 91, 88, 86]
print(sum(score))             # 2156
print(sum(score)/len(score))  # 86.24

能力点6：利用math模块计算

math是内置模块，不需要安装，直接使用
官方文档
https://docs.python.org/zh-cn/3/library/math.html

乘方、开方、对数运算等等，要实现这些运算，可以使用Python 中的Math模块。

导入库名

import <库名>

import math                   # 导入 math 模块,引用时函数名前加 math.

print(math.pi)                # 输出 math 模块中的 pi 值 3.141592653589793

导入库中的函数

# 导入库中的多个函数名（不带括号），函数名之间用逗号分隔
from <库名> import <函数名，函数名，...，函数名>

# 导入库中所有函数
from <库名> import *             # * 是通配符，代表全部函数

调用该库的函数时不需要指明函数所在库的名称

from math import pi,sqrt   # 导入math中的常数pi和sqrt()函数
# from math import *       # 导入math中所有函数,引用时直接引用函数名

print(pi)                  # 输出math中pi值3.141592653589793
print(sqrt(5))             # 输出 5 的平方根2.23606797749979

math.fabs(x)：以浮点数形式返回x的绝对值。
math.factorial(x)：返回x的阶乘，要求x为非负整数，x为负数或浮点数时返回错误
math.fsum()：返回浮点数迭代求和的精确值，避免多次求和导致精度损失。
math.gcd(integers)：返回给定的整数参数的最大公约数。如果参数之一非零，则返回值将是能同时整除所有参数的最大正整数。如果所有参数为零或无参数，则返回值为 0。在 3.9 版后添加了对任意数量的参数的支持，3.8版本或之前只支持两个参数。
math.lcm(integers)：返回给定的整数参数的最小公倍数。如果所有参数均非零，则返回值将是为所有参数的整数倍的最小正整数。如果参数之一为零，则返回值为 0。不带参数的 lcm() 返回 1。（3.9版新增函数）

print(math.gcd(88,44,22))        # 输出22
print(math.gcd(0,0))             # 输出0
print(math.lcm(44,22,5))         # 输出220
print(math.lcm())                # 输出1

math.prod(iterable, *, start=1)：计算输入的可迭代对象 iterable 中所有元素的积。积的默认起始值start为 1。当可迭代对象为空时，返回起始值。此函数特别针对数字值使用，并会拒绝非数字类型。

print(math.prod([1,2,3,4,5]))   # 120
print(math.prod([1,2,3,4,5], start=2))   # 240

math.floor(x)：返回不大于x的最大整数。
math.ceil(x)：返回不小于x的最小整数。

print(math.floor(9.8))           # 输出9
print(math.ceil(9.8))            # 输出10

math.exp(x)：返回ex
math.pow(x, y)：返回x的y次幂，结果为浮点数，pow(1.0, x) 和 pow(x, 0.0) 总返回1.0。
math.sqrt(x)：返回非负数 x 的平方根
math.isqrt(n)：返回非负整数 n 的整数平方根，即对 n 的实际平方根向下取整，或者相当于使得 a² ≤ n 的最大整数 a。对于某些应用来说，可以更适合取值为使得 n ≤ a² 的最小整数 a ，或者换句话说就是 n 的实际平方根向上取整。对于正数 n，这可以使用 a = 1 + isqrt(n - 1) 来计算。

print(math.exp(2))               # 输出 e 的平方，7.38905609893065
print(math.pow(2,3))             # 输出 2 的 3 次方 8.0
print(math.sqrt(100))            # 输出 100的正数平方根 10.0
print(math.isqrt(99))            # 输出 99的整数平方根 9
print(1 + math.isqrt(99 - 1))    # 输出不小于99的平方根的最小整数10

import math

print(math.sqrt(-2))  # 不能用于负数开偶次方
# ValueError: math domain error

# 涉及复数运算用cmath模块实现
import cmath

print(cmath.sqrt(-2))  # 1.4142135623730951j

# 或用幂运算 **  或pow()函数实现
print((-2) ** 0.5)  
print(pow(-2, 1/2))
# (8.659560562354934e-17+1.4142135623730951j)

math.log2(x)：返回以2为底的x的对数，其值通常比log(x, 2)值更精确
math.log10(x)：返回以10为底的x的对数，其值通常比log(x, 10)值更精确
math.cos(x)：返回 x的余弦函数,x为弧度
math.sin(x)：返回 x的正弦函数,x为弧度
math.atan(x)：返回 x的正切函数,x为弧度
math.hypot(x, y)：返回坐标(x,y)到原点（0，0）距离
math.dist(p, q)：返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列或可迭代对象的形式给出，两个点必须具有相同的维度。

print(math.cos(math.pi / 3))     # 输出 0.5000000000000001
print(math.sin(math.pi / 3))     # 输出 0.8660254037844386
print(math.hypot(3, 4))          # 输出 5.0

math.degrees(x)：弧度值转角度值
math.radians(x)：角度值转弧度值

print(math.degrees(math.pi / 4)) # 输出 45.0
print(math.radians(90))          # 输出 1.5707963267948966

math.pi：返回圆周率常数π值
math.e：返回自然常数e值

print(math.pi)                   # 输出 3.141592653589793
print(math.e)                    # 输出 2.718281828459045

math.comb(n, k)：返回不重复且无顺序地从 n 项中选择 k 项的方式总数。当 k <= n 时取值为 n! / (k! (n - k)!)；当 k > n 时取值为零。也称为二项式系数，因为他等价于表达式 (1 + x) * n 的多项式展开中第 k 项的系数。

print(math.comb(6, 3))           # 20

三角函数相关

math.sin(x)      # 返回 x 弧度的正弦值。
math.cos(x)       # 返回 x 弧度的余弦值。
math.tan(x)      # 返回 x 弧度的正切值。

math.asin(x)      # 返回以弧度为单位的 x 的反正弦值。 结果范围在 -pi/2 到 pi/2 之间。
math.acos(x)      # 返回以弧度为单位的 x 的反余弦值。 结果范围在 0 到 pi 之间。
math.atan(x)      # 返回以弧度为单位的 x 的反正切值。 结果范围在 -pi/2 到 pi/2 之间。.

math.dist(p, q)   # 返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列（或可迭代对象）的形式给出。
math.hypot(*coordinates)  # 返回欧几里得范数，sqrt(sum(x**2 for x in coordinates))。 这是从原点到坐标给定点的向量长度。
对于一个二维点 (x, y)，这等价于使用毕达哥拉斯定义 sqrt(x*x + y*y) 计算一个直角三角形的斜边。

math.degrees(x)  #将角度 x 从弧度转换为度数。
math.radians(x)  #将角度 x 从度数转换为弧度。

示例2.3 计算弓形的面积

从图中可知：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
AD = AB / 2 OA2 = AD2 + OD2 OD = OC – CD = OA – CD‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
代入后可得‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
OA = (AD2 + CD2 ) / (2 CD) sin(∠AOB / 2) = AD / OA‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
圆心角：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
∠AOB = 2 arcsin(AD / OA)‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
扇形AOB的面积为：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
area_of_sector = ∠AOB / (2π) π OA2‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
三角形 △AOB‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
area_of_triangle = 1 / 2 OA2 sin(∠AOB)‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
弓形面积为扇形AOB面积减去三角形△AOB面积之差：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
area_of_arch = area_of_sector - area_of_triangle

import math

# 输入弦长度，浮点数#
AB = float(input())  # 弦长度

# 输入弓高度，浮点数#
CD = float(input())  # 弓高度

# 计算半弦长#
AD = AB / 2

# 计算半径#
OA = (AD ** 2 + CD ** 2) / (2 * CD)

# 计算圆心角#
AOB = 2 * math.asin(AD / OA)

# 计算拱形所在扇形的面积#
area_of_sector = AOB / (math.pi * 2) * math.pi * OA ** 2

# 计算三角形面积#
area_of_triangle = 1 / 2 * OA * OA * math.sin(AOB)

# 计算弓形面积#
area_of_arch = area_of_sector - area_of_triangle

# 在两行中分别输出半径和弓形面积#
print(f'{OA:.2f}')
print(f'{area_of_arch:.2f}')

第2章 数值类型.pptx