master
/ 2.4常用数学运算函数.ipynb

2.4常用数学运算函数.ipynb @master — view markup · raw · history · blame

Notebook

常用数学运算函数

Python 内置了一系列与数字运算相关的函数可以直接使用，如下表所示

函数 功能描述
abs(x) 返回 x的绝对值，x可以是整数或浮点数；当x为复数时返回复数的模
divmod(a, b) (a // b, a % b)，以整数商和余数的二元组形式返回
pow(x, y[, z]) 返回 x的y次幂，当z存在时，返回 x的y次幂对z取余
round(number[, n]) 返回number舍入到小数点后n位精度的值。当小数点最后几位都是0时，输出其最短表示。当number是整数时，直接返回整数本身
max(iterable)
max(arg1,arg2,…)		 从多个参数或一个可迭代对象中返回其最大值，有多个最大值时返回第一个。
min(iterable)
min(arg1,arg2,…)		 从多个参数或一个可迭代对象中返回其最小值，有多个最小值时返回第一个。
sum(iterable, start=0) 从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。
eval(source) 计算指定表达式的值source：必选参数，可以是字符串，也可以是一个任意的代码对象实例。常用于将字符串转为数字
complex([real[, imag]]) 返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。
如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。
int(x, base=10) base缺省为10，当其省略时，当x为浮点数或整数字符串时返回整型数字，当x为浮点数字符串时会返回异常。
当base为其他值时可将字符串x作为base进制字符串，并将其转成十进制数字。
float([x]) 从一个数字或字符串x返回浮点数字

其中int()与float()函数前面已经讲解过，下面对其他函数进行说明。

  • ### abs(x)

返回一个数的__绝对值__。参数可以是整数、浮点数，返回值的类型与参数x的类型一致。</font>

In [1]:
print(abs(3))        # 返回绝对值3
print(abs(-3.0))     # 返回绝对值3.0
print(abs(-3.45))    # 返回绝对值3.45

3
3.0
3.45

如果参数x是一个__复数__，则返回它的__模__。

In [4]:
print(abs(3 + 4j))  # 返回复数3+4j的模5.0
  • ### divmod(a, b)

参数a、b可以是整数、浮点数，返回以__整数商和余数__构成的二元组，相当于(a // b, a % b)</font>

In [2]:
print(divmod(10, 3))        # 输出(3, 1)
print(divmod(10, -3))       # 输出(-4, -2)
print(divmod(-10, 3))       # 输出(-4, 2)
print(divmod(-10, -3))      # 输出(3, -1)

(3, 1)
(-4, -2)
(-4, 2)
(3, -1)
In [16]:
print(divmod(11.5, 3.5))    # 输出(3.0, 1.0)
print(divmod(11.5, -3.5))   # 输出(-4.0, -2.5)
print(divmod(-11.5, 3.5))   # 输出(-4.0, 2.5)
print(divmod(-11.5, -3.5))  # divmod()输出(3.0, -1.0)
  • ### pow(x, y[, z])

两参数形式 pow(x, y) 返回x的y次__幂__，等价于乘方运算：x ** y

In [27]:
print(pow(2, 3))      # 等价于2**3，返回8
print(pow(2, -3))      # 等价于2**-3，返回0.125
print(pow(2, 1/2))    # 等价于2**0.5，返回1.4142135623730951
print(pow(-9, 1/2))   # 等价于-9**0.5，返回复数1.8369701987210297e-16+3j，实部近似为0

如果z存在，则返回x的y次幂对z取余的结果， 比 pow(x, y) % z 更__高效__。此时三个参数均必须为整数。

In [22]:
print(pow(1999, 1998, 1997)) 
print(1999 ** 1998 % 1997)
  • ### round(number[, n])

返回浮点数number保留n 位小的__最短表示__，若number为整数时，返回整数本身。

Python 中采用的末位取舍算法为：
四舍六入五考虑，
五后非零就进一，
五后为零看奇偶，
五前为偶应舍去，
五前为奇要进一。

四舍六入五考虑，五后非零就进一，

In [3]:
print(round(3.84, 1))      # 舍去，输出3.8
print(round(3.86, 1))      # 进位，输出3.9
print(round(3.120500001, 2))  # 五后非零应进一，输出3.13
print('{:.2f}'.format(3.125000001))

3.8
3.9
3.13
3.13

五后为零看奇偶，五前为偶应舍去，五前为奇要进一。

In [4]:
print(round(3.12500000, 2))     # 五前为偶应舍去，输出3.12
print(round(3.11500000, 2))     # 五前为奇要进一，输出3.12

如果n被省略或为None,则返回最接近输入值的整数，即__取整__。

In [7]:
print(round(3.14))
print(round(-3.84))

结果小数部分的末位为0 或n 超过小数位数时，返回该数的__最短表示__，舍弃浮点数末尾无意义的零。

In [2]:
print(round(3.000006, 2))       # 期望输出3.00，实际输出其浮点数的最短表示3.0
print(round(3.140000005, 4))    # 期望输出3.1400，实际输出3.14

需要注意的是，__多数浮点数无法精确转为二进制__，会导致部分数字取舍与期望不符。

In [10]:
print(round(3.1425, 3))  # 五前为偶应舍去，期望输出3.142，实际输出3.143
print(round(2.675, 2))   # 五前为奇应进一，期望输出2.68，实际输出2.67

使用decimal模块可观察浮点数的精确值，round()函数的舍入实际上是按照其精确值处理的。

In [1]:
import decimal  # 引入decimal模块


print(decimal.Decimal(3.1425))  
print(decimal.Decimal(2.675))

print(decimal.Decimal(14.95))  
print(decimal.Decimal(14.65))
In [ ]:
当round(number,n)函数对整数number保留小数点后n位时，得到的数据仍为整数类型。
In [1]:
print(round(5,4))  # 输出 5
  • ### max(iterable)或max(arg1,arg2,…)

max(arg1,arg2,…) 从__多个参数__中返回其__最大值__</font>

In [4]:
print(max(80, 100, 1000))
print(max(32.7, 45.9, -100))

1000
45.9

max(iterable) 从一个__可迭代对象__中返回其__最大值__</font>

In [3]:
print(max([80, 100, 1000]))     # 返回列表中的最大值
print(max({32.7, 45.9, -100}))  # 返回集合中的最大值

1000
45.9
  • ### min(iterable)或min(arg1,arg2,…)

min(arg1,arg2,…) 从__多个参数__中返回其__最小值__</font>

In [3]:
print(min(80, 100, 1000))
print(min(32.7, 45.9, -100))

80
-100

min(iterable) 从一个__可迭代对象__中返回其__最小值__

In [4]:
print(min([80, 100, 1000]))     # 返回列表中的最小值
print(min({32.7, 45.9, -100}))  # 返回集合中的最小值

80
-100
  • ### sum(iterable, start=0)

省略start时，将元素为数值的可迭代对象iterable中的元素__累加__。</font>

In [5]:
print(sum(range(11)))      # 1+2+3+......+10，返回55
print(sum([1, 2, 3, 4]))   # 1+2+3+4，返回10

55
10

若给strat参数传值，将元素为数值的可迭代对象iterable中的元素__累加到start上__</font>

In [19]:
print(sum(range(11), start=10))  # 10+1+2+3+......+10，返回65
print(sum([1, 2, 3, 4], 20))     # 20+1+2+3+4，返回30

start参数值非整数时的应用：列表__降维__

若一个二维列表包含 n 个一维列表元素，可使用sum()函数将这些子列表拼成一个新的一维列表，起到降维的效果。

In [20]:
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]]
print(sum(ls,[]))

