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類中的方法就像我們學習數學的時候運用的方法一樣，那些方法都是使用的，比如加減乘除，冪，求余，截尾等。