数学#

介绍 #

Math includes both built-in Python functions and the full math module, which is automatically available in VEXcode AIR. These tools allow you to perform everything from basic arithmetic to advanced trigonometry, rounding, and logarithmic operations.

使用这些函数和常量来计算 VEX AIR 无人机控制器的位置、角度、距离和其他数值。您还可以在角度和弧度之间转换、计算表达式，以及处理无穷大和 NaN 等特殊值。

**注意：**除非另有明确说明，所有返回值均为浮点数，并精确格式化为小数点后五位。超过五位小数的值将被四舍五入，少于五位小数的值将以零补齐，以确保始终精确显示五位小数。

以下是可用的数学函数、常量和实用程序的列表：

内置函数——Python 附带的常见数学工具。

abs – Returns the absolute value of a number.
round – Rounds a number to a specified number of decimal places.
min – Returns the smallest of the input values.
max – Returns the largest of the input values.
sum – Adds up all values in an iterable.
divmod – Returns the quotient and remainder as a tuple.
pow – Raises a number to a power, optionally with a modulus.
int – Converts a value to an integer.
float – Converts a value to a floating-point number.

Constants – Predefined values from the math module.

math.pi – The constant π (pi).
math.tau – The constant tau (2π).
math.e – Euler’s number, base of the natural log.
math.inf – Positive infinity.
math.nan – Not a Number (NaN).

三角学——计算角度和边之间的关系。

math.sin – Sine of an angle in radians.
math.cos – Cosine of an angle in radians.
math.tan – Tangent of an angle in radians.
math.asin – Arcsine of a value in radians.
math.acos – Arccosine of a value in radians.
math.atan – Arctangent of a value in radians.
math.atan2 – Arctangent of y/x in radians, considering the quadrant.
math.degrees – Converts radians to degrees.
math.radians – Converts degrees to radians.

双曲线——高级三角相关函数。

math.sinh – Hyperbolic sine of a value.
math.cosh – Hyperbolic cosine of a value.
math.tanh – Hyperbolic tangent of a value.
math.asinh – Inverse hyperbolic sine.
math.acosh – Inverse hyperbolic cosine.
math.atanh – Inverse hyperbolic tangent.

舍入和绝对值——调整精度或方向。

math.ceil – Rounds up to the nearest integer.
math.floor – Rounds down to the nearest integer.
math.trunc – Removes the decimal portion.
math.fabs – Returns the absolute value as a float.

指数和对数——幂、根和对数计算。

math.pow – Raises a number to a power.
math.sqrt – Returns the square root.
math.exp – Calculates e to the power of x.
math.log – Natural logarithm (base e).
math.log10 – Base-10 logarithm.
math.log2 – Base-2 logarithm.
math.factorial – Factorial of an integer.
math.expm1 – More accurate result for e^x - 1.

浮点运算——检查或分解浮点值。

math.modf – Returns the fractional and integer parts of a float.
math.frexp – Decomposes a number into mantissa and exponent.
math.fmod – Remainder with sign of the dividend.
math.copysign – Returns a value with the sign of another.
math.ldexp – Computes x * (2 ** exp).

比较和近似——检查具有公差或类别的值。

math.isfinite – Checks if a number is finite.
math.isinf – Checks if a number is infinite.
math.isnan – Checks if a value is NaN.

误差与伽马——特殊的数学函数。

math.gamma – Gamma function (generalized factorial).
math.lgamma – Logarithmic gamma.
math.erf – Error function.
math.erfc – Complementary error function.

内置函数 #

Python 提供了几个内置函数，允许您在项目内部执行数学运算。

abs #

abs returns the absolute value of a number, removing any negative sign.

Usage:
abs(x)

范围	描述
`x`	整数或浮点数。

# Get the absolute value of -10
abs_result = abs(-10)
controller.screen.print(abs_result)

# abs_result = 10

round #

round returns a rounded a number to a specified number of decimal places as an integer.

