Python 数学理论和表示函数

ceil() 函数

来自 math 模块的 ceil() 函数返回 x 的上限值，即不小于 x 的最小整数。

语法

ceil() 函数的语法如下：

import math
math.ceil(x)

注意： 这个函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象调用这个函数。

参数

• x −这是一个数值表达式。

返回值

这个函数返回大于等于“x”的最小整数。

示例

下面的示例展示了ceil()函数的用法。

from math import ceil, pi

a = -45.17
ceil_a = ceil(a)
print ("a: ",a, "ceil(a): ", ceil_a)

a = 100.12
ceil_a = ceil(a)
print ("a: ",a, "ceil(a): ", ceil_a)

a = 100.72
ceil_a = ceil(a)
print ("a: ",a, "ceil(a): ", ceil_a)

a = pi
ceil_a = ceil(a)
print ("a: ",a, "ceil(a): ", ceil_a)

当我们运行上面的程序时，它产生以下 输出 -

a: -45.17 ceil(a): -45
a: 100.12 ceil(a): 101
a: 100.72 ceil(a): 101
a: 3.141592653589793 ceil(a): 4

comb()函数

math模块中的comb()函数返回从y个项目中选择x个项目的方式的数量，无重复且无顺序。当x <= y时，计算为n! / (x! * (x-y)!)，当x > y时，计算为零。

语法

以下是comb()函数的语法 –

math.comb(x, y)

参数

• x - 必需。从中选择的正整数项。

• y - 必需。选择的正整数项。

返回值

如果”x”的值大于y的值，则返回0。如果x和y都是负数，则会引发ValueError错误。如果两个参数都不是整数，则会引发TypeError错误。

示例

from math import comb

x=7
y=5
combinations = comb(x,y)
print ("x: ",x, "y: ", y, "combinations: ", combinations)

x=5
y=7
combinations = comb(x,y)
print ("x: ",x, "y: ", y, "combinations: ", combinations)

它将产生以下输出−

x: 7 y: 5 combinations: 21
x: 5 y: 7 combinations: 0

copysign()函数

math模块中的copy()函数返回一个具有与y相同符号但大小（绝对值）与x相同的浮点数。

语法

copysign()函数的语法如下所示：

math.copysign(x, y)

参数

• x – 一个数字
• y – 一个数字

返回值

返回一个浮点数，其绝对值为 x，但符号与 y 相同。

示例

from math import copysign

x=10
y=-20

result = copysign(x,y)
print ("x: ",x, "y: ", y, "copysign: ", result)

x=-10
y=20

result = copysign(x,y)
print ("x: ",x, "y: ", y, "copysign: ", result)

x=-10
y= -0.0

result = copysign(x,y)
print ("x: ",x, "y: ", y, "copysign: ", result)

它将产生以下 输出 −

x: 10 y: -20 copysign: -10.0
x: -10 y: 20 copysign: 10.0
x: -10 y: -0.0 copysign: -10.0

fabs()函数

math模块中的fabs()函数返回给定数字的绝对值。即使参数是整数，它也总是返回一个浮点数。

语法

fabs()函数的语法如下所示−

math.fabs(x)

参数

• x - 一个数字

返回值

返回一个带有 x 的大小（绝对值）的浮点数

示例

from math import fabs

x=10.25
result = fabs(x)
print ("x: ",x, "fabs value: ", result)

x=20
result = fabs(x)
print ("x: ",x,"fabs value: ", result)

x=-10
result = fabs(x)
print ("x: ",x, "fabs value: ", result)

它会生成以下 输出 −

x: 10.25 fabs value: 10.25
x: 20 fabs value: 20.0
x: -10 fabs value: 10.0

factorial()函数

factorial()函数在math模块中返回给定整数的阶乘值。阶乘是从1到该数字之间所有整数的乘积。记为x！其中4！= 4X3X2X1。

语法

factorial()函数的语法如下：

math.factorial(x)

参数

• x − 一个整数

返回值

返回一个整数，该整数为从1到x的整数的乘积。对于负数x，将引发ValueError错误。

示例

from math import factorial

x=10
result = factorial(x)
print ("x: ",x, "x! value: ", result)

x=5
result = factorial(x)
print ("x: ",x,"x! value: ", result)

x=-5
result = factorial(x)
print ("x: ",x, "x! value: ", result)

它将产生以下 输出 –

