__builtin_

Module __builtin__ :: Class int

[show private | hide private]

Type int

object --+
         |
        int

Known Subclasses:: enum

int(x[, base]) -> integer

Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string. If the argument is outside the integer range a long object will be returned instead.

Method Summary
	`__abs__(x)` x.__abs__() <==> abs(x)
	`__add__(x, y)` x.__add__(y) <==> x+y
	`__and__(x, y)` x.__and__(y) <==> x&y
	`__cmp__(x, y)` x.__cmp__(y) <==> cmp(x,y)
	`__coerce__(x, y)` x.__coerce__(y) <==> coerce(x, y)
	`__div__(x, y)` x.__div__(y) <==> x/y
	`__divmod__(x, y)` x.__divmod__(y) <==> xdivmod(x, y)y
	`__float__(x)` x.__float__() <==> float(x)
	`__floordiv__(x, y)` x.__floordiv__(y) <==> x//y
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__getnewargs__(...)`
	`__hash__(x)` x.__hash__() <==> hash(x)
	`__hex__(x)` x.__hex__() <==> hex(x)
	`__int__(x)` x.__int__() <==> int(x)
	`__invert__(x)` x.__invert__() <==> ~x
	`__long__(x)` x.__long__() <==> long(x)
	`__lshift__(x, y)` x.__lshift__(y) <==> x<<y
	`__mod__(x, y)` x.__mod__(y) <==> x%y
	`__mul__(x, y)` x.__mul__(y) <==> x*y
	`__neg__(x)` x.__neg__() <==> -x
	`__new__(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
	`__nonzero__(x)` x.__nonzero__() <==> x != 0
	`__oct__(x)` x.__oct__() <==> oct(x)
	`__or__(x, y)` x.__or__(y) <==> x\|y
	`__pos__(x)` x.__pos__() <==> +x
	`__pow__(x, y, z)` x.__pow__(y[, z]) <==> pow(x, y[, z])
	`__radd__(x, y)` x.__radd__(y) <==> y+x
	`__rand__(x, y)` x.__rand__(y) <==> y&x
	`__rdiv__(x, y)` x.__rdiv__(y) <==> y/x
	`__rdivmod__(x, y)` x.__rdivmod__(y) <==> ydivmod(y, x)x
	`__repr__(x)` x.__repr__() <==> repr(x)
	`__rfloordiv__(x, y)` x.__rfloordiv__(y) <==> y//x
	`__rlshift__(x, y)` x.__rlshift__(y) <==> y<<x
	`__rmod__(x, y)` x.__rmod__(y) <==> y%x
	`__rmul__(x, y)` x.__rmul__(y) <==> y*x
	`__ror__(x, y)` x.__ror__(y) <==> y\|x
	`__rpow__(y, x, z)` y.__rpow__(x[, z]) <==> pow(x, y[, z])
	`__rrshift__(x, y)` x.__rrshift__(y) <==> y>>x
	`__rshift__(x, y)` x.__rshift__(y) <==> x>>y
	`__rsub__(x, y)` x.__rsub__(y) <==> y-x
	`__rtruediv__(x, y)` x.__rtruediv__(y) <==> y/x
	`__rxor__(x, y)` x.__rxor__(y) <==> y^x
	`__str__(x)` x.__str__() <==> str(x)
	`__sub__(x, y)` x.__sub__(y) <==> x-y
	`__truediv__(x, y)` x.__truediv__(y) <==> x/y
	`__xor__(x, y)` x.__xor__(y) <==> x^y
Inherited from object
	`__init__(...)` x.__init__(...) initializes x; see x.__class__.__doc__ for signature
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__reduce__(...)` helper for pickle
	`__reduce_ex__(...)` helper for pickle
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value

Method Details

abs(x)

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

Returns:

abs(x)

add(x, y)
(Addition operator)

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

Returns:

x+y

and(x, y)
(And operator)

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

Returns:

x&y

cmp(x, y)
(Comparison operator)

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

Returns:

cmp(x,y)

coerce(x, y)

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

Returns:

coerce(x, y)

div(x, y)

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

Returns:

x/y

divmod(x, y)

x.__divmod__(y) <==> xdivmod(x, y)y

Returns:

xdivmod(x, y)y

float(x)

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

Returns:

float(x)

floordiv(x, y)

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

Returns:

x//y

getattribute(...)

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

Overrides:: __builtin__.object.__getattribute__

hash(x)
(Hashing function)

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

Returns:

hash(x)

Overrides:: __builtin__.object.__hash__

hex(x)

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

Returns:

hex(x)

int(x)

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

Returns:

int(x)

invert(x)

x.__invert__() <==> ~x

Returns:

~x

long(x)

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

Returns:

long(x)

lshift(x, y)

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

Returns:

x<<y

mod(x, y)

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

Returns:

x%y

mul(x, y)

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

Returns:

x*y

neg(x)

x.__neg__() <==> -x

Returns:

-x

new(T, S, ...)

T.__new__(S, ...) -> a new object with type S, a subtype of T

Returns:

a new object with type S, a subtype of T

Overrides:: __builtin__.object.__new__

nonzero(x)
(Boolean test operator)

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

Returns:

x != 0

oct(x)

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

Returns:

oct(x)

or(x, y)
(Or operator)

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

Returns:

x|y

pos(x)

x.__pos__() <==> +x

Returns:

+x

pow(x, y, z=...)

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

Returns:

pow(x, y[, z])

radd(x, y)
(Right-side addition operator)

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

Returns:

y+x

rand(x, y)

x.__rand__(y) <==> y&x

Returns:

y&x

rdiv(x, y)

x.__rdiv__(y) <==> y/x

Returns:

y/x

rdivmod(x, y)

x.__rdivmod__(y) <==> ydivmod(y, x)x

Returns:

ydivmod(y, x)x

repr(x)
(Representation operator)

x.__repr__() <==> repr(x)

Returns:

repr(x)

Overrides:: __builtin__.object.__repr__

rfloordiv(x, y)

x.__rfloordiv__(y) <==> y//x

Returns:

y//x

rlshift(x, y)

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

Returns:

y<<x

rmod(x, y)

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

Returns:

y%x

rmul(x, y)

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

Returns:

y*x

ror(x, y)

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

Returns:

y|x

rpow(y, x, z=...)

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

Returns:

pow(x, y[, z])

rrshift(x, y)

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

Returns:

y>>x

rshift(x, y)

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

Returns:

x>>y

rsub(x, y)

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

Returns:

y-x

rtruediv(x, y)

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

Returns:

y/x

rxor(x, y)

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

Returns:

y^x

str(x)
(Informal representation operator)

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

Returns:

str(x)

Overrides:: __builtin__.object.__str__

sub(x, y)
(Subtraction operator)

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

Returns:

x-y

truediv(x, y)

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

Returns:

x/y

xor(x, y)

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

Returns:

x^y

Generated by Epydoc 2.1 on Wed Mar 22 21:13:59 2006

http://epydoc.sf.net

Type int

__abs__(x)

__add__(x, y) (Addition operator)

__and__(x, y) (And operator)

__cmp__(x, y) (Comparison operator)

__coerce__(x, y)

__div__(x, y)

__divmod__(x, y)

__float__(x)

__floordiv__(x, y)

__getattribute__(...)

__hash__(x) (Hashing function)

__hex__(x)

__int__(x)

__invert__(x)

__long__(x)

__lshift__(x, y)

__mod__(x, y)

__mul__(x, y)

__neg__(x)

__new__(T, S, ...)

__nonzero__(x) (Boolean test operator)

__oct__(x)

__or__(x, y) (Or operator)

__pos__(x)

__pow__(x, y, z=...)

__radd__(x, y) (Right-side addition operator)

__rand__(x, y)

__rdiv__(x, y)

__rdivmod__(x, y)

__repr__(x) (Representation operator)

__rfloordiv__(x, y)

__rlshift__(x, y)

__rmod__(x, y)

__rmul__(x, y)

__ror__(x, y)

__rpow__(y, x, z=...)

__rrshift__(x, y)

__rshift__(x, y)

__rsub__(x, y)

__rtruediv__(x, y)

__rxor__(x, y)

__str__(x) (Informal representation operator)

__sub__(x, y) (Subtraction operator)

__truediv__(x, y)

__xor__(x, y)

abs(x)

add(x, y)
(Addition operator)

and(x, y)
(And operator)

cmp(x, y)
(Comparison operator)

coerce(x, y)

div(x, y)

divmod(x, y)

float(x)

floordiv(x, y)

getattribute(...)

hash(x)
(Hashing function)

hex(x)

int(x)

invert(x)

long(x)

lshift(x, y)

mod(x, y)

mul(x, y)

neg(x)

new(T, S, ...)

nonzero(x)
(Boolean test operator)

oct(x)

or(x, y)
(Or operator)

pos(x)

pow(x, y, z=...)

radd(x, y)
(Right-side addition operator)

rand(x, y)

rdiv(x, y)

rdivmod(x, y)

repr(x)
(Representation operator)

rfloordiv(x, y)

rlshift(x, y)

rmod(x, y)

rmul(x, y)

ror(x, y)

rpow(y, x, z=...)

rrshift(x, y)

rshift(x, y)

rsub(x, y)

rtruediv(x, y)

rxor(x, y)

str(x)
(Informal representation operator)

sub(x, y)
(Subtraction operator)

truediv(x, y)

xor(x, y)