Help on class complex in module __builtin__:


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

 |  

 |  __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__ =

 |      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 "", line 1, in

ValueError: complex() arg is a malformed string