__builtin_

Module __builtin__ :: Class int

Class int

object --+
         |
        int

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...
	`__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...
Inherited from type
	`__new__(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T...

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

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.0 on Fri Sep 19 18:29:39 2003

http://epydoc.sf.net

Class 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)

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

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)