Just name a few frequently used special method names in python

(`__len__``self`)- Called to implement the built-in function
`len()`. Should return the length of the object, an integer`>=`

0. Also, an object that doesn't define a`__nonzero__()`method and whose`__len__()`method returns zero is considered to be false in a Boolean context.

(`__getitem__``self, key`)- Called to implement evaluation of

. For sequence types, the accepted keys should be integers and slice objects. Note that the special interpretation of negative indexes (if the class wishes to emulate a sequence type) is up to the`self`[`key`]`__getitem__()`method. If`key`is of an inappropriate type,`TypeError`may be raised; if of a value outside the set of indexes for the sequence (after any special interpretation of negative values),`IndexError`should be raised. For mapping types, if`key`is missing (not in the container),`KeyError`should be raised.**Note:**`for`loops expect that an`IndexError`will be raised for illegal indexes to allow proper detection of the end of the sequence.

(`__setitem__``self, key, value`)- Called to implement assignment to

. Same note as for`self`[`key`]`__getitem__()`. This should only be implemented for mappings if the objects support changes to the values for keys, or if new keys can be added, or for sequences if elements can be replaced. The same exceptions should be raised for improper`key`values as for the`__getitem__()`method.

(`__delitem__``self, key`)- Called to implement deletion of

. Same note as for`self`[`key`]`__getitem__()`. This should only be implemented for mappings if the objects support removal of keys, or for sequences if elements can be removed from the sequence. The same exceptions should be raised for improper`key`values as for the`__getitem__()`method.

(`__iter__``self`)- This method is called when an iterator is required for a container. This method should return a new iterator object that can iterate over all the objects in the container. For mappings, it should iterate over the keys of the container, and should also be made available as the method
`iterkeys()`.Iterator objects also need to implement this method; they are required to return themselves. For more information on iterator objects, see ``Iterator Types'' in the*Python Library Reference*.

`in`and

`not in`) are normally implemented as an iteration through a sequence. However, container objects can supply the following special method with a more efficient implementation, which also does not require the object be a sequence.

(`__contains__``self, item`)- Called to implement membership test operators. Should return true if
`item`is in`self`, false otherwise. For mapping objects, this should consider the keys of the mapping rather than the values or the key-item pairs.

(`__getslice__``self, i, j`)**Deprecated since release 2.0.**Support slice objects as parameters to the`__getitem__()`method.

Called to implement evaluation of

. The returned object should be of the same type as`self`[`i`:`j`]`self`. Note that missing`i`or`j`in the slice expression are replaced by zero or`sys.maxint`

, respectively. If negative indexes are used in the slice, the length of the sequence is added to that index. If the instance does not implement the`__len__()`method, an`AttributeError`is raised. No guarantee is made that indexes adjusted this way are not still negative. Indexes which are greater than the length of the sequence are not modified. If no`__getslice__()`is found, a slice object is created instead, and passed to`__getitem__()`instead.

(`__setslice__``self, i, j, sequence`)- Called to implement assignment to

. Same notes for`self`[`i`:`j`]`i`and`j`as for`__getslice__()`.This method is deprecated. If no`__setslice__()`is found, or for extended slicing of the form

, a slice object is created, and passed to`self`[`i`:`j`:`k`]`__setitem__()`, instead of`__setslice__()`being called.

(`__delslice__``self, i, j`)- Called to implement deletion of

. Same notes for`self`[`i`:`j`]`i`and`j`as for`__getslice__()`. This method is deprecated. If no`__delslice__()`is found, or for extended slicing of the form

, a slice object is created, and passed to`self`[`i`:`j`:`k`]`__delitem__()`, instead of`__delslice__()`being called.

`__getitem__()`,`__setitem__()`or`__delitem__()`is called with a slice object as argument.

## Emulating numeric types

The following methods can be defined to emulate numeric objects. Methods corresponding to operations that are not supported by the particular kind of number implemented (e.g., bitwise operations for non-integral numbers) should be left undefined.