x: 10 x! value: 3628800
x: 5 x! value: 120
Traceback (most recent call last):
   File "C:\Users\mlath\examples\main.py", line 14, in <module>
     result = factorial(x)
              ^^^^^^^^^^^^
ValueError: factorial() not defined for negative values

floor()函数

floor()函数返回x的向下取整，即最大的不大于x的整数。

语法

floor()函数的语法如下：

import math
math.floor(x)

注意 - 该函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象来调用该函数。

参数

• x - 这是一个数值表达式。

返回值

该函数返回不大于 x 的最大整数。

示例

下面的例子展示了floor()函数的用法。

from math import floor, pi

a = -45.17
floor_a = floor(a)
print ("a: ",a, "floor(a): ", floor_a)

a = 100.12
floor_a = floor(a)
print ("a: ",a, "floor(a): ", floor_a)

a = 100.72
floor_a = floor(a)
print ("a: ",a, "floor(a): ", floor_a)

a = pi
floor_a = floor(a)
print ("a: ",a, "floor(a): ", floor_a)

当我们运行上述程序时，它产生以下 输出 −

a: -45.17 floor(a): -46
a: 100.12 floor(a): 100
a: 100.72 floor(a): 100
a: 3.141592653589793 floor(a): 3

fmod()函数

在math模块中，fmod()函数与x%y返回相同的结果。然而，fmod()函数比取模运算符给出更准确的模除结果。

语法

以下是fmod()函数的语法：

import math
math.fmod(x, y)

注意 ：这个函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象来调用该函数。

参数

• x ：被除数，可以为正数或负数。

• y ：除数，可以为正数或负数。

返回值

该函数返回 x 除以 y 的余数。

示例

以下示例展示了fmod()函数的用法。

from math import fmod

a=10
b=2
c=fmod(a,b)
print ("a=",a, "b=",b, "fmod(a,b)=", c)

a=10
b=4
c=fmod(a,b)
print ("a=",a, "b=",b, "fmod(a,b)=", c)

a=0
b=10
c=fmod(a,b)
print ("a=",a, "b=",b, "fmod(a,b)=", c)

a=10
b=1.5
c=fmod(a,b)
print ("a=",a, "b=",b, "fmod(a,b)=", c)

当我们运行上述程序时，它会产生以下的输出。

a= 10 b= 2 fmod(a,b)= 0.0
a= 10 b= 4 fmod(a,b)= 2.0
a= 0 b= 10 fmod(a,b)= 0.0
a= 10 b= 1.5 fmod(a,b)= 1.0

frexp()函数

math模块中的frexp()函数返回x的尾数和指数对(m, e)。m是一个浮点数，e是一个整数，使得x m * 2**e。

语法

frexp()函数的语法如下所示：

import math
math.frexp(x)

注意 - 这个函数不能直接访问，我们需要导入math模块，然后使用math静态对象调用这个函数。

参数

• x - 正数或负数。

返回值

这个函数返回幂和指数(m,n)，使得m*2**e等于 x 。

示例

以下示例展示了frexp()函数的用法。

from math import frexp

x = 8
y = frexp(x)
print ("x:", x, "frex(x):",y)
print ("Cross-check")
m,n=y
x = m*2**n
print ("frexp(x): ",y, "x:", x)

它将产生如下输出：

x: 8 frex(x): (0.5, 4)
Cross-check
frexp(x): (0.5, 4) x: 8.0

fsum() 函数

math 模块中的 fsum() 函数返回可迭代对象（例如列表、元组、数组）中所有数字项的浮点数和。

语法

下面是 fsum() 函数的语法：

import math
math.sum(x)

注意 − 这个函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象调用这个函数。

参数

• x − 数组，包含数字。其他类型会导致TypeError。

返回值

这个函数返回迭代对象中所有项的浮点数之和。

示例

以下示例展示了fsum()函数的用法−

from math import fsum

x = [1,2,3,4,5]
y = fsum(x)
print ("x:", x, "fsum(x):",y)

x = (10,11,12)
y = fsum(x)
print ("x:", x, "fsum(x):",y)

x = [1,'a',2]
y = fsum(x)
print ("x:", x, "fsum(x):",y)

它将产生以下输出： output -

x: [1, 2, 3, 4, 5] fsum(x): 15.0
x: (10, 11, 12) fsum(x): 33.0
Traceback (most recent call last):
   File "C:\Users\mlath\examples\main.py", line 13, in <module>
      y = fsum(x)
          ^^^^^^^
TypeError: must be real number, not str

