6.Python3标准库--数学运算

时间:2022-07-01 07:47:20
'''
作为一种通用的变成语言,Python经常用来解决数学问题。它包含一些用于管理整数和浮点数的内置类型,这很适合完成一般应用中可能出现的基本数学运算。
而标准库中包含一些用于满足更高级需求的模块。
Python的内置浮点数在底层C语言中是double类型,对于大多数数学运算需求的程序来说,这已经足够精确。
但是如果需要非整数值更为精确的表示,那么decimal和fractions模块会很有用。小数和分数值的算术运算可以保证精度,但是不如原生float的运算速度快

random模块则包含了一个均匀分布的伪随机数生成器,还提供了一些函数用于模拟很多常用的非均匀分布

math模块则包含一些高级数学函数的快速实现,如对数、三角函数。这个模块对原生平台C库中常见的IEEE函数提供了全面的补充
'''

  

(一)decimal:定点数和浮点数的数学运算

1.Decimal

import decimal
'''
小数值被表示为Decimal类的实例。
构造函数取一个整数或字符串作为参数。
在使用浮点数创建Decimal之前,可以先将浮点数转换为一个字符串,以使调用者能够显示地处理值的位数,因为如果使用硬件浮点数表示则可能无法准确的描述。
或者,类方法from_float可以把一个浮点数转换为精确的小数表示
'''
print(f"{'input':<25} {'output':<25}")
print("-"*25, "-"*25)

# integer
print(f"{5:<25} {decimal.Decimal(5):<25}")
# string
print(f"{'3.14':<25} {decimal.Decimal('3.14'):<25}")
# float

print(f"{3.14:<25} {decimal.Decimal.from_float(3.14)}")
'''
input                     output
------------------------- -------------------------
5                         5
3.14                      3.14
3.14                      3.140000000000000124344978758017532527446746826171875
'''

# Decimal还可以使用元组创建,但是不太方面,这里不推荐了。

  

2.格式化

import decimal
'''
Decimal对应Python的字符串格式化协议,使用与其他数值类型一样的语法和选项
'''
d = decimal.Decimal(1.1)
print(f"{d:.1f}")  # 1.1
print(f"{d:.2f}")  # 1.10
print(f"{d:.10f}")  # 1.1000000000

  

3.算术运算

import decimal
'''
Decimal重载了简单的算术操作符,所以可以采用与内置数值类型相同的方法来处理Decimal实例
'''
a = decimal.Decimal("5.1")
b = decimal.Decimal("3.14")
c = 4
d = 3.14
print(repr(a))  # Decimal('5.1')
print(repr(b))  # Decimal('3.14')
print(repr(c))  # 4
print(repr(d))  # 3.14

print(f"a+b = {a+b}")  # a+b = 8.24
print(f"a-b = {a-b}")  # a-b = 1.96
print(f"a*b = {a*b}")  # a*b = 16.014
print(f"a/b = {a/b}")  # a/b = 1.624203821656050955414012739
# 对Decimal实例进行运算,得到的仍是一个Decimal对象
print(type(a*b))  # <class 'decimal.Decimal'>

try:
    a + d
except TypeError as e:
    print(e)  # unsupported operand type(s) for +: 'decimal.Decimal' and 'float'

  

4.特殊值

import decimal
'''
除了期望的特殊值,Decimal还可以表示很多特殊值,包括正负无穷大值、不是一个数(NAN)和0
'''
for value in ["Infinity", "NAN", "0"]:
    print(decimal.Decimal(value), decimal.Decimal("-"+value))
    '''
    Infinity -Infinity
    NaN -NaN
    0 -0
    '''

print("Infinity+1:", decimal.Decimal("Infinity")+1)  # Infinity+1: Infinity
print("-Infinity+1:", decimal.Decimal("-Infinity")+1)  # -Infinity+1: -Infinity

print(decimal.Decimal("NAN") == decimal.Decimal("Infinity"))  # False
print(decimal.Decimal("NAN") != decimal.Decimal("Infinity"))  # True
'''
与无穷大值相加减总会返回无穷大值,与NAN比较相等性总会返回False,比较不等性则返回True。
与NAN比较大小来确定排序是未定义的,这回导致一个错误
'''

