yaml :: representer :: BaseRepresenter :: instance_type :: Class instance_type

Class instance_type

object --+
         |
        yaml.representer.BaseRepresenter.instance_type

instance(class[, dict])

Create an instance without calling its __init__() method. The class must be a classic class. If present, dict must be a dictionary or None.

Instance Methods

[hide private]

__abs__(x)
abs(x)

__add__(x, y)
x+y

__and__(x, y)
x&y

__call__(x, ...)
x(...)

__cmp__(x, y)
cmp(x,y)

__coerce__(x, y)
coerce(x, y)

__contains__(x, y)
y in x

__delattr__(...)
x.__delattr__('name') <==> del x.name

__delitem__(x, y)
del x[y]

__delslice__(x, i, j)
del x[i:j]

__div__(x, y)
x/y

__divmod__(x, y)
divmod(x, y)

__eq__(x, y)
x==y

__float__(x)
float(x)

__floordiv__(x, y)
x//y

__ge__(x, y)
x>=y

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

__getitem__(x, y)
x[y]

__getslice__(x, i, j)
x[i:j]

__gt__(x, y)
x>y

__hash__(x)
hash(x)

__hex__(x)
hex(x)

__iadd__(x, y)
x+y

__iand__(x, y)
x&y

__idiv__(x, y)
x/y

__ifloordiv__(x, y)
x//y

__ilshift__(x, y)
x<<y

__imod__(x, y)
x%y

__imul__(x, y)
x*y

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

__int__(x)
int(x)

__invert__(x)
~x

__ior__(x, y)
x|y

__ipow__(x, y)
x**y

__irshift__(x, y)
x>>y

__isub__(x, y)
x-y

__iter__(x)
iter(x)

__itruediv__(x, y)
x/y

__ixor__(x, y)
x^y

__le__(x, y)
x<=y

__len__(x)
len(x)

__long__(x)
long(x)

__lshift__(x, y)
x<<y

__lt__(x, y)
x<y

__mod__(x, y)
x%y

__mul__(x, y)
x*y

__ne__(x, y)
x!=y

__neg__(x)
-x

a new object with type S, a subtype of T

__new__(T, S, ...)

__nonzero__(x)
x != 0

__oct__(x)
oct(x)

__or__(x, y)
x|y

__pos__(x)
+x

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

__radd__(x, y)
y+x

__rand__(x, y)
y&x

__rdiv__(x, y)
y/x

__rdivmod__(x, y)
divmod(y, x)

__repr__(x)
repr(x)

__rfloordiv__(x, y)
y//x

__rlshift__(x, y)
y<<x

__rmod__(x, y)
y%x

__rmul__(x, y)
y*x

__ror__(x, y)
y|x

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

__rrshift__(x, y)
y>>x

__rshift__(x, y)
x>>y

__rsub__(x, y)
y-x

__rtruediv__(x, y)
y/x

__rxor__(x, y)
y^x

__setattr__(...)
x.__setattr__('name', value) <==> x.name = value

__setitem__(x, i, y)
x[i]=y

__setslice__(x, i, j, y)
x[i:j]=y

__str__(x)
str(x)

__sub__(x, y)
x-y

__truediv__(x, y)
x/y

__xor__(x, y)
x^y

the next value, or raise StopIteration

next(x)

Inherited from object: __init__, __reduce__, __reduce_ex__

Properties

[hide private]

Inherited from object: __class__

Method Details

[hide private]

delattr(...)

x.__delattr__('name') <==> del x.name

Overrides: object.__delattr__

delslice(x, i, j)
(Slice deletion operator)

del x[i:j]

Use of negative indices is not supported.

getattribute(...)

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

Overrides: object.__getattribute__

getslice(x, i, j)
(Slicling operator)

x[i:j]

Use of negative indices is not supported.

hash(x)
(Hashing function)

hash(x)

Overrides: object.__hash__

new(T, S, ...)

Returns: a new object with type S, a subtype of T
Overrides: object.__new__

repr(x)
(Representation operator)

repr(x)

Overrides: object.__repr__

setattr(...)

x.__setattr__('name', value) <==> x.name = value

Overrides: object.__setattr__

setslice(x, i, j, y)
(Slice assignment operator)

x[i:j]=y

Use of negative indices is not supported.

str(x)
(Informal representation operator)

str(x)

Overrides: object.__str__

Class instance_type

__delattr__(...)

__delslice__(x, i, j) (Slice deletion operator)

__getattribute__(...)

__getslice__(x, i, j) (Slicling operator)

__hash__(x) (Hashing function)

__new__(T, S, ...)

__repr__(x) (Representation operator)

__setattr__(...)

__setslice__(x, i, j, y) (Slice assignment operator)

__str__(x) (Informal representation operator)

delattr(...)

delslice(x, i, j)
(Slice deletion operator)

getattribute(...)

getslice(x, i, j)
(Slicling operator)

hash(x)
(Hashing function)

new(T, S, ...)

repr(x)
(Representation operator)

setattr(...)

setslice(x, i, j, y)
(Slice assignment operator)

str(x)
(Informal representation operator)