在某些使用场景时，不要用sum()。例如当以扩展精度对浮点数求和时，使用sum()可能无法得到精确结果，此时推荐使用 math.fsum()。

In [25]:
print(sum([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]))   # 期望输出1.0，实际结果为0.9999999999999999
In [26]:
import math  # 引入math模块
print(math.fsum([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]))  # 可获得精确的结果，输出1.0
  • ### eval(source)

前面我们讲解过使用eval()进行__数值类型转换__。
实际上，source参数是一个字符串，python会将source当做一个python__表达式__（从技术上讲，是一个条件列表）进行解析和计算。

In [33]:
x = 1
y = 3
print(eval('x+1'))        # 计算表达式x+1，输出2
print(eval('pow(y, 2)'))  # 计算表达式pow(y, 2)，输出9

当eval()解析到表达式是不可以计算后，就会查找它是不是一个变量的名字，如果是一个变量的名字，那么它会输出这个变量的内容，否则就会抛异常。

In [8]:
s = 'abc'
print(eval('s'))  # 解析到s，将其当作变量名，输出其值'abc'
s = '"abc"'
print(eval(s))    # eval去除单引号后得到了字符串“abc”，直接输出。

abc
abc
In [29]:
s = 'abc'
print(eval(s))   # 解析到abcd，将其当作变量名，此时该变量名未定义，抛NameError异常
  • ### complex([real[, imag]])

如果第一个形参real是字符串，则它被解释为一个复数。此时函数调用时必须没有第二个形参，否则将抛异常。

In [9]:
print(complex('1'))     # 解释为复数，此时虚部为0，输出(1+0j)
print(complex('1+2j'))  # 解释为复数，输出(1+2j)

(1+0j)
(1+2j)
In [38]:
print(complex('1',2))        # 第一个参数为字符串，此时若设置第二个参数，将抛异常

如果第一个形参real是数值型（整数、浮点数或复数），则函数调用时可以有第二个形参imag，返回值为 real + imag*1j 的复数。如果省略了imag，则默认值为零。

In [42]:
print(complex(1))           # 实部为1，此时虚部为默认值0，输出(1+0j)
print(complex(1, 2))        # 输出(1+2j)
print(complex(3.4, 5.6))    # 输出(3.4+5.6j)
print(complex(1+2j, 3+4j))  # 计算(1+2j)+(3+4j)*j，输出(-3+5j)

第二个形参imag不能是字符串，否则将抛异常。

In [43]:
print(complex(1, '2'))        # 第二个参数为字符串，抛异常