# 除此之外math和numpy当中也有这种功能
import math, numpy as np
print(math.inf, math.nan)  # inf nan
print(np.inf, np.nan)  # inf nan

print(math.inf == math.inf, math.inf is math.inf)  # True True
# 可以看到nan有点特殊,即便是同一个对象is成立,但是==不成立。
print(math.nan == math.nan, math.nan is math.nan)  # False True

  

(二)fractions:有理数

'''
Fraction类基于numbers模块中Rational定义的API来实现有理数的数值运算
'''

  

1.创建Fraction实例

import fractions
'''
与decimal模块类似,可以采用多种方式创建新值。一种简便的方式是由单独的分子和分母值来创建
'''
for n, d in [(1, 2), (2, 4), (3, 6)]:
    f = fractions.Fraction(n, d)
    print(f"{n} / {d} = {f}")
    '''
    1 / 2 = 1/2
    2 / 4 = 1/2
    3 / 6 = 1/2
    '''

# 还可以使用字符串方式来创建
# 会自动解析这个字符串,找出分子和分母值
for s in ["1/2", "2/4", "3/6"]:
    f = fractions.Fraction(s)
    print(f"{s} = {f}")
    '''
    1/2 = 1/2
    2/4 = 1/2
    3/6 = 1/2
    '''

# 字符串还可以使用更常用的小数或浮点数记法,即用一个小数点分隔的一系列数字。能够由float()解析而且不表示NAN或者无穷大值的所有字符串都支持
for s in ["0.5", "1.5", "2.0", "5e-3"]:
    f = fractions.Fraction(s)
    print(f"{s} = {f}")
    '''
    0.5 = 1/2
    1.5 = 3/2
    2.0 = 2
    5e-3 = 1/200
    '''

# 此外还可以使用Decimal类创建
import decimal
values = [
    decimal.Decimal("0.1"),
    decimal.Decimal("0.5"),
    decimal.Decimal("1.5"),
    decimal.Decimal("2.0")
]
for v in values:
    print(f"{v} {fractions.Fraction(v)}")
    '''
    0.1 1/10
    0.5 1/2
    1.5 3/2
    2.0 2
    '''

# 此外得到的都是Fraction对象
print(type(fractions.Fraction("0.5")))  # <class 'fractions.Fraction'>

  

2.算术运算

import fractions
'''
一旦分数被实例化,就可以在数学表达式中使用了
'''
f1 = fractions.Fraction("1/2")
f2 = fractions.Fraction(3, 4)
print(f"{f1} + {f2} = {f1 + f2}")  # 1/2 + 3/4 = 5/4
print(f"{f1} - {f2} = {f1 - f2}")  # 1/2 - 3/4 = -1/4
print(f"{f1} * {f2} = {f1 * f2}")  # 1/2 * 3/4 = 3/8
print(f"{f1} / {f2} = {f1 / f2}")  # 1/2 / 3/4 = 2/3

  

3.近似值

import fractions
import math
'''
Fraction有一个很有用的特性,即能够将一个浮点数转换为一个近似的有理数值
'''

f_pi = fractions.Fraction(str(math.pi))
print(f_pi)  # 3141592653589793/1000000000000000
for i in [1, 6, 11, 60, 70, 90, 100]:
    limited = f_pi.limit_denominator(i)
    print(f"{i} {limited}")
    '''
    1 3
    6 19/6
    11 22/7
    60 179/57
    70 201/64
    90 267/85
    100 311/99
    '''

  

(三)random:伪随机数生成器

'''
random模块基于Mersenne Twister算法提供了一个快速伪随机数生成器。
原先开发这个生成器是为了向蒙特卡洛模拟生成输入,Mersenne Twister算法会生成大周期近均匀分布的数,因此适用于大量不同类型的应用
'''

  

1.生成随机数

import random

'''
random返回一个0到1之间的随机浮点数
'''
print(random.random())  # 0.254811057329168
print(random.random())  # 0.7395548455074491
print(random.random())  # 0.505764048975116
print(random.random())  # 0.4639293410664217

# random的范围是0到1,如果我想指定范围呢?可以使用uniform,说到uniform,我就想起了uniform temptation。就想起了孙悟空那豹纹小短裙,想起了今年下半年文体两开花
# 生成的规则是 2+(4-2)*random(), min + (max - min)*random()
print(random.uniform(2, 4))  # 3.4563486365870606

  

