Help on class float in module __builtin__:
class float(object)
| float(x) -> floating point number
|
| Convert a string or number to a floating point number, if possible.
|
| Methods defined here:
|
| __abs__(...)
| x.__abs__() <==> abs(x)
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __coerce__(...)
| x.__coerce__(y) <==> coerce(x, y)
|
| __div__(...)
| x.__div__(y) <==> x/y
|
| __divmod__(...)
| x.__divmod__(y) <==> divmod(x, y)
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __float__(...)
| x.__float__() <==> float(x)
|
| __floordiv__(...)
| x.__floordiv__(y) <==> x//y
|
| __format__(...)
| float.__format__(format_spec) -> string
|
| Formats the float according to format_spec.
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getattribute__(...)
| x.__getattribute__(‘name‘) <==> x.name
|
| __getformat__(...)
| float.__getformat__(typestr) -> string
|
| You probably don‘t want to use this function. It exists mainly to be
| used in Python‘s test suite.
|
| 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.
|
| __getnewargs__(...)
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __hash__(...)
| x.__hash__() <==> hash(x)
|
| __int__(...)
| x.__int__() <==> int(x)
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __long__(...)
| x.__long__() <==> long(x)
|
| __lt__(...)
| x.__lt__(y) <==> x<y
|
| __mod__(...)
| x.__mod__(y) <==> x%y
|
| __mul__(...)
| x.__mul__(y) <==> x*y
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __neg__(...)
| x.__neg__() <==> -x
|
| __nonzero__(...)
| x.__nonzero__() <==> x != 0
|
| __pos__(...)
| x.__pos__() <==> +x
|
| __pow__(...)
| x.__pow__(y[, z]) <==> pow(x, y[, z])
|
| __radd__(...)
| x.__radd__(y) <==> y+x
|
| __rdiv__(...)
| x.__rdiv__(y) <==> y/x
|
| __rdivmod__(...)
| x.__rdivmod__(y) <==> divmod(y, x)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __rfloordiv__(...)
| x.__rfloordiv__(y) <==> y//x
|
| __rmod__(...)
| x.__rmod__(y) <==> y%x
|
| __rmul__(...)
| x.__rmul__(y) <==> y*x
|
| __rpow__(...)
| y.__rpow__(x[, z]) <==> pow(x, y[, z])
|
| __rsub__(...)
| x.__rsub__(y) <==> y-x
|
| __rtruediv__(...)
| x.__rtruediv__(y) <==> y/x
|
| __setformat__(...)
| float.__setformat__(typestr, fmt) -> None
|
| You probably don‘t want to use this function. It exists mainly to be
| used in Python‘s test suite.
|
| 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.
|
| Overrides the automatic determination of C-level floating point type.
| This affects how floats are converted to and from binary strings.
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __sub__(...)
| x.__sub__(y) <==> x-y
|
| __truediv__(...)
| x.__truediv__(y) <==> x/y
|
| __trunc__(...)
| Returns the Integral closest to x between 0 and x.
|
| as_integer_ratio(...)
| float.as_integer_ratio() -> (int, int)
|
| Returns a pair of integers, whose ratio is exactly equal to the original
| float and with a positive denominator.
| Raises 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)
|
| conjugate(...)
| Returns self, the complex conjugate of any float.
|
| fromhex(...)
| 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
|
| hex(...)
| float.hex() -> string
|
| Return a hexadecimal representation of a floating-point number.
| >>> (-0.1).hex()
| ‘-0x1.999999999999ap-4‘
| >>> 3.14159.hex()
| ‘0x1.921f9f01b866ep+1‘
|
| is_integer(...)
| Returns True if the float is an integer.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| imag
| the imaginary part of a complex number
|
| real
| the real part of a complex number
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
filter(function, iterable)
Construct a list from those elements of iterable for which function returns true. iterable may be either a sequence, a container which supports iteration, or an iterator. If iterable is a string or a tuple, the result also has that type; otherwise it is always a list. If function is None, the identity function is assumed, that is, all elements of iterable that are false are removed.
Note that filter(function, iterable) is equivalent to [item for item in iterable if function(item)] if function is not None and [item for item in iterable if item] if function is None.
See itertools.ifilter() and itertools.ifilterfalse() for iterator versions of this function, including a variation that filters for elements where the function returns false.
中文说明：
本函数是转换一个字符串或一个整数为浮点数。如果参数x是一个字符串，那么只使用十进制表示的数字串，数字前面可以添加符号来表示正数，或负数。如果参数x是整数，可以转换为浮点数表示。不过，这个函数有一个特别的地方，就是使用infinity或inf来表示无穷大的数。比如+inf是正无穷大，-inf是负无穷大。
>>> float(6)
6.0
>>> float(‘6‘)
6.0
>>> float()
0.0
>>> float(‘+5.778‘)
5.778
>>> float(‘-5.778‘)
-5.778
>>> float(‘+inf‘)
inf
>>> float(‘-inf‘)
-inf
>>> float(‘nan‘)
nan
>>> class T:
... def __init__(self,score):
... self.score = score
... def __float__(self):
... return self.score
...
>>> x=T(10.68)
>>> float(x)
10.68