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