2.指定种子

import random

'''
每次重复执行的时候,生成的结果都不一样。
因此可以指定种子,只要种子一样,那么每次生成的结果都是一样的
'''
print(random.random())
print(random.random())
'''
$ python 3.random.py
0.6968598797532435
0.5403043133943518

$ python 3.random.py
0.7498812800384731
0.08841963718934376
'''

# 当我指定种子之后
random.seed(666)
print(random.random())
print(random.random())
'''
$ python 3.random.py
0.45611964897696833
0.9033231539802643

$ python 3.random.py
0.45611964897696833
0.9033231539802643
'''
# 可以看到当我重新指定种子的时候,不管执行多少次结果都是一样的 

3.保存状态

import random

'''
几乎不用
'''

  

4.随机整数

import random

'''
random生成浮点数,可以再转化为整数,不过直接使用randint生成整数会更方便
'''
print(random.randint(1, 3))  # 1
print(random.randint(1, 3))  # 2
print(random.randint(1, 3))  # 3

print(random.randint(-5, -3))  # -4
print(random.randint(-5, -3))  # -5
print(random.randint(-5, -3))  # -4
# 可以看到randint接收的值为两个,分别是闭区间的两端。可以是正数也可以是负数,但是左边要小于右边。

# 还有一个randrange方法,前两个参数和randint一样,但是randrange还可以接收第三个参数,表示步长
# 从1到8里面随机选择,但是步长为2,也就是说,只可能选到1 4(1+3) 7(1+3+3)这三个值
# 注意,如果不指定第三个参数,那么步长默认为1,并且是不包含右短点的。也就是说,即便步长为1,也是不可能随机到8这个数的
print(random.randrange(1, 8, 3))  # 4
print(random.randrange(1, 8, 3))  # 7
print(random.randrange(1, 8, 3))  # 1

  

5.选择随机元素

import random

'''
随机数生成器有一种常见用法,即从一个枚举值序列中选择元素,即使这些值并不是数字。
random模块包含一个choice函数,可以从一个序列中随机选择。
'''
girls = ["mashiro", "satori"]
print(random.choice(girls))  # mashiro

# 此外我们还可以验证大数定理
'''
大数定理:用个人的大白话解释,就是我们知道一个事物出现的概率是固定的,比如说等于A,但是由于次数较少,可能会出现不同的结果。但是随着实验次数的增加,比例越来越趋近A

就拿抛硬币来说,出现正面的概率是0.5,这是肯定的。但是由于我们只抛了3次,恰好都是正面或者都是反面,所以概率就变成1或者0了。
但是随着次数的增加,比如我抛个十万次,那么最终出现正面和出现反面的次数都是接近5万次的,也就是说出现的几率应该越来越趋近于0.5
'''
outcomes = {"正面": 0, "反面": 0}
sides = list(outcomes.keys())

for i in range(1, 201):
    outcomes[random.choice(sides)] += 1
    if i % 10 == 0:
        print(f"抛了{i}次之后--》")
        print(f"出现正面的次数:{outcomes['正面']},对应比率:{outcomes['正面'] / (outcomes['正面'] + outcomes['反面'])}")
        print(f"出现反面的次数:{outcomes['反面']},对应比率:{outcomes['反面'] / (outcomes['正面'] + outcomes['反面'])}")
        print("-"*20)
