__builtin_

Module __builtin__ :: Class long

[show private | hide private]

Type long

object --+
         |
        long

long(x[, base]) -> integer

Convert a string or number to a long 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.

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) <==> divmod(x, 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) <==> divmod(y, 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__`, `__delattr__`, `__reduce__`, `__reduce_ex__`, `__setattr__`

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) <==> divmod(x, y)

Returns:

divmod(x, 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) <==> divmod(y, x)

Returns:

divmod(y, 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 Thu Aug 16 09:55:15 2007

http://epydoc.sf.net

Type long

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