Python每日一练 04

Python每日一学 04——常用数学运算函数

一、前言

14天学习训练营导师课程：
杨鑫《Python 自学编程基础》
杨鑫《 Python 网络爬虫基础》
杨鑫《 Scrapy 爬虫框架实战和项目管理》

最近CSDN又出了一个活动，我看见了有关python的所以我就参加了，正好最近在进行python训练。
刚兴趣的朋友也可以去看看这个老师的课程。

二、常用数学运算函数

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

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

1、abs(x)

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

print(abs(3))        # 返回绝对值3
print(abs(-3.0))     # 返回绝对值3.0
print(abs(-3.45))    # 返回绝对值3.45
1
2
3

3
3.0
3.45
1
2
3

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

print(abs(3 + 4j))  # 返回复数3+4j的模5.0
1

5.0
1

2、divmod(a, b)

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

print(divmod(10, 3))        # 输出(3, 1)
print(divmod(10, -3))       # 输出(-4, -2)
print(divmod(-10, 3))       # 输出(-4, 2)
print(divmod(-10, -3))      # 输出(3, -1)
1
2
3
4

(3, 1)
(-4, -2)
(-4, 2)
(3, -1)
1
2
3
4

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)
1
2
3
4

(3.0, 1.0)
(-4.0, -2.5)
(-4.0, 2.5)
(3.0, -1.0)
1
2
3
4

3、pow(x, y[, z])

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

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
1
2
3
4

8
0.125
1.4142135623730951
(1.8369701987210297e-16+3j)
1
2
3
4

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

print(pow(1999, 1998, 1997)) 
print(1999 ** 1998 % 1997) 
1
2

4
4
1
2

4、round(number[, n])

浮点数number保留n 位小的最短表示。

Python 中采用的末位取舍算法为：

四舍六入五考虑，

五后非零就进一，

五后为零看奇偶，

五前为偶应舍去，

五前为奇要进一。

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

print(round(3.84, 1))      # 舍去，输出3.8
print(round(3.86, 1))      # 进位，输出3.9
print(round(3.125000001, 2))  # 五后非零应进一，输出3.13
1
2
3

3.8
3.9
3.13
1
2
3

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

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

3.12
3.12
1
2

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

print(round(3.14))
print(round(-3.84))
1
2

3
-4
1
2

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

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

3.0
3.14
1
2

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

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

3.143
2.67
1
2

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

import decimal  # 引入decimal模块
print(decimal.Decimal(3.1425))  
print(decimal.Decimal(2.675))
1
2
3

3.1425000000000000710542735760100185871124267578125
2.67499999999999982236431605997495353221893310546875
1
2

5、max(iterable)或max(arg1,arg2,…)

max(arg1,arg2,…) 从多个参数中返回其最大值。

print(max(80, 100, 1000))
print(max(32.7, 45.9, -100))
1
2

1000
45.9
1
2

max(iterable) 从一个可迭代对象中返回其最大值。

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

1000
45.9
1
2

6、min(iterable)或min(arg1,arg2,…)

min(arg1,arg2,…) 从多个参数中返回其最小值

print(min(80, 100, 1000))
print(min(32.7, 45.9, -100))
1
2

80
-100
1
2

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

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

80
-100
1
2

7、sum(iterable, start=0)

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

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

55
10
1
2

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

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
1
2

65
30
1
2

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

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

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,[]))
1
2

[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]
1

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

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
1

0.9999999999999999
1

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
1
2

1.0
1

8、eval(source)

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

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

2
9
1
2

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

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

abc
abc
1
2

s = 'abc'
print(eval(s))   # 解析到abcd，将其当作变量名，此时该变量名未定义，抛NameError异常
1
2

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

Input In [29], in ()
      1 s = 'abc'
----> 2 print(eval(s))


File :1, in 


NameError: name 'abc' is not defined
1
2
3
4
5
6
7
8
9
10
11
12
13

9、complex([real[, imag]])

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

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

(1+0j)
(1+2j)
1
2

print(complex('1',2))        # 第一个参数为字符串，此时若设置第二个参数，将抛异常
1

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Input In [38], in ()
----> 1 print(complex('1',2))


TypeError: complex() can't take second arg if first is a string
1
2
3
4
5
6
7
8
9

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

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)
1
2
3
4

(1+0j)
(1+2j)
(3.4+5.6j)
(-3+5j)
1
2
3
4

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

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

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Input In [43], in ()
----> 1 print(complex(1, '2'))


TypeError: complex() second arg can't be a string
1
2
3
4
5
6
7
8
9

+5.6j)
(-3+5j)

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

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

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Input In [43], in ()
----> 1 print(complex(1, '2'))


TypeError: complex() second arg can't be a string
1
2
3
4
5
6
7
8
9