'''
抛了10次之后--》
出现正面的次数:6,对应比率:0.6
出现反面的次数:4,对应比率:0.4
--------------------
抛了20次之后--》
出现正面的次数:12,对应比率:0.6
出现反面的次数:8,对应比率:0.4
--------------------
抛了30次之后--》
出现正面的次数:15,对应比率:0.5
出现反面的次数:15,对应比率:0.5
--------------------
抛了40次之后--》
出现正面的次数:22,对应比率:0.55
出现反面的次数:18,对应比率:0.45
--------------------
抛了50次之后--》
出现正面的次数:27,对应比率:0.54
出现反面的次数:23,对应比率:0.46
--------------------
抛了60次之后--》
出现正面的次数:31,对应比率:0.5166666666666667
出现反面的次数:29,对应比率:0.48333333333333334
--------------------
抛了70次之后--》
出现正面的次数:36,对应比率:0.5142857142857142
出现反面的次数:34,对应比率:0.4857142857142857
--------------------
抛了80次之后--》
出现正面的次数:39,对应比率:0.4875
出现反面的次数:41,对应比率:0.5125
--------------------
抛了90次之后--》
出现正面的次数:48,对应比率:0.5333333333333333
出现反面的次数:42,对应比率:0.4666666666666667
--------------------
抛了100次之后--》
出现正面的次数:52,对应比率:0.52
出现反面的次数:48,对应比率:0.48
--------------------
抛了110次之后--》
出现正面的次数:59,对应比率:0.5363636363636364
出现反面的次数:51,对应比率:0.4636363636363636
--------------------
抛了120次之后--》
出现正面的次数:63,对应比率:0.525
出现反面的次数:57,对应比率:0.475
--------------------
抛了130次之后--》
出现正面的次数:66,对应比率:0.5076923076923077
出现反面的次数:64,对应比率:0.49230769230769234
--------------------
抛了140次之后--》
出现正面的次数:69,对应比率:0.4928571428571429
出现反面的次数:71,对应比率:0.5071428571428571
--------------------
抛了150次之后--》
出现正面的次数:75,对应比率:0.5
出现反面的次数:75,对应比率:0.5
--------------------
抛了160次之后--》
出现正面的次数:79,对应比率:0.49375
出现反面的次数:81,对应比率:0.50625
--------------------
抛了170次之后--》
出现正面的次数:85,对应比率:0.5
出现反面的次数:85,对应比率:0.5
--------------------
抛了180次之后--》
出现正面的次数:88,对应比率:0.4888888888888889
出现反面的次数:92,对应比率:0.5111111111111111
--------------------
抛了190次之后--》
出现正面的次数:94,对应比率:0.49473684210526314
出现反面的次数:96,对应比率:0.5052631578947369
--------------------
抛了200次之后--》
出现正面的次数:100,对应比率:0.5
出现反面的次数:100,对应比率:0.5
--------------------
'''
# 可以看到正反面出现了次数越来越接近,最后一次居然整好一边一半,真给面子

  

6.排列

import random

'''
shuffle,英文有洗牌的意思,顾名思义,就是讲一个序列进行打乱操作。
'''
l = list(range(20))
random.shuffle(l)
# 这个函数是没有返回值的,实在序列本身上进行操作的
print(l)  # [17, 11, 8, 13, 6, 7, 19, 1, 15, 9, 12, 4, 3, 0, 18, 2, 10, 5, 16, 14]

try:
    t = (1, 2, 3, 4, 5)
    print(random.shuffle(t))
except TypeError as e:
    print(e)  # 'tuple' object does not support item assignment
# 可以看到由于元组是不可修改的,但shuffle又是在对象本身上进行操作,因此结果是会报错的

  

7.采样

import random

'''
很多模拟需要从大量输入值中得到随机样本,sample函数可以生成无重复值得同样本,并且不会修改原来的序列。
'''
l = list(range(100))
# 接收两个参数,第一个是序列,第二个是选择的样本个数。
# 样本的个数不可以超过序列里面元素的个数
print(random.sample(l, 10))  # [13, 98, 18, 62, 75, 43, 32, 15, 10, 83]

  

8.多个并发生成器

import random

'''
除了模块级函数,rnadom还包括一个Random类以管理多个随机数生成器的内部状态。
之前介绍的所有函数都可以作为Random实例的方法得到,并且每个实例都可以被单独初始化和使用,而不会干扰到其他实例返回的值
'''
r1 = random.Random()
r2 = random.Random()
for _ in range(3):
    print(f"{r1.random():.3f} {r2.random():.3f}")
'''
0.201 0.076
0.954 0.065
0.742 0.544
'''

r3 = random.Random(100)
r4 = random.Random(100)
for _ in range(3):
    print(f"{r3.random():.3f} {r4.random():.3f}")
'''
0.146 0.146
0.455 0.455
0.771 0.771
'''

  

9.SystemRandom

import random

'''
有些操作系统提供了一个随机数生成器,可以访问更多能引入生成器的信息源。
random通过SystemRandom类提供了这个特性,该类与Random的API相同,只不过是使用os.urandom()生成值,该值会构成所有其他算法的基础
'''

