How do I check the methods that an object has, in Python?

Question

For example, a list.

l1 = [1, 5 , 7] How do I check the methods that it has?

(l1.append, for example)

Or a string... string.lower(

Answer 1

You can use dir to get a list the methods of any object. This is very useful in the interactive prompt:

>>> dir(l1)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__',
'__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',
'__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__',
'__str__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

The interesting methods are usually those not starting with underscores. You can write your own version of dir that ignores names starting with underscores if you wish:

>>> mydir = lambda a:[x for x in dir(a) if not x.startswith('_')]
>>> mydir([])
['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Answer 2

If you install IPython, then you can do this:

% ipython
Python 2.6.4 (r264:75706, Nov  2 2009, 14:38:03) 
Type "copyright", "credits" or "license" for more information.

IPython 0.10 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object'. ?object also works, ?? prints more.

In [1]: l1=[1,5,7]

In [2]: l1.
l1.__add__           l1.__getslice__      l1.__new__           l1.append
l1.__class__         l1.__gt__            l1.__reduce__        l1.count
l1.__contains__      l1.__hash__          l1.__reduce_ex__     l1.extend
l1.__delattr__       l1.__iadd__          l1.__repr__          l1.index
l1.__delitem__       l1.__imul__          l1.__reversed__      l1.insert
l1.__delslice__      l1.__init__          l1.__rmul__          l1.pop
l1.__doc__           l1.__iter__          l1.__setattr__       l1.remove
l1.__eq__            l1.__le__            l1.__setitem__       l1.reverse
l1.__format__        l1.__len__           l1.__setslice__      l1.sort
l1.__ge__            l1.__lt__            l1.__sizeof__        
l1.__getattribute__  l1.__mul__           l1.__str__           
l1.__getitem__       l1.__ne__            l1.__subclasshook__  

In [2]: l1.

On the last line, you type the object name, a period, and then press TAB. IPython then lists all the attributes of the object.

I find IPython an invaluable tool for exploring object attributes. It is far more convenient to use than the standard Python interactive prompt. Among other nifty things, putting a question mark after an object gives you its doc string:

In [6]: d.update?
Type:    builtin_function_or_method
Base Class: <type 'builtin_function_or_method'>
String Form:    <built-in method update of dict object at 0xa3c024c>
Namespace:  Interactive
Docstring:
    D.update(E, **F) -> None.  Update D from dict/iterable E and F.
    If E has a .keys() method, does:     for k in E: D[k] = E[k]
    If E lacks .keys() method, does:     for (k, v) in E: D[k] = v
    In either case, this is followed by: for k in F: D[k] = F[k]

And, when available, two question marks gives you its source code:

In [18]: np.sum??
Type:    function
Base Class: <type 'function'>
String Form:    <function sum at 0x9c501ec>
Namespace:  Interactive
File:    /usr/lib/python2.6/dist-packages/numpy/core/fromnumeric.py
Definition: np.sum(a, axis=None, dtype=None, out=None)
Source:
def sum(a, axis=None, dtype=None, out=None):
...
    if isinstance(a, _gentype):
        res = _sum_(a)
        if out is not None:
            out[...] = res
            return out
        return res
    try:
        sum = a.sum
    except AttributeError:
        return _wrapit(a, 'sum', axis, dtype, out)
    return sum(axis, dtype, out)

Answer 3

As it happens, all the members of list instances are methods. If that weren't the case, you could use this:

l1 = [1, 5 , 7]
print [name for name in dir(l1) if type(getattr(l1, name) == type(l1.append))]

That will exclude members that aren't methods.

Answer 4

You might want to look at the getmembers function in the inspect module

In [1]: import inspect

In [2]: inspect?
Type:    module
Base Class: <type 'module'>
String Form:    <module 'inspect' from '/usr/lib/python2.6/inspect.pyc'>
Namespace:  Interactive
File:    /usr/lib/python2.6/inspect.py
Docstring:
    Get useful information from live Python objects.

    This module encapsulates the interface provided by the internal special
    attributes (func_*, co_*, im_*, tb_*, etc.) in a friendlier fashion.
    It also provides some help for examining source code and class layout.

    Here are some of the useful functions provided by this module:

        ismodule(), isclass(), ismethod(), isfunction(), isgeneratorfunction(),
            isgenerator(), istraceback(), isframe(), iscode(), isbuiltin(),
            isroutine() - check object types
        getmembers() - get members of an object that satisfy a given condition

        getfile(), getsourcefile(), getsource() - find an object's source code
        getdoc(), getcomments() - get documentation on an object
        getmodule() - determine the module that an object came from
        getclasstree() - arrange classes so as to represent their hierarchy

        getargspec(), getargvalues() - get info about function arguments
        formatargspec(), formatargvalues() - format an argument spec
        getouterframes(), getinnerframes() - get info about frames
        currentframe() - get the current stack frame
        stack(), trace() - get info about frames on the stack or in a traceback

In [3]: l1=[1,5,7]

In [4]: inspect.getmembers(l1)
Out[4]: 
[('__add__', <method-wrapper '__add__' of list object at 0xa38716c>),
 ('__class__', <type 'list'>),
 ('__contains__', <method-wrapper '__contains__' of list object at 0xa38716c>),
 ('__delattr__', <method-wrapper '__delattr__' of list object at 0xa38716c>),
 ('__delitem__', <method-wrapper '__delitem__' of list object at 0xa38716c>),
 ('__delslice__', <method-wrapper '__delslice__' of list object at 0xa38716c>),
 ('__doc__',
  "list() -> new list\nlist(sequence) -> new list initialized from sequence's items"),
 ('__eq__', <method-wrapper '__eq__' of list object at 0xa38716c>),
 ('__format__', <built-in method __format__ of list object at 0xa38716c>),
 ('__ge__', <method-wrapper '__ge__' of list object at 0xa38716c>),
 ('__getattribute__',
  <method-wrapper '__getattribute__' of list object at 0xa38716c>),
 ('__getitem__', <built-in method __getitem__ of list object at 0xa38716c>),
 ('__getslice__', <method-wrapper '__getslice__' of list object at 0xa38716c>),
 ('__gt__', <method-wrapper '__gt__' of list object at 0xa38716c>),
 ('__hash__', None),
 ('__iadd__', <method-wrapper '__iadd__' of list object at 0xa38716c>),
 ('__imul__', <method-wrapper '__imul__' of list object at 0xa38716c>),
 ('__init__', <method-wrapper '__init__' of list object at 0xa38716c>),
 ('__iter__', <method-wrapper '__iter__' of list object at 0xa38716c>),
 ('__le__', <method-wrapper '__le__' of list object at 0xa38716c>),
 ('__len__', <method-wrapper '__len__' of list object at 0xa38716c>),
 ('__lt__', <method-wrapper '__lt__' of list object at 0xa38716c>),
 ('__mul__', <method-wrapper '__mul__' of list object at 0xa38716c>),
 ('__ne__', <method-wrapper '__ne__' of list object at 0xa38716c>),
 ('__new__', <built-in method __new__ of type object at 0x822be40>),
 ('__reduce__', <built-in method __reduce__ of list object at 0xa38716c>),
 ('__reduce_ex__',
  <built-in method __reduce_ex__ of list object at 0xa38716c>),
 ('__repr__', <method-wrapper '__repr__' of list object at 0xa38716c>),
 ('__reversed__', <built-in method __reversed__ of list object at 0xa38716c>),
 ('__rmul__', <method-wrapper '__rmul__' of list object at 0xa38716c>),
 ('__setattr__', <method-wrapper '__setattr__' of list object at 0xa38716c>),
 ('__setitem__', <method-wrapper '__setitem__' of list object at 0xa38716c>),
 ('__setslice__', <method-wrapper '__setslice__' of list object at 0xa38716c>),
 ('__sizeof__', <built-in method __sizeof__ of list object at 0xa38716c>),
 ('__str__', <method-wrapper '__str__' of list object at 0xa38716c>),
 ('__subclasshook__',
  <built-in method __subclasshook__ of type object at 0x822be40>),
 ('append', <built-in method append of list object at 0xa38716c>),
 ('count', <built-in method count of list object at 0xa38716c>),
 ('extend', <built-in method extend of list object at 0xa38716c>),
 ('index', <built-in method index of list object at 0xa38716c>),
 ('insert', <built-in method insert of list object at 0xa38716c>),
 ('pop', <built-in method pop of list object at 0xa38716c>),
 ('remove', <built-in method remove of list object at 0xa38716c>),
 ('reverse', <built-in method reverse of list object at 0xa38716c>),
 ('sort', <built-in method sort of list object at 0xa38716c>)]

Answer 5

Interactive Python has a help function you can use with anything:

>>> help(list)
Help on class list in module __builtin__:

class list(object)
 |  list() -> new list
 |  list(sequence) -> new list initialized from sequence´s items
 |
 |  Methods defined here:
 |
 |  __add__(...)
 |      x.__add__(y) <==> x+y
 |
 |  __contains__(...)
 |      x.__contains__(y) <==> y in x
 |
 |  __delitem__(...)
 |      x.__delitem__(y) <==> del x[y]
 |
 |  __delslice__(...)
 |      x.__delslice__(i, j) <==> del x[i:j]
 |
 |      Use of negative indices is not supported.
 |
 |  __eq__(...)
 |      x.__eq__(y) <==> x==y
 |
 |  __ge__(...)
 |      x.__ge__(y) <==> x>=y
 |
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |
 |  __getslice__(...)
 |      x.__getslice__(i, j) <==> x[i:j]
 |
 |      Use of negative indices is not supported.
 |
 |  __gt__(...)
 |      x.__gt__(y) <==> x>y
 |
 |  __iadd__(...)
 |      x.__iadd__(y) <==> x+=y
 |
 |  __imul__(...)
 |      x.__imul__(y) <==> x*=y
 |
 |  __init__(...)
 |      x.__init__(...) initializes x; see x.__class__.__doc__ for signature
 |
 |  __iter__(...)
 |      x.__iter__() <==> iter(x)
 |
 |  __le__(...)
 |      x.__le__(y) <==> x<=y
 |
 |  __len__(...)
 |      x.__len__() <==> len(x)
 |
 |  __lt__(...)
 |      x.__lt__(y) <==> x<y
 |
 |  __mul__(...)
 |      x.__mul__(n) <==> x*n
 |
 |  __ne__(...)
 |      x.__ne__(y) <==> x!=y
 |
 |  __repr__(...)
 |      x.__repr__() <==> repr(x)
 |
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |
 |  __rmul__(...)
 |      x.__rmul__(n) <==> n*x
 |
 |  __setitem__(...)
 |      x.__setitem__(i, y) <==> x[i]=y
 |
 |  __setslice__(...)
 |      x.__setslice__(i, j, y) <==> x[i:j]=y
 |
 |      Use  of negative indices is not supported.
 |
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |
 |  append(...)
 |      L.append(object) -- append object to end
 |
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |
 |  extend(...)
 |      L.extend(iterable) -- extend list by appending elements from the iterable
 |
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |
 |  remove(...)
 |      L.remove(value) -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |
 |  sort(...)
 |      L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
 |      cmp(x, y) -> -1, 0, 1
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None
 |
 |  __new__ = <built-in method __new__ of type object at 0x1E1CF100>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T

Answer 6

If the object (which often might be a module) has many methods or attributes using dir or the TAB completion of ipython can get to complex to keep track.

In such cases I use filter like in the following example:

filter(lambda s: 'sin' in s.lower(), dir(numpy))

which results in

['arcsin',
 'arcsinh',
 'csingle',
 'isinf',
 'isposinf',
 'sin',
 'sinc',
 'single',
 'singlecomplex',
 'sinh']

I find that very handy to explore unknown objects from which I expect that they must have a method (or attribute) which should have as part of its name.