¿Cómo verifico los métodos que tiene un objeto en Python?

Question

Por ejemplo, una lista.

l1 = [1, 5, 7] ¿Cómo verifico los métodos que tiene?

(l1.append, por ejemplo)

o una cadena ... string.lower (

Answer 1

Puede utilizar dir para obtener una lista los métodos de cualquier objeto. Esto es muy útil en el modo interactivo:

>>> 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'] 

los métodos interesantes son por lo general aquellos que no empiezan con guiones usted puede escribir su propia versión de dir que ignora los nombres que comienzan con guiones bajos si lo desea:.

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

Si instala IPython, entonces usted puede hacer esto:

% 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. 

En la última línea, se escribe el nombre del objeto, un período, y luego presionar la tecla TAB. IPython luego enumera todos los atributos del objeto.

Encuentro IPython una herramienta invaluable para explorar los atributos de los objetos. Es mucho más conveniente de usar que el indicador interactivo estándar de Python. Entre otras cosas ingeniosas, poner un signo de interrogación después de que un objeto que da su cadena de documentación:

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] 

Y, cuando esté disponible, dos signos de interrogación le da su código fuente:

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

Si llega el caso, todos los miembros de instancias de lista son métodos. Si ese no fuera el caso, puede usar esto:

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

Eso excluirá los miembros que no sean métodos.

Answer 4

Es posible que desee ver en la función getmembers en el módulo inspect

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

interactivo Python tiene una función help puede utilizar con cualquier cosa:

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

Si el objeto (que a menudo podría ser un módulo) tiene muchos métodos o atributos que usan dir o la terminación TAB de ipython puede llegar a ser compleja para realizar un seguimiento.

En tales casos utilizo filtro como en el siguiente ejemplo:

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

que se traduce en

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

Me parece muy útil para explorar objetos desconocidos de la que yo esperaría que deben tener un método (o atributo) que debería tener como parte de su nombre.