r1 = random.SystemRandom()
r2 = random.SystemRandom()
for _ in range(3):
    print(f"{r1.random():.3f} {r2.random():.3f}")
'''
0.497 0.360
0.304 0.208
0.158 0.568
'''

r3 = random.SystemRandom(1000)
r4 = random.SystemRandom(1000)
for _ in range(3):
    print(f"{r3.random():.3f} {r4.random():.3f}")
'''
0.725 0.532
0.030 0.489
0.457 0.165
'''

# 可以看到即便设置了随机种子,也是不管用的,因为其随机性来自系统,而不是来自软件状态。

# 顺便看看os.urandom()是个什么东西
import os
# 传入一个整数,返回包含相应整数个数的bytes对象
print(os.urandom(20))  # b"\xb4\xe8\xc9\xe0'\x1c\xe8h\xfag\x19\xc8\xb8\xb4\xc3KXJ!\x14"

  

(四)math:数学函数

import math

'''
math模块实现了正常情况下原生平台C库中才有的很多专用IEEE函数,可以使用浮点值完成复杂的数学运算,包括对数和三角函数运算
'''

  

1.特殊常量

import math

'''
很多数学运算依赖于一些特殊的常量。math包含有pi、e、nan(不是一个数)和infinity(无穷大)的值
'''
print(math.pi)  # 3.141592653589793
print(math.e)  # 2.718281828459045
print(math.nan)  # nan
print(math.inf)  # inf
# pi和e的精度仅受平台的浮点数C库限制

  

2.测试异常值

import math

'''
浮点数计算可能会导致两种类型的异常值。第一种是inf(无穷大),当用double存储一个浮点值,而该值会从一个具有很大绝对值的值上溢出时,就会出现这个异常值
'''
print(f"{'e':^3} {'x':^6} {'x**2':^6} {'isinf':^6}")
print(f"{'':-^3} {'':-^6} {'':-^6} {'':-^6}")
for e in range(0, 201, 20):
    x = 10.0 ** e
    y = x * x
    print(f"{e:>3} {x:<6g} {y:<6g} {bool(math.isinf(y))}")
'''
 e    x     x**2  isinf
--- ------ ------ ------
  0 1      1      False
 20 1e+20  1e+40  False
 40 1e+40  1e+80  False
 60 1e+60  1e+120 False
 80 1e+80  1e+160 False
100 1e+100 1e+200 False
120 1e+120 1e+240 False
140 1e+140 1e+280 False
160 1e+160 inf    True
180 1e+180 inf    True
200 1e+200 inf    True
'''
# 当这个例子中的指数变得足够大时,x的平方无法再存放于一个double中,这个就会被记录为无穷大
# 不过,并不是所有浮点数都会导致inf值。具体地,用浮点值计算一个指数时,会生成OverFlowError而不是保留inf结果
try:
    10.0 ** 400
except OverflowError as e:
    print(e)  # (34, 'Result too large')
# 这种差异是由C和Python所用库中的实现差别造成的。

# 无穷大值得除法运算未定义。将一个数除以无穷大值的结果是nan(不是一个数)
x = 10.0**200 * 10.0**200
y = x / x
print("x =", x)  # x = inf
print("isnan(x) =", math.isnan(x))  # isnan(x) = False
print("y =", y)  # y = nan
print("isnan(y) =", math.isnan(y))  # isnan(y) = True
'''
x是无穷大,由于无穷大的除法未定义,那么即使是x/x,得到的也并不是1,而是nan
注意:nan不等于任何值,甚至也不等于它自身,所以要检查nan,要使用isnan()
'''
print(y == math.nan)  # False
print(y is math.nan)  # False
print(math.nan == math.nan)  # False
print(math.nan is math.nan)  # True
print(y == y)  # False
print(y is y)  # True
'''
因此nan还是比较特殊的,即使同一个nan也不相等,但使用is会打印True,表示是同一个对象。
但是y和math.nan虽然都是nan,但是是不同的nan,因此==和is都返回True
'''
# 因此最好使用math.isnan
print(math.isnan(y))  # True
# 再来看看numpy和pandas
import numpy as np
import pandas as pd
# 可以看到依旧返回True
print(math.isnan(np.nan))  # True
print(np.isnan(math.nan))  # True
print(np.isnan(y))  # True
print(pd.isna(np.nan))  # True
print(pd.isna(math.nan))  # True
# 因此使用isnan函数来对nan判断最为合适