(`__add__``self, other`)(`__sub__``self, other`)(`__mul__``self, other`)(`__floordiv__``self, other`)(`__mod__``self, other`)(`__divmod__``self, other`)(`__pow__``self, other`[`, modulo`]`)`(`__lshift__``self, other`)(`__rshift__``self, other`)(`__and__``self, other`)(`__xor__``self, other`)(`__or__``self, other`)- These methods are called to implement the binary arithmetic operations (
`+`

,`-`

,`*`

,`//`

,`%`

,`divmod()`,`pow()`,`**`

,`<<`

,`>>`

,`&`

,`^`

,`|`

). For instance, to evaluate the expression`x``+`

`y`, where`x`is an instance of a class that has an`__add__()`method,

is called. The`x`.__add__(`y`)`__divmod__()`method should be the equivalent to using`__floordiv__()`and`__mod__()`; it should not be related to`__truediv__()`(described below). Note that`__pow__()`should be defined to accept an optional third argument if the ternary version of the built-in`pow()`function is to be supported.If one of those methods does not support the operation with the supplied arguments, it should return`NotImplemented`

.

(`__div__``self, other`)(`__truediv__``self, other`)- The division operator (
`/`

) is implemented by these methods. The`__truediv__()`method is used when`__future__.division`

is in effect, otherwise`__div__()`is used. If only one of these two methods is defined, the object will not support division in the alternate context;`TypeError`will be raised instead.

(`__radd__``self, other`)(`__rsub__``self, other`)(`__rmul__``self, other`)(`__rdiv__``self, other`)(`__rtruediv__``self, other`)(`__rfloordiv__``self, other`)(`__rmod__``self, other`)(`__rdivmod__``self, other`)(`__rpow__``self, other`)(`__rlshift__``self, other`)(`__rrshift__``self, other`)(`__rand__``self, other`)(`__rxor__``self, other`)(`__ror__``self, other`)- These methods are called to implement the binary arithmetic operations (
`+`

,`-`

,`*`

,`/`

,`%`

,`divmod()`,`pow()`,`**`

,`<<`

,`>>`

,`&`

,`^`

,`|`

) with reflected (swapped) operands. These functions are only called if the left operand does not support the corresponding operation and the operands are of different types.^{3.3}For instance, to evaluate the expression`x``-`

`y`, where`y`is an instance of a class that has an`__rsub__()`method,

is called if`y`.__rsub__(`x`)

returns`x`.__sub__(`y`)`NotImplemented`.Note that ternary`pow()`will not try calling`__rpow__()`(the coercion rules would become too complicated).

**Note:**If the right operand's type is a subclass of the left operand's type and that subclass provides the reflected method for the operation, this method will be called before the left operand's non-reflected method. This behavior allows subclasses to override their ancestors' operations.

(`__iadd__``self, other`)(`__isub__``self, other`)(`__imul__``self, other`)(`__idiv__``self, other`)(`__itruediv__``self, other`)(`__ifloordiv__``self, other`)(`__imod__``self, other`)(`__ipow__``self, other`[`, modulo`]`)`(`__ilshift__``self, other`)(`__irshift__``self, other`)(`__iand__``self, other`)(`__ixor__``self, other`)(`__ior__``self, other`)- These methods are called to implement the augmented arithmetic operations (
`+=`

,`-=`

,`*=`

,`/=`

,`//=`

,`%=`

,`**=`

,`<<=`

,`>>=`

,`&=`

,`^=`

,`|=`

). These methods should attempt to do the operation in-place (modifying`self`) and return the result (which could be, but does not have to be,`self`). If a specific method is not defined, the augmented operation falls back to the normal methods. For instance, to evaluate the expression`x``+=`

`y`, where`x`is an instance of a class that has an`__iadd__()`method,

is called. If`x`.__iadd__(`y`)`x`is an instance of a class that does not define a`__iadd__()`method,

and`x`.__add__(`y`)

are considered, as with the evaluation of`y`.__radd__(`x`)`x``+`

`y`.

(`__neg__``self`)(`__pos__``self`)(`__abs__``self`)(`__invert__``self`)- Called to implement the unary arithmetic operations (
`-`

,`+`

,`abs()`and`~`

).

(`__complex__``self`)(`__int__``self`)(`__long__``self`)(`__float__``self`)- Called to implement the built-in functions
`complex()`,`int()`,`long()`, and`float()`. Should return a value of the appropriate type.

(`__oct__``self`)(`__hex__``self`)- Called to implement the built-in functions
`oct()`and`hex()`. Should return a string value.

(`__index__``self`)- Called to implement
`operator.index()`. Also called whenever Python needs an integer object (such as in slicing). Must return an integer (int or long). New in version 2.5.

(`__coerce__``self, other`)- Called to implement ``mixed-mode'' numeric arithmetic. Should either return a 2-tuple containing
`self`and`other`converted to a common numeric type, or`None`

if conversion is impossible. When the common type would be the type of`other`

, it is sufficient to return`None`

, since the interpreter will also ask the other object to attempt a coercion (but sometimes, if the implementation of the other type cannot be changed, it is useful to do the conversion to the other type here). A return value of`NotImplemented`

is equivalent to returning`None`

.