Usage:
round(x, ndigits)

范围	描述
`x`	整数或浮点数。
`ndigits`	Optional. Controls how many decimal places to round to (between 0 and 5). The default is 0. When this parameter is used, `round` returns a float.

# Round 5.7 to the nearest integer
round_int_result = round(5.7)
controller.screen.print(round_int_result)

# round_int_result = 6

# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
controller.screen.print(round_result)

# round_result = 3.14000

min #

min returns the smallest value from multiple arguments or an iterable.

Usage:
min(arg1, arg2, …) or min(sequence)

范围	描述
`arg1`, `arg2`, …	要比较的数字。
`sequence`	包含数字的列表、元组或其他序列。

# Get the smallest number from 3, 7, and 1
min_result = min(3, 7, 1)
controller.screen.print(min_result)

# min_result = 1

# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
controller.screen.print(min_list_result)

# min_list_result = 1

max #

max returns the largest value from multiple arguments or an iterable.

Usage:
max(arg1, arg2, …) or max(sequence)

范围	描述
`arg1`, `arg2`, …	要比较的数字。
`sequence`	包含数字的列表、元组或其他序列。

# Get the largest number from 3, 7, and 1
max_result = max(3, 7, 1)
controller.screen.print(max_result)

# max_result = 7

# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
controller.screen.print(max_list_result)

# max_list_result = 25

sum #

sum adds up all values in an iterable, with an optional starting value.

Usage:
sum(sequence, start)

范围	描述
`sequence`	包含数字的列表、元组或其他序列。
`start`	可选。要添加到总和的值。默认值为 0。

# Calculate the sum of a list of numbers
sum_result = sum([1, 2, 3, 4, 5])
controller.screen.print(sum_result)

# sum_result = 15

# Calculate the sum of a list with a starting value of 10
sum_with_start = sum([1, 2, 3], 10)
controller.screen.print(sum_with_start)

# sum_with_start = 16

divmod #

divmod returns a tuple containing the quotient and remainder of a division operation.

Usage:
divmod(a, b)

范围	描述
`a`	股息。
`b`	除数。

# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
controller.screen.print(divmod_result)

# divmod_result = (3, 1)

pow #

pow returns a number raised to a power and optionally performs a modulus operation as an integer.

Usage:
pow(x, y, mod)

范围	描述
`x`	基数。
`y`	指数。
`mod`	Optional. A modulus value. If provided, returns `(x ** y) % mod`.

# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
controller.screen.print(pow_result)

# pow_result = 8

# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
controller.screen.print(pow_mod_result)

# pow_mod_result = 6

int #

>int converts a number or string into an integer. It also supports base conversion when converting from a string.

Usage:
int(x, base)

范围	描述
`x`	要转换的数字、字符串或其他对象。
`base`	可选。用于转换的进制数。默认值为 10。

# Convert a float to an integer to get rid of decimals
price = 19.99
price_int = int(price)
controller.screen.print(f"{price_int} coins")

# Output: 19 coins

# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
controller.screen.print(user_number * 2)

# Output: 110

float #

float converts a number or string into a floating-point number.

Usage:
float(x)

范围	描述
`x`	要转换的数字、字符串或其他对象。

# Convert division result to a float
num_apples = 6
num_people = 2
apples_per_person = float(num_apples) / num_people
controller.screen.print(apples_per_person)

# Output: 3.00000

# Convert a string into a float to use in calculations
user_input = "23.4"
user_number = float(user_input)
controller.screen.print(user_number * 3)

# Output: 70.20000

数学模块 #

The math module in MicroPython provides additional methods for performing common mathematical calculations. These methods include trigonometric, logarithmic, and other numerical operations.

The math module is imported by default in VEXcode.

Constants #

常量是预定义的值，在项目期间保持不变。它们可以在计算中使用，无需任何定义或赋值。

圆周率 #

pi gives the mathematical constant π, the ratio of a circle’s circumference to its diameter.

Usage:
math.pi

