浮点型float

Posted 2020-12-28 skyzy

浮点型float

class float(object):

float(x) -> floating point number

Convert a string or number to a floating point number, if possible.

def as_integer_ratio(self):

获取改值的最简比

float.as_integer_ratio() -> (int, int)

Return a pair of integers, whose ratio is exactly equal to the original

float and with a positive denominator.

Raise OverflowError on infinities and a ValueError on NaNs.

>>> (10.0).as_integer_ratio()

(10, 1)

>>> (0.0).as_integer_ratio()

(0, 1)

>>> (-.25).as_integer_ratio()

(-1, 4)

def conjugate(self, *args, **kwargs):

Return self, the complex conjugate of any float.

def fromhex(self, string):

将十六进制字符串转换成浮点型

float.fromhex(string) -> float

Create a floating-point number from a hexadecimal string.

>>> float.fromhex(‘0x1.ffffp10‘)

2047.984375

>>> float.fromhex(‘-0x1p-1074‘)

-4.9406564584124654e-324

def hex(self): 返回当前值的 16 进制表示

float.hex() -> string

Return a hexadecimal representation of a floating-point number.

>>> (-0.1).hex()

‘-0x1.999999999999ap-4‘

>>> 3.14159.hex()

‘0x1.921f9f01b866ep+1‘

def is_integer(self, *args, **kwargs):Return True if the float is an integer.

def __abs__(self):

x.__abs__() <==> abs(x)

def __add__(self, y):

x.__add__(y) <==> x+y

def __coerce__(self, y):

x.__coerce__(y) <==> coerce(x, y)

def __divmod__(self, y):

x.__divmod__(y) <==> divmod(x, y)

def __div__(self, y):

x.__div__(y) <==> x/y

def __eq__(self, y):

x.__eq__(y) <==> x==y

def __float__(self):

x.__float__() <==> float(x)

def __floordiv__(self, y):

x.__floordiv__(y) <==> x//y

def __format__(self, format_spec):

float.__format__(format_spec) -> string

Formats the float according to format_spec.

def __getattribute__(self, name):

x.__getattribute__(‘name‘) <==> x.name

def __getformat__(self, typestr):

float.__getformat__(typestr) -> string

typestr must be ‘double‘ or ‘float‘. This function returns whichever of

‘unknown‘, ‘IEEE, big-endian‘ or ‘IEEE, little-endian‘ best describes the

format of floating point numbers used by the C type named by typestr.

def __getnewargs__(self, *args, **kwargs):

def __ge__(self, y):

x.__ge__(y) <==> x>=y

def __gt__(self, y):

x.__gt__(y) <==> x>y

def __hash__(self):

x.__hash__() <==> hash(x)

def __init__(self, x):

def __int__(self):

x.__int__() <==> int(x)

def __le__(self, y):

x.__le__(y) <==> x<=y

def __long__(self):

x.__long__() <==> long(x)

def __lt__(self, y):

x.__lt__(y) <==> x<y

def __mod__(self, y):

x.__mod__(y) <==> x%y

def __mul__(self, y):

x.__mul__(y) <==> x*y

def __neg__(self):

x.__neg__() <==> -x

@staticmethod # known case of __new__

def __new__(S, *more):

T.__new__(S, ...) -> a new object with type S, a subtype of T

def __ne__(self, y):

x.__ne__(y) <==> x!=y

def __nonzero__(self):

x.__nonzero__() <==> x != 0

def __pos__(self):

x.__pos__() <==> +x

def __pow__(self, y, z=None):

x.__pow__(y[, z]) <==> pow(x, y[, z])

def __radd__(self, y):

x.__radd__(y) <==> y+x

def __rdivmod__(self, y):

x.__rdivmod__(y) <==> divmod(y, x)

def __rdiv__(self, y):

x.__rdiv__(y) <==> y/x

def __repr__(self):

x.__repr__() <==> repr(x)

def __rfloordiv__(self, y):

x.__rfloordiv__(y) <==> y//x

def __rmod__(self, y):

x.__rmod__(y) <==> y%x

def __rmul__(self, y):

x.__rmul__(y) <==> y*x

def __rpow__(self, x, z=None):

y.__rpow__(x[, z]) <==> pow(x, y[, z])

def __rsub__(self, y):

x.__rsub__(y) <==> y-x

def __rtruediv__(self, y):

x.__rtruediv__(y) <==> y/x

def __setformat__(self, typestr, fmt):

float.__setformat__(typestr, fmt) -> None

typestr must be ‘double‘ or ‘float‘. fmt must be one of ‘unknown‘,

‘IEEE, big-endian‘ or ‘IEEE, little-endian‘, and in addition can only be

one of the latter two if it appears to match the underlying C reality.

Override the automatic determination of C-level floating point type.

This affects how floats are converted to and from binary strings.

def __str__(self):

x.__str__() <==> str(x)

def __sub__(self, y):

x.__sub__(y) <==> x-y

def __truediv__(self, y):

x.__truediv__(y) <==> x/y

def __trunc__(self, *args, **kwargs):Return the Integral closest to x between 0 and x.