1 2 3 4 5 6 7 8 9 10 ''' 作为一种通用的变成语言，Python经常用来解决数学问题。它包含一些用于管理整数和浮点数的内置类型，这很适合完成一般应用中可能出现的基本数学运算。 而标准库中包含一些用于满足更高级需求的模块。 Python的内置浮点数在底层C语言中是double类型，对于大多数数学运算需求的程序来说，这已经足够精确。 但是如果需要非整数值更为精确的表示，那么decimal和fractions模块会很有用。小数和分数值的算术运算可以保证精度，但是不如原生float的运算速度快   random模块则包含了一个均匀分布的伪随机数生成器，还提供了一些函数用于模拟很多常用的非均匀分布   math模块则包含一些高级数学函数的快速实现，如对数、三角函数。这个模块对原生平台C库中常见的IEEE函数提供了全面的补充 '''

　　

（一）decimal：定点数和浮点数的数学运算

1.Decimal

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 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.格式化

1 2 3 4 5 6 7 8 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.算术运算

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 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.特殊值

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 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：有理数

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

　　

1.创建Fraction实例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 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.算术运算

1 2 3 4 5 6 7 8 9 10 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.近似值

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 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：伪随机数生成器

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

　　

1.生成随机数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 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.指定种子

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 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.保存状态

1 2 3 4 5 import  random   ''' 几乎不用 '''

　　

4.随机整数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 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.选择随机元素

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 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.排列

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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.采样

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

　　

8.多个并发生成器

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 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：数学函数

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

　　

1.特殊常量

1 2 3 4 5 6 7 8 9 10 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.测试异常值

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 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.比较

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 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.将浮点值转换为整数

1 2 3 4 5 6 7 8 9 10 11 12 13 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.浮点值的其他表示

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 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.正号和负号

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 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.常用计算

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 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.指数和对数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 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.角

1 2 3 4 5 6 7 8 9 10 11 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.三角函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 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.特殊函数

1 2 3 4 5 6 import  math   ''' 不做介绍，没啥乱用。 真要用的话，可以使用numpy，更牛逼的方法可以使用scipy '''

　　

（五）statistics：统计计算

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

　　

1.平均值

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 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.方差

1 2 3 4 5 6 7 8 9 10 11 12 13 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

　　

转载于:https://www.cnblogs.com/valorchang/p/11395728.html