凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

6.3 cmath--数学函数_cmath.polar

作者：凡人多烦事01 | 2024-06-01 08:09:23

踩

cmath.polar

本模块提供了处理复数的数学函数，因此这些函数接受整数、浮点数或者复数作为参数。

6.3.1 与极坐标相互转换的函数

在Python里表示一个复数z，实部使用z.real表示，虚部使用z.imag，可以使用下面的公式来表示：

z = z.real + z.imag*1j

同样，采用极坐标也可以表示一个复数，具体是这样表示复数z，采用复数z的模r和复数向量与x轴正坐标的夹角来表示。

cmath.phase(x)

返回复数在极坐标里的相位。

例子：

#python 3.4

import cmath

n = cmath.phase(complex(-1.0, 0.0))

print(n)

n = cmath.phase(complex(-1.0, -0.0))

print(n)

结果输出如下：

3.141592653589793

-3.141592653589793

cmath.polar(x)

返回复数x在极坐标的表示(r, phi)。

例子：

#python 3.4

import cmath

n = cmath.polar(complex(-1.0, 0.0))

print(n)

n = cmath.polar(complex(-1.0, -0.0))

print(n)

结果输出如下：

(1.0, 3.141592653589793)

(1.0, -3.141592653589793)

cmath.rect(r, phi)

从极坐标表示(r, phi)转换为笛卡尔坐标表示的复数。

例子：

#python 3.4

import cmath

n = cmath.rect(1.0, cmath.pi)

print(n)

结果输出如下：

(-1+1.2246467991473532e-16j)

6.4 decimal--十进制的固定数和浮点数运算

本模块提供了快速地进行十进制的浮点数运算，与内置类型float有下面几点区别：

l 十进制模块是基于人类来设计的，跟人们在学校里学习到的数学内容保持一致。

l 十进制模块的浮点数是可以准确地表示，比如1.1和2.2相加，用户一般认为是等于3.3，而不是等于3.3000000000000003。

l 正确地进行算术运算。比如0.1 + 0.1 + 0.1 - 0.3，在数学上是等于0，但在计算机的浮点数类型时，会返回5.5511151231257827e-017。

l 保留小数点后的有效位数。比如1.30 + 1.20 等于2.50，1.3*1.2等于1.56，而1.30*1.20等于1.5600。

l 跟浮点数类型不一样的地方，它可以由用户来选择合适的精度，默认是28位。

l 二进制和十进制的浮点数都是按已经发布的标准来实现。

l 十进制模块被设计来计算固定的浮点数计算。

6.4.1 简单使用介绍

要使用decimal模块，先要把此模块导入，然后使用函数getcontext()来进看精度、小数点保留多少位，以及异常处理等等。

例子：

#python 3.4

from decimal import *

print(getcontext())

结果输出如下：

Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])

十进制的模块支持从整数、字符串、浮点数或元组构造对象：

例子：

#python 3.4

from decimal import *

print(Decimal(10))

print(Decimal('3.14'))

print(Decimal(3.14))

print(Decimal((0, (3, 1, 4), -2)))

print(Decimal(str(2.0**0.5)))

print(Decimal(2)**Decimal('0.5'))

print(Decimal('NaN'))

print(Decimal('-Infinity'))

结果输出如下：

3.14

3.140000000000000124344978758017532527446746826171875

3.14

1.4142135623730951

1.414213562373095048801688724

NaN

-Infinity

打开浮点数操作时就抛出异常：

例子：

#python 3.4

from decimal import *

c = getcontext()

c.traps[FloatOperation] = True

print(Decimal('3.14'))

print(Decimal(3.14))

结果输出如下：

3.14

Traceback (most recent call last):

File "F:/temp/pywin/dec1.py", line 7, in <module>

print(Decimal(3.14))

decimal.FloatOperation: [<class 'decimal.FloatOperation'>]

改变十进制模块的位数精度、有效位取舍：

例子：

#python 3.4

from decimal import *

c = getcontext()

c.prec = 6

print(Decimal('3.14'))

print(Decimal(3.14))

print(Decimal('3.1415926535') + Decimal('2.7182818285'))

c.rounding = ROUND_UP

print(Decimal('3.1415926535') + Decimal('2.7182818285'))

结果输出如下：

3.14

3.140000000000000124344978758017532527446746826171875

5.85987