# 此外还有一个isfinite函数检查是普通的值还是inf或者nan
# infinity表示无穷,那么finite表示有穷。isfinite表示是否有穷,是不是一个有限的数字
# inf肯定不是了,至于nan,它根本就不是一个数字,当然更不是了。
# 所以isfinite(inf)和isfinite(nan)返回False,其它的返回True
print(math.isfinite(x))  # False
print(np.isfinite(x))  # False
print(math.isfinite(100))  # True
print(np.isfinite(100))  # True

  

3.比较

import math

'''
浮点数的比较容易出错,每一个计算都可能由于数值表示而引入误差。
isclose函数使用一种稳定的算法来尽可能的减少这种误差,同时完成绝对比较和相对比较
'''
a = 1.1
b = 1.21
# 首先isclose函数的前两个参数是要比较的两个数字,后面的两个参数一个是rel_tol,一个是abs_tol
# 先来看看abs_tol,tol表示tolerate容忍,表示能容忍的最大极限。举个栗子
print(math.isclose(a, b, abs_tol=0.2))  # True
print(math.isclose(a, b, abs_tol=0.1))  # False
'''
asb_tol=0.2:表示我最多能容忍a和b之前差0.2,小于等于0.2,我认为是True,也就是两个数是相等的。超过0.2,不忍了,返回False
而我们的a和b之前差0.11,所以0.2的时候返回True,0.1的时候返回False,因为0.11小于没有超过容忍极限0.2,但超过了容忍极限0.1
'''
# 了解abs_tol那么rel_tol也就好理解了,这个是与a、b的值有关系的
# abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
# 如果不传入abs_tol,那么表示a、b差的绝对值要小于等于a、b之间较大的那个数再乘以rel_tol。
# 如果传入abs_tol,那么再和abs_tol比较,选出较大的做为容差,判断abs(a-b)是否小于等于这个容差
# 因此rel_tol也叫相对容差,abs_tol也叫绝对容差

# 如果只传入a、b的话,那么rel_tol默认为1e-9,即只要abs(a-b)小于等于a、b之间绝对值较大的那个数的绝对值再乘上rel_tol,那么结果就认为是True

  

4.将浮点值转换为整数

import math

'''
math模块中有三个函数用于将浮点值转换为整数。这三个函数分别采用不同的方法,适用于不同的场合
最简单的是trunc,其会截断小数点之后的数字,只留下整数部分,说白了和int的作用是一样的。
floor向下取整,2.5--》2
ceil向上取整,2.5--》3
'''
val = 2.85
print(math.trunc(val), type(math.trunc(val)))  # 2 <class 'int'>
print(math.floor(val), type(math.floor(val)))  # 2 <class 'int'>
print(math.ceil(val), type(math.ceil(val)))  # 3 <class 'int'>
# 最后得到的结果都是int类型

  

5.浮点值的其他表示

import math

'''
modf取一个浮点值,并返回一个元组,其中包含这个输入值得小数和整数部分。
注意是小数和整数,不是整数和小数。这与我们平常的思维比较相反,因为我们做除法一般是先得到商,也就是整数部分,然后才得到余数也就是小数部分
'''
# 可以看到,即便传入整数,也会自动地将其转化为浮点数
print(math.modf(10))  # (0.0, 10.0)

print(math.modf(2.888431))  # (0.8884310000000002, 2.0)
'''
结果可能不太一样,但这是没办法的事情,不光是Python,所有语言都会存在这个问题。
比如golang,我们用golang的math库,计算直角三角形的边长。两个直角边是3和4,那么求斜边
手动计算,很容易知道是5,但是机器计算的话,那么在golang中有时会得到4.999999,那么取整之后就变成了4。
因此浮点数会有误差,这是无法避免的
'''

# frexp返回一个浮点数的位数和指数
'''
什么意思呢?我先拿整数为例子,比如20
先找一个数e,使得2**e > 20并且2**(e-1) < 20, 显然这里e=5,因为2**5=32>20, 2**4=16<20
然后找一个数m,使得m * 2**e=20,这里m=20/ 2** 5 = 20 / 32 = 5/8 = 0.625
返回m和e。
综上所述:frexp(20)-->(0.625, 5)
'''
print(math.frexp(20))  # (0.625, 5)
# ldexp和frexp是一对,返回一个浮点数
# 2**5 * 0.625 = 20.0
print(math.ldexp(0.625, 5))  # 20.0

