complex



>>> complex([real[,imag]])


real, imag 값을 전달하면 해당 복소수를 반환하거나 

문자열 혹은 숫자를 복소수로 변환한다.


__builtin__ module에 포함된 class 이다. 


예제)


real, imag 값을 정수(int)/실수(float)로 전달하는 경우

>>> complex(1,1)
(1+1j)
>>> complex(1.1,2.2)
(1.1+2.2j)


imag 값이 생략되는 경우

>>> complex(1)
(1+0j)


두 인자 모두 생략되는 경우

>>> complex()
0j


첫번째 인자를 문자열로 전달하는 경우 (두번째 인자는 없음)

>>> complex("1+1j")
(1+1j)


complex는 일반 function이 아니고 class 이다. 


따라서 해당 class에 포함된 다양한 method 사용이 가능하다. 



string 변환 method 사용의 예)

>>> complex(1).__str__()
'(1+0j)'



>>> help(complex)


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

 |

 |  __format__(...)

 |      complex.__format__() -> str

 |

 |      Convert to a string according to format_spec.

 |

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

 |

 |      Return 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