gcd()函数

math模块中的gcd()函数返回所有整数数字的最大公约数。返回值是所有参数的最大正整数约数。如果所有数字都是零，则返回0。不带参数的gcd()函数返回0。

语法

以下是gcd()函数的语法：

import math
math.gcd(x)

注意 - 这个函数不能直接访问，需要先导入math模块，然后使用math静态对象调用这个函数。

参数

• x1, x2 – 整数

返回值

这个函数返回最大公约数，作为整数。

示例

下面的示例展示了gcd()函数的用法：

from math import gcd

x, y, z = 12, 8, 24
result = gcd(x, y, z)
print ("x: {} y: {} z: {}".format(x,y,z), "gcd(x,y, z):",result)

x, y, z = 12, 6, 9
result = gcd(x, y, z)
print ("x: {} y: {} z: {}".format(x,y,z), "gcd(x,y, z):",result)

x, y = 7, 12
result = gcd(x, y)
print ("x: {} y: {}".format(x,y), "gcd(x,y):",result)

x, y = 0, 12
result = gcd(x, y)
print ("x: {} y: {}".format(x,y), "gcd(x,y):",result)

它将生成以下 输出 –

x: 12 y: 8 z: 24 gcd(x,y, z): 4
x: 12 y: 6 z: 9 gcd(x,y, z): 3
x: 7 y: 12 gcd(x,y): 1
x: 0 y: 12 gcd(x,y): 12

isclose() 函数

isclose() 函数是 math 模块中的一个函数，如果两个数字参数的值彼此接近，则返回 True，否则返回 false。

语法

isclose() 函数的语法如下：

import math
math.isclose(x,y)

注意 − 该函数不可直接访问，因此我们需要导入math模块，然后使用math静态对象调用该函数。接近度根据给定的绝对容忍度和相对容忍度来确定。

参数

• x − 要检查接近度的第一个值。

• y − 要检查接近度的第二个值。

• rel_tol − 相对容忍度（可选）。

• abs_tol − 最小绝对容忍度（可选）。

返回值

如果 x 和 y 接近，则该函数返回True，否则返回False。

示例

下面的示例显示了isclose()函数的用法。

from math import isclose

x = 2.598
y = 2.597
result = isclose(x, y)
print ("x: {} y:{}".format(x,y), "isclose(x,y):",result)

x = 5.263
y = 5.263000001
result = isclose(x, y)
print ("x: {} y:{}".format(x,y), "isclose(x,y):",result)

它将产生如下 输出 –

x: 2.598 y:2.597 isclose(x,y): False
x: 5.263 y:5.263000001 isclose(x,y): True

isfinite()函数

isfinite()函数在math模块中返回True，如果参数既不是无穷大也不是NaN，否则返回False。

语法

以下是isfinite()函数的语法:

import math
math.isfinite(x)

注意 - 这个函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象调用这个函数。

参数

• x - 数值操作数。

返回值

如果 x 既不是无穷大也不是NaN，则该函数返回True，否则返回False。

示例

以下示例显示了isfinite()函数的用法：

from math import isfinite

x = 1.23E-5
result = isfinite(x)
print ("x:", x, "isfinite(x):",result)

x = 0
result = isfinite(x)
print ("x:", x, "isfinite(x):",result)

x = float("Inf")
result = isfinite(x)
print ("x:", x, "isfinite(x):",result)

它会产生以下 输出 –

x: 1.23e-05 isfinite(x): True
x: 0 isfinite(x): True
x: inf isfinite(x): False

isinf()函数

math模块中的isinf()函数返回True，如果参数是正无穷或负无穷，否则返回False。它是isfinite()函数的相反。

语法

isinf()函数的语法如下：

import math
math.isinf(x)

注意 - 这个函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象调用这个函数。

参数

• x - 数字操作数

返回值

如果 x 是正无穷或负无穷，则返回True，否则返回False。

示例

以下示例显示了isinf()函数的用法：

from math import isinf

x = 1.23E-5
result = isinf(x)
print ("x:", x, "isinf(x):",result)

x = float("-Infinity")
result = isinf(x)
print ("x:", x, "isinf(x):",result)

x = float("Inf")
result = isinf(x)
print ("x:", x, "isinf(x):",result)

它将产生以下 输出 –

x: 1.23e-05 isinf(x): False
x: -inf isinf(x): True
x: inf isinf(x): True

isnan()函数