# Calculate the area of a circle with radius 5 using pi
circle_area = math.pi * 5 * 5
controller.screen.print(circle_area)

# circle_area = 78.53982

tau #

tau gives the value of 2π.

Usage:
math.tau

# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)

# circumference = 31.41593

e #

e gives the base of the natural logarithm.

Usage:
math.e

# Calculate e raised to the power of 2
e_power = math.pow(math.e, 2)
controller.screen.print(e_power)

# e_power = 7.38906

信息 #

inf gives positive infinity as a float.

Usage:
math.inf

# Check if infinity is infinite
inf_value = math.inf

if math.isinf(inf_value):
    controller.screen.print("Infinity")

# Prints "Infinity"

馕 #

nan represents a special float for “Not a Number” (NaN).

Usage:
math.nan

# Check if nan is Not a Number
nan_value = math.nan

if math.isnan(nan_value):
    controller.screen.print("Not a Number")

# Prints "Not a Number"

Trigonometry #

罪 #

sin calculates the sine of an angle in radians and returns a float.

Usage:
math.sin(x)

范围	描述
`x`	表示角度的浮点数或整数，单位为弧度。

# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)

# sine_result = 0.50000

余弦 #

cos calculates the cosine of an angle in radians and returns a float.

Usage:
math.cos(x)

范围	描述
`x`	表示角度的浮点数或整数，单位为弧度。

# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)

# cosine_result = 0.50000

棕褐色 #

tan calculates the tangent of an angle in radians and returns a float.

Usage:
math.tan(x)

范围	描述
`x`	表示角度的浮点数或整数，单位为弧度。

# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)

# tangent_result = 1.00000

阿辛 #

asin calculates the inverse sine (arc sine) of a number and returns a float representing the angle in radians.

Usage:
math.asin(x)

范围	描述
`x`	-1 到 1 之间的浮点数或整数。

# Calculate the arc sine of 0.5 in radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)

# arc_sine_result = 0.52360

阿科斯 #

acos calculates the inverse cosine (arc cosine) of a number and returns a float representing the angle in radians.

Usage:
>math.acos(x)

范围	描述
`x`	-1 到 1 之间的浮点数或整数。

# Calculate the arc cosine of 0.5 in radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)

# arc_cosine_result = 1.04720

阿坦 #

atan calculates the inverse tangent (arc tangent) of a number and returns a float representing the angle in radians.

Usage:
math.atan(x)

范围	描述
`x`	浮点数或整数。

# Calculate the arc tangent of 1 in radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)

# arc_tangent_result = 0.78540

反相2 #

atan2 calculates the principal value of the inverse tangent of y/x and returns a float representing the angle in radians.

Usage:
math.atan2(y, x)

范围	描述
`y`	表示 y 坐标的浮点数或整数。
`x`	表示 x 坐标的浮点数或整数。

# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)

# atan2_result = 0.64350

度 #

degrees converts an angle from radians to degrees.

Usage:
math.degrees(x)

范围	描述
`x`	表示弧度角的浮点数或整数。

# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
controller.screen.print(degrees_result)

# degrees_result = 180.00000

弧度 #

radians converts an angle from degrees to radians.

Usage:
math.radians(x)

范围	描述
`x`	表示角度（以度为单位）的浮点数或整数。

# Convert 180 degrees to radians
radians_result = math.radians(180)
controller.screen.print(radians_result)

# radians_result = 3.14159

Hyperbolics #

辛 #

sinh calculates the hyperbolic sine of x.

Usage:
math.sinh(x)

范围	描述
`x`	表示输入值的浮点数或整数。

# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
controller.screen.print(sinh_result)

# sinh_result = 1.7520

科什 #

cosh calculates the hyperbolic cosine of x.

Usage:
math.cosh(x)

范围	描述
`x`	表示输入值的浮点数或整数。

# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
controller.screen.print(cosh_result)

# cosh_result = 1.54308

双曲正切 #

