首页 > 代码库 > int类中的方法

int类中的方法

    我们知道在python中,一切对象都是类,对象的方法都封装在类中,现在来探讨一下int类中的方法:

    我们可以通过help(int)和dir(int)来查看int类中都封装了那些方法:

    1.bit_length()

def bit_length(self): # real signature unknown; restored from __doc__
"""

"""返回表示该数字的二进制最少位数"""
int.bit_length() -> int

Number of bits necessary to represent self in binary.
>>> bin(37)
‘0b100101‘
>>> (37).bit_length()
6
"""
return 0

    下面我们来看一个例子,我们知道计算机底层都是0和1表示,我们定义a = 10,看a的二进制表示方式如下:

    0 0 0 0 1 0 1 0           10(二进制)

    >>> bin(a)
  ‘0b1010‘

    我们也可以使用bin()函数(bin()函数是把一个整数转化为二进制的表示形式),把一个整数转化为二进制进行查看:

    那么可以看出10的二进制最少位数为4,下面使用bit_length进行验证一下:

    >>> a = 10
  >>> a.bit_length()
  4

    从上面程序我们可以看出,输出结果与我们设想的是一致的,bit_length()方法不需要参数,用来返回整数的二进制长度。

    下面我们来进一步进行探讨一下,我们都学过数学,知道有正整数,负整数,浮点数(float,即小数),来看一下是否bit_length属性:

    >>> a = -10
  >>> a.bit_length()
  4
  >>> a = 10.5
  >>> a.bit_length()
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  AttributeError: ‘float‘ object has no attribute ‘bit_length‘

    从上面可以看出,负整数也是有bit_length属性的,但是浮点数是没有这个属性的,浮点数使用bit_length属性的时候,程序报错,提示float数没有bit_length,因此我们可以得到结论,无论正整数还是负整数都具有属性bit_length,都能用二进制进行表示在计算机里面,而且int(10)和int(-10)的二进制长度是一样的。

    2.conjugate()

def conjugate(self, *args, **kwargs): # real signature unknown

"""返回一个整数的共轭复数"""
""" Returns self, the complex conjugate of any int. """
pass

    >>> a = 10
  >>>
