int



>>> int(x=0)

>>> int(x, base=10)


전달한 숫자 혹은 문자열, x를 기반으로 정수 값을 돌려준다.

만약 인자가 없다면 기본 값 0을 돌려준다. 


인자가 숫자일 경우, plain integer, long integer, floating point number가 입력될 수 있다. 


plain integer의 경우 int 형으로 반환하고, long integer의 경우 long 형으로 반환한다. (참고> plain integer와 long integer 범위)

반면 floating point number의 경우는 소수점 이하는 버리고 int 혹은 long 형으로 반환한다. 


인자가 앞서 언급한 숫자형이 아니거나 base(진법) 인자가 같이 넘어올 경우 문자열이나 unicode object가 인자 x로 전달되어야 한다. 

(진법 인자를 전달하지 않을 때는 기본으로 10진법 기반)


문자열로 넘어올 때 부호가 같이 넘어올 수도 있는데 문자열내 부호와 숫자 사이에는 공란이 없어야 한다. 


그리고 진법 인자는 36까지 전달이 가능한데, 이는 0123456789 숫자와 abcdefghijklmnopqrstuvwxyz 문자를 가지고 표현 가능한 최대 진법이 36진법이기 때문이다. 


__builtin__ module에 포함된 class 이다. 



예제)


인자로 숫자(plain integer, long integer, float point number)가 전달되었을 경우

>>> int(1)
1
>>> type(int(1))
<type 'int'>
>>> int(9223372036854775808)
9223372036854775808L
>>> type(int(9223372036854775808))
<type 'long'>
>>> int(1.2)
1
>>> type(int(1.2))
<type 'int'>
>>> int(1.8)
1
>>> type(int(1.8))
<type 'int'>


인자로 문자열이 전달되었을 경우

>>> int('1')
1


진법(base)인자가 함께 전달되었을 경우

>>> int('a',base=16)
10
>>> int('z',base=36)
35

잘못된 인자가 전달될 경우 아래와 같은 에러가 발생할 수 있다. 


지원가능한 진법을 벗어난 진법(base)인자가 전달되었을 경우

>>> int('z',base=37)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: int() base must be >= 2 and <= 36

설정한 진법에서 사용 불가능한 문자가 전달되었을 경우
>>> int('z',base=35)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 35: 'z'

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


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



string 변환 method 사용의 예)

>>> int('1').__str__()
'1'



>>> help(int)


Help on class int in module __builtin__:


class int(object)

 |  int(x=0) -> int or long

 |  int(x, base=10) -> int or long

 |

 |  Convert a number or string to an integer, or return 0 if no arguments

 |  are given.  If x is floating point, the conversion truncates towards zero.

 |  If x is outside the integer range, the function returns a long instead.

 |

 |  If x is not a number or if base is given, then x must be a string or

 |  Unicode object representing an integer literal in the given base.  The

 |  literal can be preceded by '+' or '-' and be surrounded by whitespace.

 |  The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to

 |  interpret the base from the string as an integer literal.

 |  >>> int('0b100', base=0)

 |  4

 |

 |  Methods defined here:

 |

 |  __abs__(...)

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

 |

 |  __add__(...)

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

 |

 |  __and__(...)

 |      x.__and__(y) <==> x&y

 |

 |  __cmp__(...)

 |      x.__cmp__(y) <==> cmp(x,y)

 |

 |  __coerce__(...)

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

 |

 |  __div__(...)

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

 |

 |  __divmod__(...)

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

 |

 |  __float__(...)

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

 |

 |  __floordiv__(...)

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

 |

 |  __format__(...)

 |

 |  __getattribute__(...)

 |      x.__getattribute__('name') <==> x.name

 |

 |  __getnewargs__(...)

 |

 |  __hash__(...)

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

 |

 |  __hex__(...)

 |      x.__hex__() <==> hex(x)

 |

 |  __index__(...)

 |      x[y:z] <==> x[y.__index__():z.__index__()]

 |

 |  __int__(...)

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

 |

 |  __invert__(...)

 |      x.__invert__() <==> ~x

 |

 |  __long__(...)

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

 |

 |  __lshift__(...)

 |      x.__lshift__(y) <==> x<<y

 |

 |  __mod__(...)

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

 |

 |  __mul__(...)

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

 |

 |  __neg__(...)

 |      x.__neg__() <==> -x

 |

 |  __nonzero__(...)

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

 |

 |  __oct__(...)

 |      x.__oct__() <==> oct(x)

 |

 |  __or__(...)

 |      x.__or__(y) <==> x|y

 |

 |  __pos__(...)

 |      x.__pos__() <==> +x

 |

 |  __pow__(...)

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

 |

 |  __radd__(...)

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

 |

 |  __rand__(...)

 |      x.__rand__(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

 |

 |  __rlshift__(...)

 |      x.__rlshift__(y) <==> y<<x

 |

 |  __rmod__(...)

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

 |

 |  __rmul__(...)

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

 |

 |  __ror__(...)

 |      x.__ror__(y) <==> y|x

 |

 |  __rpow__(...)

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

 |

 |  __rrshift__(...)

 |      x.__rrshift__(y) <==> y>>x

 |

 |  __rshift__(...)

 |      x.__rshift__(y) <==> x>>y

 |

 |  __rsub__(...)

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

 |

 |  __rtruediv__(...)

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

 |

 |  __rxor__(...)

 |      x.__rxor__(y) <==> y^x

 |

 |  __str__(...)

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

 |

 |  __sub__(...)

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

 |

 |  __truediv__(...)

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

 |

 |  __trunc__(...)

 |      Truncating an Integral returns itself.

 |

 |  __xor__(...)

 |      x.__xor__(y) <==> x^y

 |

 |  bit_length(...)

 |      int.bit_length() -> int

 |

 |      Number of bits necessary to represent self in binary.

 |      >>> bin(37)

 |      '0b100101'

 |      >>> (37).bit_length()

 |      6

 |

 |  conjugate(...)

 |      Returns self, the complex conjugate of any int.

 |

 |  ----------------------------------------------------------------------

 |  Data descriptors defined here:

 |

 |  denominator

 |      the denominator of a rational number in lowest terms

 |

 |  imag

 |      the imaginary part of a complex number

 |

 |  numerator

 |      the numerator of a rational number in lowest terms

 |

 |  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