tanh calculates the hyperbolic tangent of x.

Usage:
math.tanh(x)

范围	描述
`x`	表示输入值的浮点数或整数。

# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
controller.screen.print(tanh_result)

# tanh_result = 0.76159

阿辛 #

asinh calculates the inverse hyperbolic sine of x.

Usage:
math.asinh(x)

范围	描述
`x`	表示输入值的浮点数或整数。

# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
controller.screen.print(asinh_result)

# asinh_result = 0.88137

阿科什 #

acosh calculates the inverse hyperbolic cosine of x.

Usage:
math.acosh(x)

范围	描述
`x`	大于或等于 1 的浮点数或整数。

# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
controller.screen.print(acosh_result)

# acosh_result = 1.31696

阿坦 #

atanh calculates the inverse hyperbolic tangent of x.

Usage:
math.atanh(x)

范围	描述
`x`	-1 和 1（不含）之间的浮点数。

# Calculate the inverse hyperbolic tangent of 0.5
atanh_result = math.atanh(0.5)
controller.screen.print(atanh_result)

# atanh_result = 0.54931

Rounding & Absolute Values #

天花板 #

ceil rounds a number up to the nearest integer.

Usage:
math.ceil(x)

范围	描述
`x`	要向上舍入的浮点数或整数。

# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
controller.screen.print(ceil_result)

# ceil_result = 4

地面 #

floor rounds a number down to the nearest integer.

Usage:
math.floor(x)

范围	描述
`x`	要向下舍入的浮点数或整数。

# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
controller.screen.print(floor_result)

# floor_result = 3

截断 #

trunc removes the decimal part of a number without rounding.

Usage:
math.trunc(x)

范围	描述
`x`	要截断的浮点数。

# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)

# trunc_result = 3

晶圆厂 #

fabs returns the absolute value of a number as a float.

Usage:
math.fabs(x)

范围	描述
`x`	浮点数或整数。

# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
controller.screen.print(fabs_result)

# fabs_result = 3.70000

Exponents & Logarithms #

战俘 #

pow raises x to the power of y (x^y) and returns a float.

Usage:
math.pow(x, y)

范围	描述
`x`	浮点数或整数基数。
`y`	浮点数或整数指数。

# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
controller.screen.print(power_result)

# power_result = 8.00000

平方根 #

sqrt calculates the square root of a number and returns a float.

Usage:
math.sqrt(x)

范围	描述
`x`	非负浮点数或整数。

# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)

# sqrt_result = 4.00000

经验值 #

exp returns e raised to the power of x (e^x) and as a float.

Usage:
math.exp(x)

范围	描述
`x`	浮点数或整数。

# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)

# exp_result = 2.71828

日志 #

log calculates the natural logarithm of a number and returns a float.

Usage:
math.log(x)

范围	描述
`x`	正浮点数或整数。

# Calculate the natural logarithm (base e) of 7.389056
log_result = math.log(7.389056)
controller.screen.print(log_result)

# log_result = 2.00000

log10 #

log10 calculates the base-10 logarithm of a number and returns a float.

Usage:
math.log10(x)

范围	描述
`x`	正浮点数或整数。

# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)

# log10_result = 3.00000

日志2 #

log2 calculates the base-2 logarithm of a number and returns a float, even when x is a power of 2.

Usage:
math.log2(x)

范围	描述
`x`	正浮点数或整数。

# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
controller.screen.print(log2_result)

# log2_result = 3.00000

阶乘 #

factorial returns the factorial of an integer x, which is the product of all positive integers up to x.

Usage:
math.factorial(x)

范围	描述
`x`	一个非负整数。

# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)

# factorial_result = 120

表达式1 #

expm1 calculates e^x - 1, which is more accurate for small x.

Usage:
math.expm1(x)

范围	描述
`x`	指数值。

# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
controller.screen.print(expm1_result)

# expm1_result = 1.71828

Floating Point Operations #

修改 #

