# Problem with Help when using numarray

Colin J. Williams cjw at sympatico.ca
Fri Sep 16 21:36:43 CEST 2005

```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
|
|  Methods defined here:
|
|  __abs__(...)
|      x.__abs__() <==> abs(x)
|
|
|  __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])
|
|
|  __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>
>
>
>

```