'''
个人不知道,这几个函数会有什么用,反正我是觉得没有什么卵用
'''

  

6.正号和负号

import math

'''
一个数的绝对值就是不带正负号的本值。使用fabs函数可以计算一个浮点数的绝对值
'''
print(math.fabs(-1.1), abs(-1.1))
print(math.fabs(-0.0), abs(-0.0))
print(math.fabs(1.0), abs(1.0))
print(math.fabs(1.1), abs(1.1))
'''
1.1 1.1
0.0 0.0
1.0 1.0
1.1 1.1
'''
# 感觉和abs没有太大区别

# copysign表示拷贝符号,copysign(a, b), 将b的符号拷贝到a中
# 注意与a的符号无关,如果b为正,结果相当于abs(a) * 1, 结果b为负,结果相当于abs(a) * -1
print(math.copysign(-1.1, 5))  # 1.1
print(math.copysign(-1.1, -5))  # -1.1

  

7.常用计算

import math

'''
在二进制浮点数内存中表示精确值很有难度。有些值无法准确地表示,而且如果通过反复计算来处理一个值,那么计算越频繁就越容易引入表示误差。
math包含一个函数来计算一系列浮点数的和,它使用一种高效的算法来尽量减少这种误差。
'''
values = [0.1] * 10
s = 0.0
for v in values:
    s += v
print("for-loop:", s)  # for-loop: 0.9999999999999999
print("sum:", sum(values))  # for-loop: 0.9999999999999999
print("fsum:", math.fsum(values))  # fsum: 1.0
# 由于0.1不能精确表示为一个浮点数,因此在计算总和的时候会引入误差,但是可以使用fum来避免这种情况

# factorial用于计算阶乘
print(math.factorial(5))  # 120

# gamma、lgamma不再介绍,感觉没啥用

# fmod,之前好像介绍一个modf
print(math.modf(2.2))  # (0.20000000000000018, 2.0)
# 相当于取余,%
print(math.fmod(8, 3))  # 2.0
print(int.__mod__(8, 3))  # 2

# gca函数,可以用来查找两个数的最大公约数
print(math.gcd(20, 15))  # 5

  

8.指数和对数

import math

'''
指数生长曲线在经济学、物理学和其他科学中经常出现。Python有一个内置的**幂运算符。
不过,如果需要将一个可调用函数作为另一个函数的参数,那么可能需要用到pow
'''
print(2**5, math.pow(2, 5))  # 32 32.0
print(3**4, math.pow(3, 4))  # 81 81.0

# 1的任何次幂都返回1.0,任何值得指数为0也返回1.0
# 对于nan,大多数运算返回nan,如果值小于1,那么pow会计算一个根
# 如果指数是1/2,就变成了求平方根,这也有一个专门的函数叫sqrt,因为平方根用的很频繁
print(math.pow(9, 1/2))  # 3.0
print(math.sqrt(9))  # 3.0
# 如果是求负数的平方根,那么会报错,因为涉及到复数,可以使用cmath模块,c:complex
try:
    print(math.sqrt(-9))
except ValueError as e:
    print(e)  # math domain error
import cmath
# cmath和math模块的api基本上是一只的,只不过cmath是用来处理复数的,如果我传入实数呢,比如33,那么会解释器自动在结尾加上0j,变成33+0j,注意在Python中,复数的虚部用j表示,不是i
print(cmath.sqrt(-9))  # 3j
# 那我想手动创建复数怎么办?直接创建就好啦
c = 3 + 4j
print(f"实部:{c.real},虚部:{c.imag},复数本身:{c},共轭复数:{c.conjugate()}")  # 实部:3.0,虚部:4.0,复数本身:(3+4j),共轭复数:(3-4j)
print(f"模:{abs(c)}")  # 模:5.0

# 对数,log里面接收两个参数,第一个参数传计算的值,表示要计算谁的对数。第二个参数表示底数,以谁为底,如果不传,默认为e
print(math.log(math.e))  # 1.0
print(math.log(9, 3))  # 2.0
print(math.log(0.5, 2))  # -1.0

