理论与表示函数

上一个
下一个

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() 函数返回一个浮点数，其大小（绝对值）为 x，但符号为 y。

语法

以下是 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() 函数

math 模块中的 factorial() 函数返回给定整数的阶乘值。一个数的阶乘是从 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)

它将产生以下输出 -

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() 函数

math 模块中的 isclose() 函数如果两个数字参数的值彼此接近，则返回 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() 函数

math 模块中的 isfinite() 函数如果参数既不是无穷大也不是 NaN，则返回 True，否则返回 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() 函数如果 x 是 NaN（非数字），则返回 True，否则返回 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() 返回浮点数，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)

注意 - 此函数无法直接访问，因此我们需要导入 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具有相同的符号。整数部分作为浮点数返回。

语法

以下是 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 - 必需。要选择的项目的正整数。

返回值

此函数返回xPy的排列值 = 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 的最低有效位的数值。trunc() 对于正 x 等效于 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
python_maths.htm
打印页面
上一页
下一页
广告