Problem with Help when using numarray

[Colin J. Williams]

Fredrik Lundh wrote:
> Colin J. Williams wrote:
> 
> 
>>With numarray, help gives unhelpful responses:
>>
>>import numarray.numarraycore as _n
>>c= _n.array((1, 2))
>>print 'rank Value:', c.rank
>>print 'c.rank Help:', help(c.rank)
> 
> 
> c.rank returns a Python integer object.
Fredrik,

Thanks to Robert Kern and yourself.
Yes, you are right.  Most of such cases are treated as properties so 
that a doc string is available.

I think that the script below shows that there are cases where a doc 
string is available but this information is not retrieved by help()

names= [n * int(not ( '_' in n)) for n in dir(c)]
for n in names:
   if len(n):
     try:
       txt= eval('c.'+n+'.__doc__ ')
       print n, txt
       print 'help:', help('c.'+n)
     except:
       print n, ' fails'

You give an integer example below, which I have marked <<<<<<<

This gives the basics. help(c.rank) below gives much more and a lot of 
it is irrelevant.

Colin W.

 >>> help(c.rank)
Help on int object:

class int(object)
  |  int(x[, base]) -> integer
  |
  |  Convert a string or number to an 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. If the argument is outside the integer range a long object
  |  will be returned instead.
  |
  |  Methods defined here:
  |
  |  __abs__(...)
  |      x.__abs__() <==> abs(x)
  |
  |  __add__(...)
  |      x.__add__(y) <==> x+y
  |
  |  __and__(...)
  |      x.__and__(y) <==> x&y
  |
  |  __cmp__(...)
  |      x.__cmp__(y) <==> cmp(x,y)
  |
  |  __coerce__(...)
  |      x.__coerce__(y) <==> coerce(x, y)
  |
  |  __div__(...)
  |      x.__div__(y) <==> x/y
  |
  |  __divmod__(...)
  |      x.__divmod__(y) <==> xdivmod(x, y)y
  |
  |  __float__(...)
  |      x.__float__() <==> float(x)
  |
  |  __floordiv__(...)
  |      x.__floordiv__(y) <==> x//y
  |
  |  __getattribute__(...)
  |      x.__getattribute__('name') <==> x.name
  |
  |  __getnewargs__(...)
  |
  |  __hash__(...)
  |      x.__hash__() <==> hash(x)
  |
  |  __hex__(...)
  |      x.__hex__() <==> hex(x)
  |
  |  __int__(...)
  |      x.__int__() <==> int(x)
  |
  |  __invert__(...)
  |      x.__invert__() <==> ~x
  |
  |  __long__(...)
  |      x.__long__() <==> long(x)
  |
  |  __lshift__(...)
  |      x.__lshift__(y) <==> x<<y
  |
  |  __mod__(...)
  |      x.__mod__(y) <==> x%y
  |
  |  __mul__(...)
  |      x.__mul__(y) <==> x*y
  |
  |  __neg__(...)
  |      x.__neg__() <==> -x
  |
  |  __nonzero__(...)
  |      x.__nonzero__() <==> x != 0
  |
  |  __oct__(...)
  |      x.__oct__() <==> oct(x)
  |
  |  __or__(...)
  |      x.__or__(y) <==> x|y
  |
  |  __pos__(...)
  |      x.__pos__() <==> +x
  |
  |  __pow__(...)
  |      x.__pow__(y[, z]) <==> pow(x, y[, z])
  |
  |  __radd__(...)
  |      x.__radd__(y) <==> y+x
  |
  |  __rand__(...)
  |      x.__rand__(y) <==> y&x
  |
  |  __rdiv__(...)
  |      x.__rdiv__(y) <==> y/x
  |
  |  __rdivmod__(...)
  |      x.__rdivmod__(y) <==> ydivmod(y, x)x
  |
  |  __repr__(...)
  |      x.__repr__() <==> repr(x)
  |
  |  __rfloordiv__(...)
  |      x.__rfloordiv__(y) <==> y//x
  |
  |  __rlshift__(...)
  |      x.__rlshift__(y) <==> y<<x
  |
  |  __rmod__(...)
  |      x.__rmod__(y) <==> y%x
  |
  |  __rmul__(...)
  |      x.__rmul__(y) <==> y*x
  |
  |  __ror__(...)
  |      x.__ror__(y) <==> y|x
  |
  |  __rpow__(...)
  |      y.__rpow__(x[, z]) <==> pow(x, y[, z])
  |
  |  __rrshift__(...)
  |      x.__rrshift__(y) <==> y>>x
  |
  |  __rshift__(...)
  |      x.__rshift__(y) <==> x>>y
  |
  |  __rsub__(...)
  |      x.__rsub__(y) <==> y-x
  |
  |  __rtruediv__(...)
  |      x.__rtruediv__(y) <==> y/x
  |
  |  __rxor__(...)
  |      x.__rxor__(y) <==> y^x
  |
  |  __str__(...)
  |      x.__str__() <==> str(x)
  |
  |  __sub__(...)
  |      x.__sub__(y) <==> x-y
  |
  |  __truediv__(...)
  |      x.__truediv__(y) <==> x/y
  |
  |  __xor__(...)
  |      x.__xor__(y) <==> x^y
  |
  |  ----------------------------------------------------------------------
  |  Data and other attributes defined here:
  |
  |  __new__ = <built-in method __new__ of type object>
  |      T.__new__(S, ...) -> a new object with type S, a subtype of T

 >>>
> 
> if you pass in an object to help(), help figures out what that object is,
> and tries to tell you what you can do with that object.
> 
> the integer itself has no idea whatsoever from where it came; it's just
> an integer, and that's all Python knows about it.
> 
> cf.
> 
> 
>>>>import sys
>>>>help(sys)
> 
> Help on built-in module sys:
> NAME
>     sys
> 
> 
>>>>help(sys.stdout)
> 
> Help on file object:
> class file(object)
>  |  file(name[, mode[, buffering]]) -> file object
> 
> 
>>>>help(sys.stdout.softspace)
> 
> Help on int object:                             <<<<<<
> class int(object)
> 
> 
>>>>help(sys.stdout.softspace.__int__)
> 
> Help on method-wrapper object:
> __int__ = class method-wrapper(object)
> 
> and so on.
> 
> </F> 
> 
> 
>