5.85988

对于浮点数的字符串进行处理：

例子：

#python 3.4

from decimal import *

data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))

print(max(data))

print(min(data))

print(sorted(data))

print(sum(data))

结果输出如下：

9.25

0.03

[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'), Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]

19.29

针对不同小数位进行取舍：

例子：

#python 3.4

from decimal import *

print(Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN))

print(Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP))

结果输出如下：

7.32

6.4.2 Decimal对象

class decimal.Decimal(value="0", context=None)

从值value构造一个Decimal对象。value的类型可以是整数、字符串、元组、浮点数或者另一个Decimal对象。如果输入是一个字符串，符合下面的规则的表达式：

sign ::= '+' | '-'

digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'

indicator ::= 'e' | 'E'

digits ::= digit [digit]...

decimal-part ::= digits '.' [digits] | ['.'] digits

exponent-part ::= indicator [sign] digits

infinity ::= 'Infinity' | 'Inf'

nan ::= 'NaN' [digits] | 'sNaN' [digits]

numeric-value ::= decimal-part [exponent-part] | infinity

numeric-string ::= [sign] numeric-value | [sign] nan

adjusted()

返回调整为指数形式之后，指数需要多少表示。

例子：

#python 3.4

from decimal import *

print(Decimal('7.325').adjusted())

print(Decimal('1000').adjusted())

print(Decimal('9000').adjusted())

print(Decimal('0.0009').adjusted())

输出结果如下：

-4

as_tuple()

返回命名的元组表示十进制数值。

例子：

#python 3.4

from decimal import *

print(Decimal('7.325').as_tuple())

print(Decimal('1000').as_tuple())

print(Decimal('9000').as_tuple())

print(Decimal('0.0009').as_tuple())

结果输出如下：

DecimalTuple(sign=0, digits=(7, 3, 2, 5), exponent=-3)

DecimalTuple(sign=0, digits=(1, 0, 0, 0), exponent=0)

DecimalTuple(sign=0, digits=(9, 0, 0, 0), exponent=0)

DecimalTuple(sign=0, digits=(9,), exponent=-4)

canonical()

返回规范的格式。

例子：

#python 3.4

from decimal import *

print(Decimal('7.325').canonical())

print(Decimal('1000').canonical())

print(Decimal('9000').canonical())

print(Decimal('0.0009').canonical())

结果输出如下：

7.325

1000

9000

0.0009

compare(other, context=None)

与其它other十进制数值比较，等于返回0，大于返回1，小于返回-1，与不是数值比较返回NaN。

例子：

#python 3.4

from decimal import *

r = Decimal('100').compare(Decimal('200'))

print(r)

r = Decimal('100').compare(Decimal('50'))

print(r)

r = Decimal('100').compare(Decimal('100'))

print(r)

r = Decimal('100').compare(Decimal('-inf'))

print(r)

r = Decimal('100').compare(Decimal('NaN'))

print(r)

结果输出如下：

-1

NaN

compare_signal(other, context=None)

除了NaN操作不一样之外，其它与compare()函数是一样的。

例子：

#python 3.4

from decimal import *

r = Decimal('100').compare_signal(Decimal('200'))

print(r)

r = Decimal('100').compare_signal(Decimal('50'))

print(r)

r = Decimal('100').compare_signal(Decimal('100'))

print(r)

r = Decimal('100').compare_signal(Decimal('-inf'))

print(r)

r = Decimal('100').compare_signal(Decimal('NaN'))

print(r)

结果输出如下：

-1

Traceback (most recent call last):

File "F:\temp\pywin\dec1.py", line 12, in <module>

r = Decimal('100').compare_signal(Decimal('NaN'))

decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

compare_total(other, context=None)

使用抽象表示方式进行比较，而不是使用值。返回的结果跟compare()函数一样。

例子：

#python 3.4

from decimal import *

r = Decimal('100').compare_total(Decimal('100'))

print(r)

r = Decimal('100').compare_total(Decimal('100.0'))

print(r)

r = Decimal('100.0').compare_total(Decimal('100'))

print(r)

结果输出如下：

-1

compare_total_mag(other, context=None)

不考虑符号的比较，与上面的函数返回值一样。

例子：

#python 3.4

from decimal import *

r = Decimal('100').compare_total_mag(Decimal('-100'))

print(r)