modf decomposes a number into its fractional and integer parts and returns a tuple (fractional part, integer part), both as floats.

Usage:
math.modf(x)

范围	描述
`x`	要分解的浮点数或整数。

# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)

# fractional_part = 0.14159
# integer_part = 3.00000

frexp #

frexp decomposes a number into its mantissa and exponent and returns a tuple (mantissa, exponent), where the mantissa is a float and the exponent is an integer.

Usage:
math.frexp(x)

范围	描述
`x`	要分解的浮点数或整数。

# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)

# mantissa = 0.50000
# exponent = 5

fmod #

fmod returns the remainder of division while keeping the sign of the dividend (x).

Usage:
math.fmod(x, y)

范围	描述
`x`	股息。
`y`	除数。

# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
controller.screen.print(fmod_result)

# fmod_result = 1.00000

版权声明 #

copysign returns x with the sign of y.

Usage:
math.copysign(x, y)

范围	描述
`x`	要修改的值。
`y`	将被复制其符号的值。

# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
controller.screen.print(copysign_result)

# copysign_result = 10.00000

ldexp #

ldexp computes x * (2 ** exp), which is equivalent to x * 2^exp.

Usage:
math.ldexp(x, exp)

范围	描述
`x`	基值。
`exp`	指数。

# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)

# ldexp_result = 48.00000

Comparison & Approximation #

是有限的 #

isfinite checks if a number is finite. This method returns a Boolean value:

True - The number is finite.
False - The number is infinite.

Usage:
math.isfinite(x)

范围	描述
`x`	要检查的浮点数或整数。

# Check if 42 is a finite number (returns True)
is_finite_true = math.isfinite(42)
controller.screen.print(is_finite_true)

# is_finite_true = True

# Check if infinity is a finite number (returns False)
is_finite_false = math.isfinite(math.inf)
controller.screen.print(is_finite_false)

# is_finite_false = False

信息 #

isinf checks if a number is infinite. This method returns a Boolean value:

True - The number is infinite.
False - The number is finite.

Usage:
math.isinf(x)

范围	描述
`x`	要检查的浮点数或整数。

# Check if infinity is an infinite number (returns True)
is_inf_true = math.isinf(math.inf)
controller.screen.print(is_inf_true)

# is_inf_true = True

# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
controller.screen.print(is_inf_false)

# is_inf_false = False

伊斯南 #

isnan checks if a number is NaN (Not a Number). This method returns a Boolean value:

True - The number is NaN.
False - The number is a valid number.

Usage:
math.isnan(x)

范围	描述
`x`	要检查的浮点数或整数。

# Check if NaN (Not a Number) is NaN (returns True)
is_nan_true = math.isnan(math.nan)
controller.screen.print(is_nan_true)

# is_nan_true = True

# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
controller.screen.print(is_nan_false)

# is_nan_false = False

Error and Gamma Calculations #

伽马 #

gamma computes the gamma function of x, which generalizes the factorial function for real and complex numbers. For an integer n, gamma(n) = (n-1)!.

Usage:
math.gamma(x)

范围	描述
`x`	正浮点数或整数。

# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
controller.screen.print(gamma_result)

# gamma_result = 24.00000

伽玛 #

lgamma computes the natural logarithm of the gamma function.

Usage:
math.lgamma(x)

范围	描述
`x`	正浮点数或整数。

# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
controller.screen.print(lgamma_result)

# lgamma_result = 3.17805

erf #

erf computes the error function of x.

Usage:
math.erf(x)

范围	描述
`x`	表示输入值的浮点数或整数。

# Calculate the error function of 1
erf_result = math.erf(1)
controller.screen.print(erf_result)

# erf_result = 0.84270

erfc #

erfc computes the complementary error function of x, which is defined as 1 - erf(x).

Usage:
math.erfc(x)

范围	描述
`x`	表示输入值的浮点数或整数。

# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
controller.screen.print(erfc_result)

# erfc_result = 0.15730