a.conjugate()
  10

    大家可以去看看共轭复数的概念,实部相等,虚部相反称为共轭复数,现在都忘的差不多了。

    3.__abs__()

    def __abs__(self, *args, **kwargs): # real signature unknown

    # a.__abs__()  等价于  abs(a)

    """返回绝对值"""
  """ abs(self) """
  pass

    __abs__()是返回一个数的绝对值,我们知道,肯定是用来返回复数的绝对值,正数的绝对值还是其本身,由于__abs__是处理数据的时候的常用功能,因此Python中内置了abs()函数,abs()函数在运用的时候也是调用__abs__()来实现的。下面来看两个列子:

    >>> a = -19
  >>> a.__abs__()
  19
  >>> abs(a)
  19
    可以看出,两个方法得到的结果是一致的,其实Python中内置的函数就是调用类中的方法,这点在我们逐渐学习的过程中会看得更深入。

    3.__add__(self,y)

    def __add__(self, *args, **kwargs): # real signature unknown

    """返回两个数字相加的结果"""

    """ x.__add__(y)等价于x+y """
  """ Return self+value. """
  pass

    >>> a = 5
  >>> x = 5
  >>> y = 3
  >>> x.__add__(y)
  8
  >>> x + y
  8
  >>> z = 3.5
  >>> x.__add__(z)
  NotImplemented
  >>> x+z
  8.5

    可以看出,两种方式是等价的,但是不知道为什么使用__add__()方法的时候,不能对浮点数进行相加,但是加号(+)是可以的,可能定制类的时候,要想相加必须是统一类的类型数字,就是在一个类中定义的方法处理的时候必须是相同的类。

    def __add__(self, *args, **kwargs): # real signature unknown

    """返回两个数的位与运算符(二进制下的位与运算符)"""
  """ Return self+value. """
  pass

    下面我们来看一下具体实例:

    0 0 0 0 1 0 1 0            二进制:10

    0 0 1 1 0 0 1 0            二进制:50

    0 0 0 0 0 0 1 0            a.__and__(a&b)

    上面是二进制下10和50的表示方法,位于运算符是同为真的时候才为真,运算结果在上面,00000010是十进制下的2,下面来看一下:

    >>> a = 10
  >>> b = 50
  >>> a.__and__(b)
  2
  >>> a&b
  2
    可以看出两者的结果是一致的,我们知道&是and的缩写表示形式,所以在使用的时候使用__and__()或者&都是可以的。

    4.__bool__(self)

    def __bool__(self, *args, **kwargs): # real signature unknown
  """ self != 0 """

    """判断一个值是否为True或者False"""
  pass

    我们知道在Python中True==1,False==0,我们经常使用bool值进行判断:

    >>> a = 5
  >>> b = 1.5
  >>> c = 1
  >>> d = 0
  >>> a.__bool__()
  True
  >>> b.__bool__()
  True
  >>> c.__bool__()
  True
  >>> d.__bool__()
  False
    可以看出,0为False,只要不是0,都为真,这个性质跟Excle中函数的性质是一样的,因为我们经常要根据返回的值进行判断,判断结果是否为零。

    5.__ceil__(self)

    def __ceil__(self, *args, **kwargs): # real signature unknown

    """__ceil__(self)返回数字的上入整数,要是学过Excel就相当于ceiling()函数,向上舍入到最接近的整数
  """ Ceiling of an Integral returns itself. """
  pass

    ceil() 函数返回数字的上入整数

    注意:ceil()是不能直接访问的,需要导入 math 模块,通过静态对象调用该方法。

 

import math   #导入math模块

print "math.ceil(-45.17) : ", math.ceil(-45.17)
print "math.ceil(100.12) : ", math.ceil(100.12)
print "math.ceil(100.72) : ", math.ceil(100.72)
print "math.ceil(119L) : ", math.ceil(119L)
print "math.ceil(math.pi) : ", math.ceil(math.pi)
运行结果如下:
math.ceil(-45.17: -45
math.ceil(100.12): 101
math.ceil(100.72: 101
math.ceil(119.0001: 120
math.cell(math.pi): 4
Python中有专门处理数字的math模块,用户数学运算的处理,需要的时候可以导入math模块的功能。
6.__divmod__(self,value)
def __divmod__(self, *args, **kwargs): # real signature unknown
"""返回两个数相处的商和余数,放在一个元素中a.__divmod__(b)返回(商,余数)"""

""" Return divmod(self, value). """
pass
我们经常访问网站,比如安居客和链家,上面有显示经纪人的房源信息,每页显示的房源信息是有最大值固定的,比如我们现在有553条房源信息,每
页可以放10条房源信息,那么需要多少页,我们知道需要55整页还剩3条房源,这3条肯定也要放一页,因此需要56个网页存放。下面我们来演示一下这个
函数:
  >>> a = 55
  >>> b = 60
  >>> c = 10
  >>> a.__divmod__(c)
  (5, 5)
  >>> b.__divmod__(c)
  (6, 0)
  >>> type(a.__divmod__(c))
  <class ‘tuple‘>
a.__divmod__(b)我们得到a与b的商和余数部分,并且存放在一个元组中,这点我们要记住,得到商和余数存放在一个元组中。
7.__eq__(self,value)
def __eq__(self, *args, **kwargs): # real signature unknown
"""__eq__(self,value)等价于判断 self == value,判断是否与要求的数字相等"""
""" Return self==value. """
pass
__eq__()是中的eq是单词equal的缩写,equal是相等的意思,判断两个数字是否相等。如下:
>>> a = 5
  >>> b = 3
  >>> c = 5
  >>> a.__eq__(b)
  False
  >>> a.__eq__(c)
  True
判断两个数字相等,返回布尔值(bool),如果相等返回True;否则返回False。
8.__ne__(self,value)
def __ne__(self, *args, **kwargs): # real signature unknown
"""判断两个数字是否不想等,如果不想等返回True;否则返回布尔值False."""
""" Return self!=value. """
pass
判断两个数字是否相等,相等返回True,否则返回False。__ne__(self,value)是单词not equal的缩写,表示不等于的含义,下面我会进行总结:
>>> a = 5
  >>> b = 3
  >>> c = 5
  >>> a.__ne__(b)
  True
  >>> a.__ne__(c)
  False
从上面我们可以看出,a != b的时候返回的是True;a == c的时候返回布尔值False.
9.__ge__(self,value)
def __ge__(self, *args, **kwargs): # real signature unknown
"""__ge__(self,value)是用来判断self>=value,如果self大于等于要比较的value值,则返回布尔值True,否则返回False"""
""" Return self>=value. """
pass
__ge__(self,value)是大于等于的含义,比较self>=value,ge是单词greater than or equal to的缩写,表示大于等于:判断如下:
>>> a = 5
  >>> b = 3
  >>> c = 6
  >>> a.__ge__(c)
  False
  >>> a.__ge__(b)
  True
10.__gt__(self,value)
def __gt__(self, *args, **kwargs): # real signature unknown
"""__gt__(self,value)判断self是否大于给定的值value"""
""" Return self>value. """
pass

判断self是否大于给定的值value,如果大于返回True;否则返回Fasle.__gt__(self,value)中的ge是单词greater than的缩写,表示大于。
11.__le__(self,value)
def __le__(self, *args, **kwargs): # real signature unknown
"""__le__(self,value)判断self <= value,如果条件成立返回True,否则返回False."""
""" Return self<=value. """
pass

__le__(self,value)是用于判断self是否小于等于value的,如果成立返回True;否则返回False.__le__(self,value)中le是单词less than equal的缩
写,函数是小于等于。
>>> a = 5
  >>> b = c
  >>> c = 6
  >>> a.__le__(c)
  True
  >>> a.__le__(b)
  True
12.__lt__(self,value)
def __lt__(self, *args, **kwargs): # real signature unknown
"""用于判断self<value是否成立"""
""" Return self<value. """
pass

__lt__(self,value)是用来判断self是否小于给定值value,如果条件成立,则返回True;否则返回False。__lt__中lt是单词less than的缩小,表示
小于,用来比较一个数是否小于另外一个数,实例如下:
>>> a = 5
  >>> b = 5
  >>> c = 6
  >>> d = 1
  >>> a.__lt__(b)
  False
  >>> a.__lt__(c)
  True
  >>> a.__lt__(d)
  False
下面总结了int类中几种相似的方法,以及简写和单词含义,可以帮助我们进行记忆:
技术分享

13.__float__(self)
def __float__(self, *args, **kwargs): # real signature unknown
""" float(self) """
pass
  
__float__(self)是将整数转化为浮点形数字,等价于float(a).
  >>> a = 5
  >>> a.__float__()
  5.0
  >>> float(a)
  5.0
14.__floordiv__(self,value)
def __floordiv__(self, *args, **kwargs): # real signature unknown
""" Return self//value. """
pass