math模块中的isnan()函数返回True，如果x是NaN（不是一个数字），否则返回False。

语法

isnan()函数的语法如下所示−

import math
math.isnan(x)

注意 − 此函数无法直接访问，因此我们需要导入math模块，然后使用math静态对象调用此函数。

参数

• x − 数字操作数

返回值

如果 x 是NaN（不是一个数字），则返回True，否则返回False。

示例

以下示例演示了isnan()函数的用法：

from math import isnan

x = 156.78
result = isnan(x)
print ("x:", x, "isnan(x):",result)

x = float("-Infinity")
result = isnan(x)
print ("x:", x, "isnan(x):",result)

x = float("NaN")
result = isnan(x)
print ("x:", x, "isnan(x):",result)

x = "NaN"
result = isnan(x)
print ("x:", x, "isnan(x):",result)

它将产生以下 输出 −

x: 156.78 isnan(x): False
x: -inf isnan(x): False
x: nan isnan(x): True
Traceback (most recent call last):
   File "C:\Users\mlath\examples\main.py", line 16, in <module>
      result = isnan(x)
               ^^^^^^^^
TypeError: must be real number, not str

请注意，”NaN”是一个字符串，而不是NaN数值操作数。

isqrt()函数

math模块中的isqrt()函数返回非负整数的整数平方根。这是给定正整数的精确平方根的底板。结果值的平方小于或等于参数数字。

语法

以下是isqrt()函数的语法 –

import math
math.isqrt(x)

注意 − 此函数无法直接访问，所以我们需要导入math模块，然后使用math静态对象调用此函数。

参数

• x − 非负整数。

返回值

此函数返回最接近的整数向下取整的平方根。

示例

以下示例展示了isqrt()函数的用法 −

from math import isqrt, sqrt

x = 12
y = isqrt(x)
z = sqrt(x)
print ("x:", x, "isqrt(x):",y, "sqrt(x):", z)

x = 16
y = isqrt(x)
z = sqrt(x)
print ("x:", x, "isqrt(x):",y, "sqrt(x):", z)

x = -100
y = isqrt(x)
z = sqrt(x)
print ("x:", x, "isqrt(x):",y, "sqrt(x):", z)

作为比较，还计算了sqrt()函数的值。sqrt()返回float类型，isqrt()返回整数类型。对于isqrt()，数字必须是非负的。

它将产生以下 输出 −

x: 12 isqrt(x): 3 sqrt(x): 3.4641016151377544
x: 16 isqrt(x): 4 sqrt(x): 4.0
Traceback (most recent call last):
   File "C:\Users\mlath\examples\main.py", line 14, in <module>
      y = isqrt(x)
          ^^^^^^^^
ValueError: isqrt() argument must be nonnegative

lcm()函数

math模块中的lcm()函数返回两个或多个整数参数的最小公倍数。对于非零的参数，该函数返回能被所有参数整除的最小正整数。如果任何一个参数为零，则返回值为0。

语法

lcm()函数的语法如下 −

import math
math.lcm(x1, x2, . . )

注意 ：此函数不可直接访问，因此我们需要导入math模块，然后使用math静态对象调用该函数。

参数

• x1, x2, . . – 整数

返回值

此函数返回所有整数的最小公倍数。

示例

以下示例展示了lcm()函数的用法：

from math import lcm

x = 4
y = 12
z = 9
result = lcm(x,y,z)
print ("x: {} y: {} z: {}".format(x,y,z), "lcm(x,y,z):", result)

x = 5
y = 15
z = 0
result = lcm(x,y,z)
print ("x: {} y: {} z: {}".format(x,y,z), "lcm(x,y,z):", result)

x = 4
y = 3
z = 6
result = lcm(x,y,z)
print ("x: {} y: {} z: {}".format(x,y,z), "lcm(x,y,z):", result)

它将生成以下 输出 −

x: 4 y: 12 z: 9 lcm(x,y,z): 36
x: 5 y: 15 z: 0 lcm(x,y,z): 0
x: 4 y: 3 z: 6 lcm(x,y,z): 12

ldexp() 函数

在 math 模块中，ldexp() 函数返回第一个数与第二个数的指数的乘积。因此，ldexp(x,y) 返回 x*2**y。这是 frexp() 函数的反向操作。

语法

ldexp() 函数的语法如下：

import math
math.lcm(x,y)

Note −此函数无法直接访问，所以我们需要导入math模块，然后使用math静态对象调用此函数。

参数

• x −正或负数。