r = Decimal('100').compare_total_mag(Decimal('-100.0'))

print(r)

r = Decimal('100.0').compare_total_mag(Decimal('-100'))

print(r)

结果输出如下：

-1

conjugate()

返回十进制值本身。

例子：

#python 3.4

from decimal import *

r = Decimal('100').conjugate()

print(r)

结果输出如下：

100

copy_abs()

返回对象的绝对值。

例子：

#python 3.4

from decimal import *

r = Decimal('100').copy_abs()

print(r)

r = Decimal('-100').copy_abs()

print(r)

结果输出如下：

100

copy_negate()

返回相反数。

例子：

#python 3.4

from decimal import *

r = Decimal('100').copy_negate()

print(r)

r = Decimal('-100').copy_negate()

print(r)

结果输出如下：

-100

100

copy_sign(other, context=None)

从另外十进制对象获取符号，本对象取绝对值。

例子：

#python 3.4

from decimal import *

r = Decimal('100').copy_sign(Decimal('-1.0'))

print(r)

r = Decimal('-100').copy_sign(Decimal('-1.0'))

print(r)

结果输出如下：

-100

exp(context=None)

返回这个值的自然指数值，e**x。

例子：

#python 3.4

from decimal import *

r = Decimal('1').exp()

print(r)

r = Decimal('-100').exp()

print(r)

结果输出如下：

2.718281828459045235360287471

3.720075976020835962959695804E-44

from_float(f)

转换一个浮点数为十进制数。与字符串转换过来的浮点数有差别。

例子：

#python 3.4

from decimal import *

r = Decimal(0.1)

print(r)

结果输出如下：

0.1000000000000000055511151231257827021181583404541015625

fma(other, third, context=None)

返回乘加值，self*other + third。

例子：

#python 3.4

from decimal import *

r = Decimal(0.1).fma(10, 2)

print(r)

结果输出如下：

3.000000000000000055511151231

is_canonical()

如果对象符合规范的十进制数，就返回True，目前全部返回True。

例子：
#python 3.4

from decimal import *

r = Decimal(0.1).is_canonical()

print(r)

结果输出如下：

True

is_finite()

判断对象是否表示有限的数值，如果是返回True，否则返回False。

例子：

#python 3.4

from decimal import *

r = Decimal(0.1).is_finite()

print(r)

r = Decimal('inf').is_finite()

print(r)

结果输出如下：

True

False

is_infinite()

判断对象是否无限的值，如果是返回True，否则返回False。

例子：

#python 3.4

from decimal import *

r = Decimal(0.1).is_infinite()

print(r)

r = Decimal('inf').is_infinite()

print(r)

r = Decimal('NaN').is_infinite()

print(r)

结果输出如下：

False

True

False

is_nan()

是否一个非数字的值，如果是返回True，否则返回False。

例子：

#python 3.4

from decimal import *

r = Decimal(0.1).is_nan()

print(r)

r = Decimal('inf').is_nan()

print(r)

r = Decimal('NaN').is_nan()

print(r)

结果输出如下：

False

True

is_normal(context=None)

如果值是正常的有限值返回True。比如0，非数字，无穷大等值返回False。

例子：

#python 3.4

from decimal import *

r = Decimal(0.1).is_normal()

print(r)

r = Decimal('inf').is_normal()

print(r)

r = Decimal('NaN').is_normal()

print(r)

r = Decimal(0).is_normal()

print(r)

结果输出如下：

True

False

is_qnan()

判断值是否一个确定的非数字值。

例子：

#python 3.4

from decimal import *

r = Decimal(0.1).is_qnan()

print(r)

r = Decimal('inf').is_qnan()

print(r)

r = Decimal('NaN').is_qnan()

print(r)

r = Decimal(0).is_qnan()

print(r)

结果输出如下：

False

True

False

is_signed()

如果值是负数返回True，否则返回False。

例子：

#python 3.4

from decimal import *

r = Decimal(-0.1).is_signed()

print(r)

r = Decimal('+inf').is_signed()

print(r)

r = Decimal('NaN').is_signed()

print(r)

结果输出如下：

True

False

is_snan()

如果参数是一个有符号的NaN数，就返回True，其它返回False。

例子：

#python 3.4

from decimal import *

r = Decimal(-0.1).is_snan()

print(r)

r = Decimal('+inf').is_snan()

print(r)

