python内置函数3-complex()

yzwj2004

　　Help on>　　class complex(object)
　　|  complex(real[, imag]) -> complex number
　　|
　　|  Create a complex number from a real part and an optional imaginary part.
　　|  This is equivalent to (real + imag*1j) where imag defaults to 0.
　　|
　　|  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
　　|
　　|  __ge__(...)
　　|      x.__ge__(y) <==> x>=y
　　|
　　|  __getattribute__(...)
　　|      x.__getattribute__('name') <==> x.name
　　|
　　|  __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
　　|
　　|  __str__(...)
　　|      x.__str__() <==> str(x)
　　|
　　|  __sub__(...)
　　|      x.__sub__(y) <==> x-y
　　|
　　|  __truediv__(...)
　　|      x.__truediv__(y) <==> x/y
　　|
　　|  conjugate(...)
　　|      complex.conjugate() -> complex
　　|
　　|      Returns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
　　|
　　|  ----------------------------------------------------------------------
　　|  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
　　class complex([real[, imag]])
　　Return a complex number with the value real + imag*1j or convert a string or number to a complex number. If the first parameter is a string, it will be interpreted as a complex number and the function must be called without a second parameter. The second parameter can never be a string. Each argument may be any numeric type (including complex). If imag is omitted, it defaults to zero and the function serves as a numeric conversion function like int(), long() and float(). If both arguments are omitted, returns 0j.
　　Note When converting from a string, the string must not contain whitespace around the central + or - operator. For example, complex('1+2j') is fine, but complex('1 + 2j') raises ValueError.
　　The complex type is described in Numeric Types — int, float, long, complex.
　　中文说明：
　　创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
　　参数real: int, long, float或字符串；
　　参数imag: int, long, float。
　　>>> complex(5,3)
　　(5+3j)
　　>>> complex(7)
　　(7+0j)
　　>>> complex("56")
　　(56+0j)
　　>>> complex("7+8j")
　　(7+8j)
　　>>> complex("7 + 8j")
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　ValueError: complex() arg is a malformed string