• y −正或负数。

返回值

此函数返回x*2**y。

示例

以下示例演示了ldexp()函数的用法−

from math import ldexp, frexp

x = 0.5
y = 4
z = ldexp(x,y)
print ("x: {} y: {}".format(x,y), "ldexp(x,y)", z)

print ("Cross-check")
x,y = frexp(z)

print ("ldexp value:", z, "frexp(z):",x,y )

它会产生以下结果 输出 &minu;

x: 0.5 y: 4 ldexp(x,y) 8.0
Cross-check
ldexp value: 8.0 frexp(z): 0.5 4

modf() 函数

modf() 方法返回一个有两个元素的元组，其中包含参数 x 的小数部分和整数部分。 x 的两个部分的符号与 x 相同。整数部分被返回为浮点数。

语法

modf() 方法的语法如下所示 −

import math
math.modf( x )

注意 − 此函数不能直接访问，因此我们需要导入math模块，然后使用math静态对象调用此函数。

参数

• x − 这是一个数值表达式。

返回值

此方法返回x的小数和整数部分，以两个元素的元组形式返回。两部分与x具有相同的符号。整数部分返回为浮点数。

示例

下面的示例演示了使用modf()方法的用法−

from math import modf, pi

a = 100.72
modf_a = modf(a)
print ("a: ",a, "modf(a): ", modf_a)

a = 19
modf_a = modf(a)
print ("a: ",a, "modf(a): ", modf_a)

a = pi
modf_a = modf(a)
print ("a: ",a, "modf(a): ", modf_a)

它会产生以下 输出 −

a: 100.72 modf(a): (0.7199999999999989, 100.0)
a: 19 modf(a): (0.0, 19.0)
a: 3.141592653589793 modf(a): (0.14159265358979312, 3.0)

nextafter()函数

nextafter()函数返回小数点后面的下一个浮点数值， x 接近 y 。

• 如果y>x，则x递增。

• 如果y<x，则x递减。

语法

下面是nextafter()函数的语法-

import math
math.nextafter( x, y )

注意 − 这个函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象调用这个函数。

参数

• x和y – 数字操作数。

返回值

这个函数返回下一个浮点数值。

示例

下面的示例展示了nextafter()函数的用法：

from math import nextafter

x=1.5
y=100
z=nextafter(x, y)
print ("x: {} y: {}".format(x,y), "nextafter(x,y)", z)

x=1.5
y=float("-inf")
z=nextafter(x, y)
print ("x: {} y: {}".format(x,y), "nextafter(x,y)", z)

x=0
y=float("inf")
z=nextafter(x, y)
print ("x: {} y: {}".format(x,y), "nextafter(x,y)", z)

它将产生以下输出 −

x: 1.5 y: 100 nextafter(x,y) 1.5000000000000002
x: 1.5 y: -inf nextafter(x,y) 1.4999999999999998
x: 0 y: inf nextafter(x,y) 5e-324

perm()函数

perm()函数计算排列。它返回从y个项中选择x个项，在没有重复和有序的情况下的选择方式数目。

排列定义为xPy = x! / (x-y)!，当y<=x时，当y>x时，返回零。

语法

以下是perm()函数的语法 –

import math
math.perm( x, y )

注意 − 该函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象来调用该函数。

参数

• x − 必需。要选择的正整数项。

• y − 必需。要选择的正整数项。

返回值

该函数返回排列值 x P y = x! / (x-y)!

示例

下面的示例显示了perm()函数的用法。

from math import perm

x=5
y=3
permutations = perm(x,y)
print ("x: ",x, "y: ", y, "permutations: ", permutations)

x=3
y=5
permutations = perm(x,y)
print ("x: ",x, "y: ", y, "permutations: ", permutations)

将产生以下 输出 −

x: 5 y: 3 permutations: 60
x: 3 y: 5 permutations: 0

prod() 函数

prod() 函数计算作为参数给定的可迭代对象（列表，元组）中所有数字项的乘积。第二个参数的默认值为 1。

语法

prod() 函数的语法如下：

import math
math.prod(iterable, start)

注意 − 此函数无法直接访问，因此我们需要导入math模块，然后使用math静态对象调用此函数。

参数

• iterable − 必需。必须包含数值操作数。

• start − 默认为1。

返回值

此函数返回可迭代对象中所有项目的乘积。

示例

以下示例演示了prod()函数的用法 −

from math import prod