r = Decimal('-inf').is_snan()

print(r)

r = Decimal('-NaN').is_snan()

print(r)

结果输出如下：

False

is_subnormal(context=None)

判断一个浮点数是否表示为一个非规标准化的浮点小数。

例子：

#python 3.4

from decimal import *

r = Decimal('0.001').is_subnormal()

print(r)

r = Decimal('+inf').is_subnormal()

print(r)

r = Decimal('-inf').is_subnormal()

print(r)

r = Decimal('-NaN').is_subnormal()

print(r)

结果输出如下：

False

is_zero()

判断值是否为0，如果是返回True，否则返回False。

例子：

#python 3.4

from decimal import *

r = Decimal('0.00').is_zero()

print(r)

r = Decimal('+inf').is_zero()

print(r)

r = Decimal('-inf').is_zero()

print(r)

r = Decimal('-NaN').is_zero()

print(r)

结果输出如下：

True

False

ln(context=None)

返回自然对数值。

例子：

#python 3.4

from decimal import *

r = Decimal('0.00').ln()

print(r)

r = Decimal('5.00').ln()

print(r)

结果输出如下：

-Infinity

1.609437912434100374600759333

log10(context=None)

返回10为底数的对数值。

例子：

#python 3.4

from decimal import *

r = Decimal('0.00').log10()

print(r)

r = Decimal('5.00').log10()

print(r)

结果输出如下：

-Infinity

0.6989700043360188047862611053

logb(context=None)

判断一个数值是否为0，如果非0就返回相应的值，否则抛出异常。

例子：

#python 3.4

from decimal import *

r = Decimal('0.00').logb()

print(r)

r = Decimal('5.00').logb()

print(r)

结果输出如下：

Traceback (most recent call last):

File "F:\temp\pywin\dec1.py", line 4, in <module>

r = Decimal('0.00').logb()

decimal.DivisionByZero: [<class 'decimal.DivisionByZero'>]

logical_and(other, context=None)

logical_invert(context=None)

logical_or(other, context=None)

logical_xor(other, context=None)

十进制表示的逻辑操作运算，值只能0和1，其它值会抛出异常。

例子：

#python 3.4

from decimal import *

r = Decimal('1').logical_and(Decimal('1'))

print(r)

r = Decimal('1').logical_and(Decimal('0'))

print(r)

结果输出如下：

max(other, context=None)

返回最大值，并且经过规范处理。

例子：

#python 3.4

from decimal import *

r = Decimal('1').max(Decimal('1.000003'))

print(r)

r = Decimal('1').max(Decimal('0'))

print(r)

结果输出如下：

1.000003

max_mag(other, context=None)

对对象先取绝对值，再进行比较，返回最大值的数。

例子：

#python 3.4

from decimal import *

r = Decimal('1').max_mag(Decimal('-1.000003'))

print(r)

r = Decimal('1').max_mag(Decimal('0'))

print(r)

结果输出如下：

-1.000003

min(other, context=None)

min_mag(other, context=None)

这两个函数跟上面的函数相似，只是返回最小值。

next_minus(context=None)

返回比当前值相差最小的值。

例子：

#python 3.4

from decimal import *

r = Decimal('1').next_minus()

print(r)

r = Decimal('0').next_minus()

print(r)

结果输出如下：

0.9999999999999999999999999999

-1E-1000026

next_plus(context=None)

返回与当前值相差最小的最大值。

例子：

#python 3.4

from decimal import *

r = Decimal('1').next_plus()

print(r)

r = Decimal('0').next_plus()

print(r)

结果输出如下：

1.000000000000000000000000001

1E-1000026

next_toward(other, context=None)

根据参数other来决定向正值还是向负值找到下一个增加或减少的值。

例子：

#python 3.4

from decimal import *

r = Decimal('1').next_toward(Decimal('10'))

print(r)

r = Decimal('8').next_toward(Decimal('-10'))

print(r)

结果输出如下：

1.000000000000000000000000001

7.999999999999999999999999999

normalize(context=None)

删除最右边的0，把值表示为Decimal(‘0’)到Decimal(‘0e0’)的格式。

例子：

#python 3.4

from decimal import *

r = Decimal('10000').normalize()

print(r)

r = Decimal('0.0004000').normalize()

print(r)

结果输出如下：

1E+4

0.0004

number_class(context=None)

