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和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类中的方法就像我们学习数学的时候运用的方法一样，那些方法都是使用的，比如加减乘除，冪，求余，截尾等。