x = [2,3,4]
product = prod(x)
print ("x: ",x, "product: ", product)

x = (5,10,15)
product = prod(x)
print ("x: ",x, "product: ", product)

x = [2,3,4]
y = 3
product = prod(x, start=y)
print ("x: ",x,"start:", y, "product: ", product)

它将会产生以下 输出 −

x: [2, 3, 4] product: 24
x: (5, 10, 15) product: 750
x: [2, 3, 4] start: 3 product: 72

remainder()函数

remainder()函数返回x与y相对的余数。这是x – n*y的差，其中n是最接近商x / y的整数。如果x / y恰好位于两个连续整数的中间，将使用最接近的偶数作为n。

语法

remainder()函数的语法如下：

import math
math.remainder(x, y)

注意 ：该函数无法直接访问，因此我们需要导入math模块，然后通过math静态对象调用该函数。

参数

• x、y：数值操作数。y必须为非零。

返回值

该函数返回x除以y的余数。

示例

以下示例演示了remainder()函数的用法：

from math import remainder

x = 18
y= 4
rem = remainder(x, y)
print ("x: ",x, "y:", y, "remainder: ", rem)

x = 22
y= 4
rem = remainder(x, y)
print ("x: ",x, "y:", y, "remainder: ", rem)

x = 15
y= float("inf")
rem = remainder(x, y)
print ("x: ",x, "y:", y, "remainder: ", rem)

x = 15
y= 0
rem = remainder(x, y)
print ("x: ",x, "y:", y, "remainder: ", rem)

它将产生以下 输出 − −

x: 18 y: 4 remainder: 2.0
x: 22 y: 4 remainder: -2.0
x: 15 y: inf remainder: 15.0
Traceback (most recent call last):
   File "C:\Users\mlath\examples\main.py", line 20, in <module>
      rem = remainder(x, y)
            ^^^^^^^^^^^^^^^
ValueError: math domain error

trunc（）函数

trunc（）函数返回数字的整数部分，去除小数部分。对于正数 x ，trunc()等效于floor()，对于负数 x ，等效于ceil（）。

语法

trunc（）函数的语法如下−

import math
math.trunc(x)

注意 − 此函数不能直接访问，因此我们需要导入math模块，然后使用math静态对象调用此函数。

参数

• x − 数字操作数

返回值

此函数返回操作数的整数部分。

示例

以下示例显示了trunc()函数的用法−

from math import trunc

x = 5.79
rem = trunc(x)
print ("x: ",x, "truncated: ", rem)

x = 12.04
rem = trunc(x)
print ("x: ",x, "truncated: ", rem)

x = -19.98
rem = trunc(x)
print ("x: ",x, "truncated: ", rem)

x = 15
rem = trunc(x)
print ("x: ",x, "truncated: ", rem)

将产生以下 输出 –

x: 5.79 truncated: 5
x: 12.04 truncated: 12
x: -19.98 truncated: -19
x: 15 truncated: 15

ulp()函数

ULP代表“最后一位中的单元”。 ulp()函数返回浮点数x的最低有效位的值。 对于正x，trunc()等效于floor()，对于负x，等效于ceil()。

不同的场景−

• 如果x是NaN，则返回x。

• 如果x是负数，则返回ulp(-x)。

• 如果x是正无穷大，则返回x。

• 如果x等于零，则返回最小正规代表浮点数。

• 如果x等于最大正规代表浮点数，则返回x的最低有效位的值。

• 如果x是正有限数，则返回x的最低有效位的值，使得大于x的第一个浮点数是x + ulp(x)。

语法

以下是ulp()函数的语法−

import math
math.ulp(x)

注意 − 此函数不能直接访问，所以我们需要导入math模块，然后使用math静态对象调用此函数。

参数

• x − 数字操作数

返回值

此函数返回浮点数 x 的最低有效位。

示例

以下示例展示了ulp()函数的用法 −

from math import ulp

x = float('nan')
rem = ulp(x)
print ("x: ",x, "ULP: ", rem)

x = 0.0
rem = ulp(x)
print ("x: ",x, "ULP: ", rem)

x = -10
rem = ulp(x)
print ("x: ",x, "ULP: ", rem)

x = 15
rem = ulp(x)
print ("x: ",x, "ULP: ", rem)

会有以下 输出 −

x: nan ULP: nan
x: 0.0 ULP: 5e-324
x: -10 ULP: 1.7763568394002505e-15
x: 15 ULP: 1.7763568394002505e-15