__floordiv__(self,value)是用于self/vaule然后返回商向下的最接近的整数,floor和ceil是一对方法,一个是向上舍入最接近的整数,一个是向
下舍入最接近的整数,不是什么地板除,这个在Excel函数中有的,学过Excel函数的应该知道里面有两个数学函数ceiling向上舍入和floor向下舍入的函
数,这里是先进行除法,然后对商进行向下舍入。
>>> a = 8
  >>> a.__floordiv__(3)
  2
  >>> a = -8
  >>> a.__floordiv__(3)
  -3
15.__floor__(self)
def __floor__(self, *args, **kwargs): # real signature unknown
""" Flooring an Integral returns itself. """
pass

__floor__(self)是将数字向下舍入到最接近的整数,跟上面__floordiv__(self,value)方法类似,只是不需要参数,实例如下:
由于floor()在数学上应用的比较多,因此要使用__floor__()方法,要调用math模块。
import math
#导入math模块

print("math.floor(2.00001): %s" %math.floor(2.00001))
print("math.floor(2.9999999): %s" %math.floor(2.9999999))
print("math.floor(-2.000001: ) %s" %math.floor(-2.000001))

运行结果如下:
math.floor(2.00001): 2
math.floor(2.9999999): 2
math.floor(-2.000001: ) -3
16.__format__()
  def __format__(self, *args, **kwargs): # real signature unknown
  pass

17.__getattribute__(self,*args,**kwargs)
  def __getattribute__(self, *args, **kwargs): # real signature unknown
  """ Return getattr(self, name). """
"""类中的方法"""
  pass

18.__getnewargs__(self,*args,**kwargs)
  def __getnewargs__(self, *args, **kwargs): # real signature unknown
  pass
19.__hash__(self,*args,**kwargs)
  def __hash__(self, *args, **kwargs): # real signature unknown
  """ Return hash(self). """
  pass
20.__index__(self,*args,**kwargs)
  def __index__(self, *args, **kwargs): # real signature unknown
  """ Return self converted to an integer, if self is suitable for use as an index into a list. """
  """返回索引,我们知道,一般列表,字符串才有索引,这里的index()没有参数,可能在math模块中使用"""
  pass
21.__init__(self,x,base=10)
def __init__(self, x, base=10): # known special case of int.__init__
"""
"""__init__()叫构造方法,构造的时候经常用,构造类的时候使用这个函数"""
int(x=0) -> integer
int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments
are given. If x is a number, return x.__int__(). For floating point
numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base. The literal can be preceded by ‘+‘ or ‘-‘ and be surrounded
by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int(‘0b100‘, base=0)
4
# (copied from class doc)
"""
pass
22.__int__(self,*args,**kwargs)
  def __int__(self, *args, **kwargs): # real signature unknown
  """ int(self) """
    """用于把字符形数字转化为整型"""
  pass

23.__invert__(self,*args,**kwargs)
  def __invert__(self, *args, **kwargs): # real signature unknown
  """ ~self """
  pass
24.__lshift__(self,*args,**kwargs)
  def __invert__(self, *args, **kwargs): # real signature unknown
  """ ~self """
"""左移运算符,向左边移动位置,按照二进制的格式移动,有一个规律,如果移动向左移动一位等于乘以2"""
  pass
>>> a = 50
>>> a.__lshift__(1)

    0 0 0 0 1 0 1 0            二进制:10


    0 0 1 1 0 0 1 0            二进制:50


    0 0 1 1 1 0 1 0            a.__or__(a |b)

    起始int类中的方法就像我们学习数学的时候运用的方法一样,那些方法都是使用的,比如加减乘除,冪,求余,截尾等。

int类中的方法