# 对数还有两个常用变形,功能类似,但是会更精确
# log10(x) <===> log(x, 10)
# log2(x) <===> log(x, 2)
print(math.log10(100))  # 2.0
print(math.log2(32))  # 5.0

# exp,用于计算指数函数,exp(x) <==> e**x
print(math.e ** 2)  # 7.3890560989306495
print(math.pow(math.e, 2))  # 7.3890560989306495
print(math.exp(2))  # 7.38905609893065

  

9.角

import math

'''
尽管我们每天讨论角是更常用的是度,但弧度才是科学和数学领域中度量角度的标准单位。
弧度是在圆心相交的两条线所构成的角,其终点落在圆的圆周上,终点之间相距一个弧度。
圆周长计算为2πr,所以弧度与π之间存在一个关系,要把度转化为弧度,可以使用函数radians
要把弧度转化为度,使用函数degrees
'''
# 在半径为1的情况下,周长是2π,整个圆是360度,所以degree/360 * 2π便是弧度
print(math.radians(180))  # 3.141592653589793
print(math.degrees(math.pi))  # 180.0

  

10.三角函数

import math

'''
概念不介绍了,上过高中应该都会的。
'''
# 注意的是要传入弧度,比如我传入30,那么这里的30是弧度,不是角度,所以结果不是二分之一
print(math.sin(30))  # -0.9880316240928618
print(math.sin(math.pi / 6))  # 0.49999999999999994

print(math.cos(0))  # 1.0
print(math.tan(0))  # 0.0
# 可以看做是无穷大
print(math.tan(math.pi / 2))  # 1.633123935319537e+16

# 已知点(x, y),那么点[(0, 0), (x, 0), (0, y)]会构成一个直角三角形,求斜边长度,可以使用函数hypot来计算
print(math.hypot(3, 4))  # 5.0
# 这不就是(x**2 + y **2)**(1/2)吗

# 除此之外还有反三角函数
print(math.asin(0.5))  # 0.5235987755982989
# 大致结果为π/2
print(math.atan(math.inf))  # 1.5707963267948966

  

11.双曲函数

12.特殊函数

import math

'''
不做介绍,没啥乱用。
真要用的话,可以使用numpy,更牛逼的方法可以使用scipy
'''

  

(五)statistics:统计计算

''''
statistics模块实现了很多常用的统计公式,允许使用Python的各种数值类型(int, float, Decimal,Fraction)来完成高级计算
'''

  

1.平均值

import statistics
'''
共支持3种形式的平均值:均值(mean),中值或中位数(median),以及众数(mode)
'''
# 可以使用mean计算算术平均值
data = [1, 2, 3, 4, 4, 4, 5, 6]
print(statistics.mean(data))  # 3.625
# 对于整数和浮点数,返回的总是浮点数,对于Decimal和Fraction,返回的类型和输入的类型相同

# 可以使用mode计算一个数据集中的最常见的数据点,也就是众数
print(statistics.mode(data))  # 4
# 由于mode是把输入处理为一个离散值集合,然后统计出现次数,所以对于mode函数来说,输入并不一定非要是数字
print(statistics.mode(["a", "xx", "xx"]))  # xx

# 可以使用median计算中位数
'''
如果是序列的个数是奇数,很好办,就是中间的那一个。
但如果个数是偶数,那么中间值会有两个,median会取两者的平均值
除了median还有median_high,median_low,显然这是针对个数是偶数的。median_high会取两者中的较大值,median_low会取两者中的较小值
'''
data = [1, 2, 3, 4]
print(statistics.median(data))  # 2.5
print(statistics.median_high(data))  # 3
print(statistics.median_low(data))  # 2

  

2.方差

import statistics
'''
统计使用两个值来描述一个集合相对于均值的离散程度。
方差:各个值与平均值之差的平方的平均。
标准差:方差的平方根。
如果方差大:说明数据集不稳定,离散程度高。
如果方差小:说明数据集稳定,离散程度低
显然:[1, 10]的方差要大于[2, 9]大于[5, 6]
'''

data = [4, 5, 3, 3, 4, 2, 5, 6]
print(statistics.variance(data))  # 1.7142857142857142
print(statistics.stdev(data))  # 1.3093073414159542