Python中使用help查看某一类对象的内置方法

Python中不同类型的对象有不同的方法,那么如何查看某一类型对象的方法?我们可以使用help()函数

用法help() ,括号中写对象的类型。比如查看数据类型的方法:

help(int)

 |  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) <==> divmod(x, y)
 |  
 |  __float__(...)
 |      x.__float__() <==> float(x)
 |  
 |  __floordiv__(...)
 |      x.__floordiv__(y) <==> x//y
 |  
 |  __format__(...)
 |  
 |  __getattribute__(...)
 |      x.__getattribute__(‘name‘) <==> x.name
 |  
 |  __getnewargs__(...)
 |  
 |  __hash__(...)
 |      x.__hash__() <==> hash(x)
 |  
 |  __hex__(...)
 |      x.__hex__() <==> hex(x)
 |  
 |  __index__(...)
 |      x[y:z] <==> x[y.__index__():z.__index__()]
 |  
 |  __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) <==> divmod(y, 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
 |  
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |  
 |  __xor__(...)
 |      x.__xor__(y) <==> x^y
 |  
 |  bit_length(...)
 |      int.bit_length() -> int
 |      
 |      Number of bits necessary to represent self in binary.
 |      >>> bin(37)
 |      ‘0b100101‘
 |      >>> (37).bit_length()
 |      6
 |

像__add__(...)这种前后有两个下划线的都是python内置方法。

x.__add__(y) <==> x+y  表示x.__add__(y) 和x+y是一样的

例如:

>>> x=1
>>> y=2
>>> x.__add__(y)
3
>>> x+y
3
时间: 2024-10-14 14:03:49

Python中使用help查看某一类对象的内置方法的相关文章

Python之路(第二十七篇) 面向对象进阶:内置方法、描述符

一.__call__ 对象后面加括号,触发执行类下面的__call__方法. 创建对象时,对象 = 类名() :而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()() class Foo: ? def __call__(self, *args, **kwargs): print("我执行啦") ? f = Foo() f() #对象加括号调用执行类下的__call__方法 #输出结果 我执行啦 二.__next__和__iter__实现迭代器协议 迭

用JAVA编写浏览器内核之实现javascript的document对象与内置方法

原创文章.转载请注明. 阅读本文之前,您须要对浏览器怎样载入javascript有一定了解. 当然,对java与javascript本身也须要了解. 本文首先介绍浏览器载入并执行javascript的原理. 其次将介绍怎样用java与javascript互调用对象. 最后介绍怎样用java实现javascript的document对象与其他内置方法. 浏览器从server得到含有javascript代码的html文本后,将顺序运行javascript代码块. 看代码是最简单的方式: packag

作用域,预解析,对象,内置方法 Math Date Array

作用域 一段程序代码中所用到的名字并不总是有效可用的,而限定这个名字(变量)的可用性的代码范围,就是这个名字的作用域,作用域提高了逻辑程序的局部性,增强了可靠性,减少了名字冲突: JavaScript作用域(es6)之前:全局作用域,局部作用域 全局作用域:整个script标签或者是一个单独的JS文件 局部作用域(函数作用域):在函数内部就是作用域: 变量作用域 全局变量:在全局作用域下声明的变量:如果在函数内部没有声明(var)直接赋值的变量也是全局变量 num = 2; 局部变量:在函数内部

python中的__init__ 、__new__、__call__等内置函数的剖析

1.__new__(cls, *args, **kwargs)   创建对象时调用,返回当前对象的一个实例;注意:这里的第一个参数是cls即class本身2.__init__(self, *args, **kwargs) 创建完对象后调用,对当前对象的实例的一些初始化,无返回值,即在调用__new__之后,根据返回的实例初始化:注意,这里的第一个参数是self即对象本身[注意和new的区别]3.__call__(self,  *args, **kwargs) 如果类实现了这个方法,相当于把这个类

python中有两个下划线__的是内置方法,一个下划线_或者没有下划线的可能是属性,也可能是方法,也可能是类名

>>> dir(__builtins__)['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarn

python类中内置方法之__call__

在python中自定义类时,如果该类实现了一个特殊方法__call__(),那么该类的实例则变成一个可调用的实例对象 如下 In [1]: class A():# 自定义一个A ...: def __call__(self,args): # 实现特殊方法__call__ ...: print(args) ...: In [2]: a = A() In [3]: a("__call__") __call__ a = A() # 对自定义的类A,实例化一个对象aa("__call

Python 多态 对象常用内置函数 运算符重载 对象迭代器 上下文管理

一 多态 1.什么是多态:多态不是一个具体的技术或代码.指的时候多个不同类型对象可以响应同一个方法,产生不同的结果. 2.使用多多态的好处:提高了程序的灵活性,拓展性 3.如何实现:鸭子类型 就是典型的多态 多种不同类型 使用方法一样 4.案例 class Cat(): def bark(self): print("喵喵喵") def run(self): print("四条腿跑!") def sleep(self): print("趴着睡!")

python中使用hasattr(x,&#39;call&#39;)来判断一个对象是否存在某个方法

class Person: def PrintName(self): print 'Is a Person' def PrintHello(self): print 'Hello, world' per = Person()per.PrintName()print hasattr(per,'PrintName')#True python中使用hasattr(x,'call')来判断一个对象是否存在某个方法

javascript中本地对象、内置对象和宿主对象(转)

ECMA-262 把本地对象(native object)定义为“独立于宿主环境的 ECMAScript 实现提供的对象”. 看定义有些不清楚,因为还未了解何为“宿主环境”的时候就引用了“宿主环境”这个概念,着实让人有些发晕. 不过,根据我强悍的文学功底,“宿主”一般是指寄生的生物选择的寄生体,这让我想起了“火影”里的“白”.简单说,就是用户的机器环境,包括操作系统和浏览器. 再来看一下,“本地对象”包含哪些内容: Object.Function.Array.String.Boolean.Num