返回对数值表示的描述。主要有以下10项：

"-Infinity", 指出操作数是负无穷大。

"-Normal", 指出操作数是负数和标准的数。

"-Subnormal", 指出操作数是负数和非规范的数。

"-Zero", 指出操作数是负零值。

"+Zero", 指出操作数是正零值。

"+Subnormal", 指出操作数是正数和非规范的数。

"+Normal", 指出操作数是正数和标准的数。

"+Infinity", 指出操作数是正数和无穷大的数。

"NaN", 指出操作数是正的非数字的数。

"sNaN", 指出操作数是有符号的非数字的数。

例子：

#python 3.4

from decimal import *

r = Decimal('10000').number_class()

print(r)

结果输出如下：

+Normal

quantize(exp, rounding=None, context=None, watchexp=True)

把值按参数exp来保持小数点的位数。

例子：

#python 3.4

from decimal import *

r = Decimal('1.41421356').quantize(Decimal('1.000'))

print(r)

r = Decimal('1.41421356').quantize(Decimal('2.0'))

print(r)

结果输出如下：

1.414

1.4

radix()

返回Decimal(10)的值，表示10进制的数字。

例子：

#python 3.4

from decimal import *

r = Decimal('1.41421356').radix()

print(r)

r = Decimal('0.001').radix()

print(r)

结果输出如下：

remainder_near(other, context=None)

返回最接近的余数，余数可以是正数，也可以是负数。

例子：

#python 3.4

from decimal import *

r = Decimal('18').remainder_near(Decimal(10))

print(r)

r = Decimal('25').remainder_near(Decimal(10))

print(r)

r = Decimal('35').remainder_near(Decimal(10))

print(r)

结果输出如下：

-2

-5

rotate(other, context=None)

对值按other进行左移运算。

例子：

#python 3.4

from decimal import *

r = Decimal('18').rotate(Decimal(2))

print(r)

r = Decimal('180').rotate(Decimal(1))

print(r)

结果输出如下：

1800

same_quantum(other, context=None)

判断两个数的小数部分是否有相同有效位数。

例子：

#python 3.4

from decimal import *

r = Decimal('18.23').same_quantum(Decimal('2.1'))

print(r)

r = Decimal('18.23').same_quantum(Decimal('2.10'))

print(r)

r = Decimal('18.23').same_quantum(Decimal(2.10))

print(r)

结果输出如下：

False

True

False

scaleb(other, context=None)

通过参数other对值进行调整，参数other必须是一个整数，相当于10**other。

例子：

#python 3.4

from decimal import *

r = Decimal('18.23').scaleb(Decimal(2))

print(r)

r = Decimal('18.233333').scaleb(Decimal(3))

print(r)

结果输出如下：

1823

18233.333

shift(other, context=None)

根据参数other进行左移数值。

例子：

#python 3.4

from decimal import *

r = Decimal('18.23').shift(Decimal(2))

print(r)

r = Decimal('18.233333').shift(Decimal(3))

print(r)

结果输出如下：

1823.00

18233.333000

sqrt(context=None)

计算平方根。

例子：

#python 3.4

from decimal import *

r = Decimal('18.23').sqrt()

print(r)

结果输出如下：

4.269660408041838636080849820

to_eng_string(context=None)

把值转换为工程方式表示。

例子：

#python 3.4

from decimal import *

r = Decimal('18.23').to_eng_string()

print(r)

r = Decimal('1823E+1').to_eng_string()

print(r)

结果输出如下：

18.23

18.23E+3

to_integral(rounding=None, context=None)

to_integral_value(rounding=None, context=None)

返回最接近的整数。

例子：

#python 3.4

from decimal import *

r = Decimal('18.23').to_integral()

print(r)

r = Decimal('182.7').to_integral()

print(r)

结果输出如下：

183

to_integral_exact(rounding=None, context=None)

返回最接近的整数，但置信号给Inexact或Rounded。

例子：

#python 3.4

from decimal import *

r = Decimal('18.23').to_integral_exact()

print(r, Inexact, Rounded)

r = Decimal('182.7').to_integral_exact()

print(r, Inexact)

结果输出如下：

18 <class 'decimal.Inexact'> <class 'decimal.Rounded'>

183 <class 'decimal.Inexact'>

蔡军生 QQ:9073204 深圳

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/656786