數字
一、數值類型
python中支持的數值類型有以下幾種：
1、整型(Int) - 通常被稱為是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，可以當作 Long 類型使用，所以 Python3 沒有 Python2 的 Long 類型。
#!/usr/bin/python # 10進制 print(12345000000000000000000000000000000000000000000000000000000000000000000000000000000000); # 16進制 print(0x1232423435646576879796) # 8進制 print(0o123456134563163564) # 2進制 print(0b10101010010011111) # 結果如下，發現在print后，所有整數都被處理為了10進制數： 12345000000000000000000000000000000000000000000000000000000000000000000000000000000000 21998004324339122916792214 2941068610692980 87199
注意16進制、8進制、2進制的默認類型，並不是想象中的16進制、8進制、2進制的類型，而是"int"類型，而使用hex、oct、bin函數轉化后同樣不是相應類型，而是str類型，
因此可以推測，python內部對於16、8、2進制都是按照字符串來存儲的，計算時再統一轉化為10進制：
1 print(type(0x10)) 2 print(type(10)) 3 print(type(0o7)) 4 print(type(0b10)) 5 print(type(hex(0x10))) 6 print(type(oct(0x7))) 7 print(type(bin(0xb1)))
<class 'int'>
<class 'int'>
<class 'int'>
<class 'int'>
<class 'str'>
<class 'str'>
<class 'str'>
2、浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
1 # 注意浮點型數據，只能是整數表示，不能是浮點數： 2 print(0x1.0) 3 print(0o4.0) 4 print(0b0.1) 5 6 # 第一個print報錯： 7 File "/usercode/file.py", line 4 8 print(0x1.0) 9 ^ 10 SyntaxError: invalid syntax 11 12 # 第二個print報錯： 13 File "/usercode/file.py", line 3 14 print(0o4.0) 15 ^ 16 SyntaxError: invalid syntax 17 18 # 第三個print報錯： 19 File "/usercode/file.py", line 4 20 print(0b0.1) 21 ^ 22 SyntaxError: invalid syntax
3、復數( (complex)) - 復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 復數的實部a和虛部b都是浮點型。
總結如下：
| int | float | complex |
|---|---|---|
| 10 | 0.0 | 3.14j |
| 100 | 15.20 | 45.j |
| -786 | -21.9 | 9.322e-36j |
| 080 | 32.3+e18 | .876j |
| -0490 | -90. | -.6545+0J |
| -0x260 | -32.54e100 | 3e+26J |
| 0x69 | 70.2-E12 | 4.53e-7j |
4、強制數字類型轉換：
-
int(x) 將x轉換為一個整數。
-
float(x) 將x轉換到一個浮點數。-----只能接受一個參數，僅僅能轉化為小數點后1位的浮點數
-
complex(x) 將x轉換到一個復數，實數部分為 x，虛數部分為 0。
-
complex(x, y) 將 x 和 y 轉換到一個復數，實數部分為 x，虛數部分為 y。x 和 y 是數字表達式。
1 #!/usr/bin/python 2 # 10進制 3 print(int(105.021561030000)) 4 print(float(12345674864561)) 5 print(complex(5)) 6 print(complex(5.00)) 7 print(complex(5e+6j)) 8 # 不能轉化復數到int和float型數據 9 print(int(5e+6j)) 10 print(float(5e+6j)) 11 12 13 # 結果如下 14 105 15 12345674864561.0 16 (5+0j) 17 (5+0j) 18 5000000j 19 20 # 可以看到結果中，不能將復數轉化為int和float型 21 Traceback (most recent call last): File "/usercode/file3.py", line 9, in print(int(5e+6j)) TypeError: can't convert complex to int 22 Traceback (most recent call last): File "/usercode/file3.py", line 10, in print(float(5e+6j)) TypeError: can't convert complex to float
5、進制數轉換
1 # 將其它進制數數轉換為16進制： 2 >>> hex(16) 3 0x10 4 >>> hex(0o7) 5 0x7 6 >>> hex(0b1) 7 0x1 8 9 # 將其它進制數轉換為10進制： 10 >>> int(0x10) 11 16 12 >>> int(0o7) 13 7 14 >>> int(0b1) 15 1 16 17 # 將其它進制數轉換為8進制： 18 >>> oct(0x10) 19 0o20 20 >>> oct(10) 21 0o12 22 >>> oct(0b1) 23 0o1 24 25 # 將其它進制數轉換為2進制： 26 >>> bin(0x10) 27 0b10000 28 >>> bin(10) 29 0b1010 30 >>> bin(0o7) 31 0b111
運算符
一、算數運算符
1、加法
1 1 + 2 //直接輸入，回車直接輸出結果 2 3 3 >>> sum = 1 + 2 //計算結果保存在sum中 4 >>> print(sum) //輸出sum 5 3 6 >>> a = 1 //變量 7 >>> b = 2 8 >>> sum = a + b //變量相加 9 >>> print(sum) 10 3
2、減法
1 >>> a = 1 2 >>> b = 2 3 >>> 2 - 1 4 1 5 >>> a - b 6 -1 7 >>> b - a 8 1
3、乘法
1 >>> 1 * 2 2 2 3 >>> 1.5 * 3 4 4.5 5 >>> a * b 6 2 7 >>>
4、除法
1 # 以下代碼在python3中表現如此，在python2中是以整除進行的，除不盡時小數點后默認保留16位 2 >>> 1 / 3 3 0.3333333333333333 4 >>> 5 / 2 5 2.5 6 >>> 1.0 / 3 7 0.3333333333333333 8 >>> 5.0 / 2.0 9 2.5 10 11 # 特殊點，注意看，在python3中，默認整數相除，其結果也是浮點數，這個就與傳統的整數相除得整數得結論有點相悖了，在python2的基礎上修改的用力過猛了： 12 >>> 4/2 13 2.0
5、整除
1 >>> 1 // 3 2 0 3 >>> 5 // 2 4 2 5 >>> 1.0 // 3 6 0.0 7 >>> 5.0 // 2.0 8 2.0 9 10 # 當使用整除時，整數相除的結果也是整數了： 11 >>> 4//2 12 2
6、取余
1 >>> 1 % 3 2 1 3 >>> 5 % 2 4 1 5 >>> 5.0 % 2.0 6 1.0
7、冪運算
1 >>> 2 ** 3 2 8 3 >>> 2.5 ** 5 4 97.65625 5 # 負數冪實際是1/4** 6 >>> 4 ** -1 7 0.25
二、比較運算符
以下假設變量a為10，變量b為20：
| 運算符 | 描述 | 實例 |
|---|---|---|
| == | 等於 - 比較對象是否相等 | (a == b) 返回 False。 |
| != | 不等於 - 比較兩個對象是否不相等 | (a != b) 返回 true. |
| > | 大於 - 返回x是否大於y | (a > b) 返回 False。 |
| < | 小於 - 返回x是否小於y。所有比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。注意，這些變量名的大寫。 | (a < b) 返回 true。 |
| >= | 大於等於 - 返回x是否大於等於y。 | (a >= b) 返回 False。 |
| <= | 小於等於 - 返回x是否小於等於y。 | (a <= b) 返回 true。 |
1 # ==和!=運算符在比較時，等式兩端的值不必是同一類，如： 2 >>> a,b = "1",1 3 >>> print(a == b) 4 False 5 6 >>> print(a != b) 7 True 8 9 # 但是其它的比較運算符，等式兩端必須是同一類型值，否則會有報錯： 10 >>> print(a <= b) 11 Traceback (most recent call last): 12 File "/usercode/file.py", line 4, in <module> 13 print(a <= b) 14 TypeError: unorderable types: str() <= int()
三、賦值運算符
以下假設變量a為10，變量b為20：
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符 | c = a + b 將 a + b 的運算結果賦值為 c |
| += | 加法賦值運算符 | c += a 等效於 c = c + a |
| -= | 減法賦值運算符 | c -= a 等效於 c = c - a |
| *= | 乘法賦值運算符 | c *= a 等效於 c = c * a |
| /= | 除法賦值運算符 | c /= a 等效於 c = c / a |
| %= | 取模賦值運算符 | c %= a 等效於 c = c % a |
| **= | 冪賦值運算符 | c **= a 等效於 c = c ** a |
| //= | 取整除賦值運算符 | c //= a 等效於 c = c // a |
四、位運算符
下表中變量 a 為 60，b 為 13。
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 按位與運算符：參與運算的兩個值,如果兩個相應位都為1,則該位的結果為1,否則為0 | (a & b) 輸出結果 12 ，二進制解釋： 0000 1100 |
| | | 按位或運算符：只要對應的二個二進位有一個為1時，結果位就為1。 | (a | b) 輸出結果 61 ，二進制解釋： 0011 1101 |
| ^ | 按位異或運算符：當兩對應的二進位相異時，結果為1 | (a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001 |
| ~ | 按位取反運算符：對數據的每個二進制位取反,即把1變為0,把0變為1 | (~a ) 輸出結果 -61 ，二進制解釋： 1100 0011， 在一個有符號二進制數的補碼形式。 |
| << | 左移動運算符：運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。 | a << 2 輸出結果 240 ，二進制解釋： 1111 0000 |
| >> | 右移動運算符：把">>"左邊的運算數的各二進位全部右移若干位，">>"右邊的數指定移動的位數 | a >> 2 輸出結果 15 ，二進制解釋： 0000 1111 |
1 # 按位與運算符，想到一個在網絡界很常用的應用，使用IP地址和子網掩碼相與，得到這個IP地址所在的子網，比如192.168.1.1/16，其子網廣播地址為："192.168.1.1" & "255.255.0.0"，結果應該是"192.168.0.0"，當然這里只是做個例子，並不能通過字符串類型進行與操作，只能是數字類： 2 3 >>> IP,Mask = [192,168,1,1],[255,255,0,0] 4 >>>print(".".join(map(str[IP[0]&Mask[0],int(IP[1])&int(Mask[1]),IP[2] & Mask[2],IP[3] & Mask[3]] ) )) 5 6 192.168.0.0
五、邏輯運算符
Python語言支持邏輯運算符，以下假設變量 a 為 10, b為 20:
| 運算符 | 邏輯表達式 | 描述 | 實例 |
|---|---|---|---|
| and | x and y | 布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。 | (a and b) 返回 20。 |
| or | x or y | 布爾"或" - 如果 x 是 True，它返回 True，否則它返回 x 的計算值。 | (a or b) 返回 10。 |
| not | not x | 布爾"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。 | not(a and b) 返回 False |
由於and和or運算符規則比較奇葩，因此下面舉例說明一下，且最后給一個結論，不要將True、False與數值類進行與、或運算，最終結果可能不是False、True。
奇葩的and運算符：
1 # 邏輯運算符中，and比較奇葩，最終結果可能不是True或者False，而是and右邊的值： 2 3 # 10在右邊時，返回10： 4 >>> print(True and 10) 5 10 6 7 # True在右邊時，返回True： 8 >>> print(10 and True) 9 True 10 11 # 當然False或者0不論在左邊還是右邊返回值都是False，這里如果左邊的值是Flase類的話，則and不會再計算后邊的值，這個成為短路運算符： 12 >>> print(False and 10) 13 False 14 >>> print(10 and False) 15 False
奇葩的or運算符：
1 # or運算符在左邊的值為非False時，返回值就只是左邊的值： 2 >>> print(True or 10) 3 True 4 >>> print(10 or True) 5 10 6 7 # 當左邊為False或0時，才會計算右邊的值，且返回值和右邊值相同： 8 >>> print(False or 10) 9 10 10 >>> print(False or 0) 11 0 12 >>> print(False or False) 13 False
六、成員運算符
包含了一系列的成員，包括字符串，列表或元組。
| 運算符 | 描述 | 實例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否則返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中沒有找到值返回 True，否則返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
1 # 在字符串中取成員 2 >>> strA = "abcd" 3 >>> print("a" in strA) 4 True 5 6 >>> print("e" in strA) 7 False 8 9 10 # 在列表中取成員 11 >>> listA = [1,2,3,4] 12 >>> print(1 in listA) 13 True 14 15 >>> print(5 in listA) 16 False 17 18 # 在元組中取成員 19 >>> tupleA = (1,2,3,4) 20 >>> print(1 in tupleA) 21 True 22 >>> print(5 in tupleA) 23 False 24 25 # 字典中取成員 26 >>> dictA = {"a":1,"b":2} 27 >>> print("a" in dictA) 28 True 29 30 31 # 以上取成員運算都是基於靜態數據，如果成員本身是動態呢？也是可以的： 32 33 >>> listB = ([1,2,3],("a","b"),{"c":4},5) 34 >>> print([1,2,3] in listB) 35 True 36 37 >>> print(("a","b") in listB) 38 True 39 40 >>> print( {"c":4} in listB ) 41 True 42 43 44 # 上面動態數據只是一層嵌套，我們再次多層嵌套，同樣可以的，只不過動態結構內部的結構是不會被當做成員的，但是它是成員的內部成員： 45 >>> listC = [[1,2,3,[4,5]],{"c":6,"b":[7,8,9]}] 46 >>> print( [1,2,3,[4,5]] in listC ) 47 True 48 49 >>> print( [4,5] in listC ) 50 False 51 52 >>> print( [4,5] in listC[0] ) 53 True 54 55 >>> print( {"c":6,"b":[7,8,9]} in listC ) 56 True 57 58 >>> print("b" in listC ) 59 False 60 61 >>> print("b" in listC[1] ) 62 True
七、身份運算符：等同於用id()函數作用
身份運算符用於比較兩個對象的存儲單元
| 運算符 | 描述 | 實例 |
|---|---|---|
| is | is是判斷兩個標識符是不是引用自一個對象 | x is y, 如果 id(x) 等於 id(y) , is 返回結果 1 |
| is not | is not是判斷兩個標識符是不是引用自不同對象 | x is not y, 如果 id(x) 不等於 id(y). is not 返回結果 1 |
1 # 數字、字符串、元組等不可變的數據類型，由於都是靜態存儲，因此同一個變量存儲在內存中的位置都是相同的，用is運算符會返回True： 2 3 >>> a,b = 1,1 4 >>> print(a is b) 5 True 6 7 >>> a,b = "c","c" 8 >>> print(a is b) 9 True 10 11 >>> a,b = "c","c" 12 >>> print(a is b) 13 True 14 15 # 列表等可變序列的數據類型，即使值相等，但是is運算符會返回False： 16 >>> a,b = [],[] 17 >>> print(a == b) 18 True 19 20 >>> a,b = [],[] 21 >>> print(a is b) 22 False 23 24 # 可以看出兩個空列表所在的內存單元不同： 25 >>> print(id(a)) 26 139942755666120 27 >>> print(id(b)) 28 139942755665736
八、運算符的優先級
以下表格列出了從最高到最低優先級的所有運算符，在有多個運算符時，最好使用()將單元括起來計算，避免混淆。
| 運算符 | 描述 |
|---|---|
| ** | 指數 (最高優先級) |
| ~ + - | 按位翻轉, 一元加號和減號 (最后兩個的方法名為 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法減法 |
| >> << | 右移，左移運算符 |
| & | 位 'AND' |
| ^ | | 位運算符 |
| <= < > >= | 比較運算符 |
| == != | 等於運算符 |
| = %= /= //= -= += *= **= | 賦值運算符 |
| is is not | 身份運算符 |
| in not in | 成員運算符 |
| not or and | 邏輯運算符 |
一些數學函數和方法總結
一、全局基礎函數
| 函數 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回數字的絕對值，如abs(-10) 返回 10 |
| cmp(x, y) |
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已廢棄 。 |
| max(x1, x2,...) | 返回給定參數的最大值，參數可以為序列。 |
| min(x1, x2,...) | 返回給定參數的最小值，參數可以為序列。 |
| pow(x, y) | x**y 運算后的值。 |
| round(x [,n]) | 返回浮點數x的四舍五入值，如給出n值，則代表舍入到小數點后的位數。 |
二、math庫
1 # 需要在使用前先import導入math標准庫 2 >>> import math 3 4 # 兩個常數math.pi和math.e 5 >>> math.pi //圓周率pi 6 3.141592653589793 7 >>> math.e 8 2.718281828459045 //自然常數e 9 10 # math.ceil()，向上取整：返回最小的大於或等於x的值 11 >>> math.ceil(2) 12 2 13 >>> math.ceil(2.2) 14 3 15 >>> math.ceil(2.9) 16 3 17 >>> math.ceil(3.0) 18 3 19 20 # math.floor()，向下取整，返回最大的小於或等於x的整數。 21 >>> math.floor(2) 22 2 23 >>> math.floor(2.2) 24 2 25 >>> math.floor(2.9) 26 2 27 >>> math.floor(3.0) 28 3 29 30 # math.fabs()，絕對值 31 >>> math.fabs(1.0) 32 1.0 33 >>> math.fabs(-1.0) 34 1.0 35 36 37 # math.factorial()，計算階乘 38 >>> math.factorial(5) 39 120 40 >>> math.factorial(4) 41 24 42 >>> math.factorial(2.1) //執行錯誤 43 Traceback (most recent call last): 44 File "<stdin>", line 1, in <module> 45 ValueError: factorial() only accepts integral values 46 >>> 47 48 # math.exp(x)。返回e ** x。 49 >>> math.exp(2) 50 7.38905609893065 51 >>> math.e ** 2 52 7.3890560989306495 //請忽略后面的不一致，計算機浮點數本身的問題 53 54 55 *****以下運算中默認精確到1位小數點，及時本應該是整數的***** 56 # math.log(x [,base])。求以base為底的對數。 57 >>> math.log(math.e) //值傳一個參數，默認以math.e為底 58 1.0 59 >>> math.log(math.e ** 2) 60 2.0 61 >>> math.log(8, 2) //兩個參數，2為底 62 3.0 63 >>> math.log(100, 10) //兩個參數，10為底s 64 2.0 65 66 # math.pow(x, y)。冪運算，計算xy，相當於x ** y--精度不同。 67 >>> math.pow(2, 3) 68 8.0 69 >>> 2 ** 3 70 8 71 72 # math.sqrt(x)**。求x的平方根。 73 >>> math.sqrt(4) 74 2.0 75 >>> math.sqrt(4.0) 76 2.0 77 >>> math.sqrt(4.00) 78 2.0 79 >>> math.sqrt(9.0) 80 3.0 81 82 # 開根號。Python的math庫中只有開平方根，沒有立方根和n次方根，不過可以利用math.pow或者**，只需把根號變成分數。 83 >>> math.pow(4, 1.0 / 2) //平方根，相當於math.sqrt(4) 84 2.0 85 >>> 4 ** (1.0 / 2) //平方根，相當於math.sqrt(4) 86 2.0 87 >>> 8 ** (1.0 / 3) //立方根 88 2.0 89 >>> 1024 ** (1.0 / 10) //10次方根 90 2.0 91 92 ****其它的函數可以使用help(math)來查看，或者查看手冊****
常用的一些math庫函數
1、數學常量：
math.pi : 元周率
math.e : 自然常數
2、數學計算函數：
| 函數 | 返回值 ( 描述 ) |
|---|---|
| ceil(x) | 返回數字的上入整數，如math.ceil(4.1) 返回 5 |
| cmp(x, y) |
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已廢棄 。使用 (x>y)-(x<y) 替換。 |
| exp(x) | 返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回數字的絕對值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回數字的下舍整數，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10為基數的x的對數，如math.log10(100)返回 2.0 |
| modf(x) | 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。 |
| pow(x, y) | x**y 運算后的值，結果帶浮點。 |
| sqrt(x) | 返回數字x的平方根，數字可以為負數，返回類型為實數，如math.sqrt(4)返回 2+0j |
3、三角函數
| 函數 | 描述 |
|---|---|
| acos(x) | 返回x的反余弦值，以弧度形式表示 |
| asin(x) | 返回x的反正弦，以弧度形式表示 |
| atan(x) | 返回x的反正切值，以弧度表示形式 |
| atan2(y, x) | 返回反正切atan(y / x)，以弧度形式表示 |
| cos(x) | 返回x 弧度的余弦 |
| hypot(x, y) | 返回歐幾里德范數，sqrt(x*x + y*y) |
| sin(x) | 返回x的弧度的正弦值 |
| tan(x) | 返回x的弧度的正切 |
| degrees(x) | 從弧度到度角 x 的轉換 |
| radians(x) | 從角度到弧度角 x 的轉換 |
常用的一些random庫函數
可以輕松生成一些想要的隨機值，使用前先import random
| choice(seq) | 從列表，元組或字符串隨機項。 |
| randrange ([start,] stop [,step]) | 從范圍隨機選擇的元素（啟動，停止，步驟） |
| random() | 隨機浮點數r，使得0是小於或等於r，r小於1 |
| seed([x]) | 設置生成隨機數使用整數開始值。調用任何其他隨機模塊函數之前調用這個函數。返回None。 |
| shuffle(lst) | 隨機化代替列表中的項。返回None。 |
| uniform(x, y) | 隨機浮點數r，大於x小於y |