什麼是運算符？
本章節主要說明Python的運算符。舉個簡單的例子
4 +5 = 9 。 例子中，4 和 5 被稱為操作數，"+" 稱為運算符。Python語言支持以下類型的運算符:
- 算術運算符
- 比較（關係）運算符
- 賦值運算符
- 邏輯運算符
- 位運算符
- 成員運算符
- 身份運算符
- 運算符優先級
接下來讓我們一個個來學習Python的運算符。
Python算術運算符
以下假設變量： a=10，b=20：
運算符描述實例+加 - 兩個對象相加a + b 輸出結果 30-減 - 得到負數或是一個數減去另一個數a - b 輸出結果 -10*乘 - 兩個數相乘或是返回一個被重複若干次的字符串a * b 輸出結果 200/除 - x除以yb / a 輸出結果 2%取模 - 返回除法的餘數b % a 輸出結果 0**冪 - 返回x的y次冪a**b 為10的20次方， 輸出結果 100000000000000000000//取整除 - 返回商的整數部分（
向下取整）<code>>>>
9
//2
4
>>>
-9
//2
-5
/<code>
以下實例演示了Python所有算術運算符的操作：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 21 b = 10 c = 0 c = a + b print "1 - c 的值為：", c c = a - b print "2 - c 的值為：", c c = a * b print "3 - c 的值為：", c c = a / b print "4 - c 的值為：", c c = a % b print "5 - c 的值為：", c # 修改變量 a 、b 、c a = 2 b = 3 c = a**b print "6 - c 的值為：", c a = 10 b = 5 c = a//b print "7 - c 的值為：", c
運行實例 »
以上實例輸出結果：
<code>1
-
c
的值為：
31
2
-
c
的值為：
11
3
-
c
的值為：
210
4
-
c
的值為：
2
5
-
c
的值為：
1
6
-
c
的值為：
8
7
-
c
的值為：
2
/<code>
注意：Python2.x 裡，整數除整數，只能得出整數。如果要得到小數部分，把其中一個數改成浮點數即可。
>>> 1/2 0 >>> 1.0/2 0.5 >>> 1/float(2) 0.5
Python比較運算符
以下假設變量a為10，變量b為20：
運算符描述實例==等於 - 比較對象是否相等(a == b) 返回 False。!=不等於 - 比較兩個對象是否不相等(a != b) 返回 true.<>不等於 - 比較兩個對象是否不相等。python3 已廢棄。(a <> b) 返回 true。這個運算符類似 != 。>大於 - 返回x是否大於y(a > b) 返回 False。=大於等於 - 返回x是否大於等於y。(a >= b) 返回 False。<=小於等於 - 返回x是否小於等於y。(a <= b) 返回 true。
以下實例演示了Python所有比較運算符的操作：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 21 b = 10 c = 0 if a == b : print "1 - a 等於 b" else: print "1 - a 不等於 b" if a != b : print "2 - a 不等於 b" else: print "2 - a 等於 b" if a <> b : print "3 - a 不等於 b" else: print "3 - a 等於 b" if a < b : print "4 - a 小於 b" else: print "4 - a 大於等於 b" if a > b : print "5 - a 大於 b" else: print "5 - a 小於等於 b" # 修改變量 a 和 b 的值 a = 5 b = 20 if a <= b : print "6 - a 小於等於 b" else: print "6 - a 大於 b" if b >= a : print "7 - b 大於等於 a" else: print "7 - b 小於 a"
以上實例輸出結果：
<code>1
- a 不等於 b
2
- a 不等於 b
3
- a 不等於 b
4
- a 大於等於 b
5
- a 大於 b
6
- a 小於等於 b
7
- b 大於等於 a
/<code>
Python賦值運算符
以下假設變量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
以下實例演示了Python所有賦值運算符的操作：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 21 b = 10 c = 0 c = a + b print "1 - c 的值為：", c c += a print "2 - c 的值為：", c c *= a print "3 - c 的值為：", c c /= a print "4 - c 的值為：", c c = 2 c %= a print "5 - c 的值為：", c c **= a print "6 - c 的值為：", c c //= a print "7 - c 的值為：", c
以上實例輸出結果：
<code>1
-
c
的值為：
31
2
-
c
的值為：
52
3
-
c
的值為：
1092
4
-
c
的值為：
52
5
-
c
的值為：
2
6
-
c
的值為：
2097152
7
-
c
的值為：
99864
/<code>
Python位運算符
按位運算符是把數字看作二進制來進行計算的。Python中的按位運算法則如下：
下表中變量 a 為 60，b 為 13，二進制格式如下：
<code>a
=
0011
1100
b
=
0000
1101
-----------------
a&b
=
0000
1100
a|b
=
0011
1101
a^b
=
0011
0001
~a
=
1100
0011
/<code>
運算符描述實例&按位與運算符：參與運算的兩個值,如果兩個相應位都為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 。~x 類似於 -x-1(~a ) 輸出結果 -61 ，二進制解釋： 1100 0011，在一個有符號二進制數的補碼形式。< 右邊的數字指定了移動的位數，高位丟棄，低位補0。a << 2 輸出結果 240 ，二進制解釋： 1111 0000>>右移動運算符：把">>"左邊的運算數的各二進位全部右移若干位，>> 右邊的數字指定了移動的位數a >> 2 輸出結果 15 ，二進制解釋： 0000 1111
以下實例演示了Python所有位運算符的操作：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0 c = a & b; # 12 = 0000 1100 print "1 - c 的值為：", c c = a | b; # 61 = 0011 1101 print "2 - c 的值為：", c c = a ^ b; # 49 = 0011 0001 print "3 - c 的值為：", c c = ~a; # -61 = 1100 0011 print "4 - c 的值為：", c c = a << 2; # 240 = 1111 0000 print "5 - c 的值為：", c c = a >> 2; # 15 = 0000 1111 print "6 - c 的值為：", c
以上實例輸出結果：
<code>1
-
c
的值為：
12
2
-
c
的值為：
61
3
-
c
的值為：
49
4
-
c
的值為：
-61
5
-
c
的值為：
240
6
-
c
的值為：
15
/<code>
Python邏輯運算符
Python語言支持邏輯運算符，以下假設變量 a 為 10, b為 20:
運算符邏輯表達式描述實例andx and y布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。(a and b) 返回 20。orx or y布爾"或" - 如果 x 是非 0，它返回 x 的值，否則它返回 y 的計算值。(a or b) 返回 10。notnot x布爾"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。not(a and b) 返回 False
以上實例輸出結果：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 10 b = 20 if a and b : print "1 - 變量 a 和 b 都為 true" else: print "1 - 變量 a 和 b 有一個不為 true" if a or b : print "2 - 變量 a 和 b 都為 true，或其中一個變量為 true" else: print "2 - 變量 a 和 b 都不為 true" # 修改變量 a 的值 a = 0 if a and b : print "3 - 變量 a 和 b 都為 true" else: print "3 - 變量 a 和 b 有一個不為 true" if a or b : print "4 - 變量 a 和 b 都為 true，或其中一個變量為 true" else: print "4 - 變量 a 和 b 都不為 true" if not( a and b ): print "5 - 變量 a 和 b 都為 false，或其中一個變量為 false" else: print "5 - 變量 a 和 b 都為 true"
以上實例輸出結果：
<code>1
-
變量
a
和
b
都為
true
2
-
變量
a
和
b
都為
true
，或其中一個變量為
true
3
-
變量
a
和
b
有一個不為
true
4
-
變量
a
和
b
都為
true
，或其中一個變量為
true
5
-
變量
a
和
b
都為
false
，或其中一個變量為
false
/<code>
Python成員運算符
除了以上的一些運算符之外，Python還支持成員運算符，測試實例中包含了一系列的成員，包括字符串，列表或元組。
運算符描述實例in如果在指定的序列中找到值返回 True，否則返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。not in如果在指定的序列中沒有找到值返回 True，否則返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
以下實例演示了Python所有成員運算符的操作：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 10 b = 20 list = [1, 2, 3, 4, 5 ]; if ( a in list ): print "1 - 變量 a 在給定的列表中 list 中" else: print "1 - 變量 a 不在給定的列表中 list 中" if ( b not in list ): print "2 - 變量 b 不在給定的列表中 list 中" else: print "2 - 變量 b 在給定的列表中 list 中" # 修改變量 a 的值 a = 2 if ( a in list ): print "3 - 變量 a 在給定的列表中 list 中" else: print "3 - 變量 a 不在給定的列表中 list 中"
以上實例輸出結果：
<code>1
- 變量 a 不在給定的列表中list
中2
- 變量 b 不在給定的列表中list
中3
- 變量 a 在給定的列表中list
中/<code>
Python身份運算符
身份運算符用於比較兩個對象的存儲單元
運算符描述實例isis 是判斷兩個標識符是不是引用自一個對象x is y, 類似 id(x) == id(y) , 如果引用的是同一個對象則返回 True，否則返回 Falseis notis not 是判斷兩個標識符是不是引用自不同對象x is not y ， 類似 id(a) != id(b)。如果引用的不是同一個對象則返回結果 True，否則返回 False。
注： id() 函數用於獲取對象內存地址。
以下實例演示了Python所有身份運算符的操作：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 20 b = 20 if ( a is b ): print "1 - a 和 b 有相同的標識" else: print "1 - a 和 b 沒有相同的標識" if ( a is not b ): print "2 - a 和 b 沒有相同的標識" else: print "2 - a 和 b 有相同的標識" # 修改變量 b 的值 b = 30 if ( a is b ): print "3 - a 和 b 有相同的標識" else: print "3 - a 和 b 沒有相同的標識" if ( a is not b ): print "4 - a 和 b 沒有相同的標識" else: print "4 - a 和 b 有相同的標識"
以上實例輸出結果：
<code>1
- a 和 b 有相同的標識
2
- a 和 b 有相同的標識
3
- a 和 b 沒有相同的標識
4
- a 和 b 沒有相同的標識
/<code>
is 與 == 區別：
is 用於判斷兩個變量引用對象是否為同一個(同一塊內存空間)， == 用於判斷引用變量的值是否相等。
>>> a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a True
Python運算符優先級
以下表格列出了從最高到最低優先級的所有運算符：
運算符描述**指數 (最高優先級)~ + -按位翻轉, 一元加號和減號 (最後兩個的方法名為 +@ 和 -@)* / % //乘，除，取模和取整除+ -加法減法>> < >=比較運算符<> == !=等於運算符= %= /= //= -= += *= **=賦值運算符is is not身份運算符in not in成員運算符not and or邏輯運算符
以下實例演示了Python所有運算符優先級的操作：
實例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 20 b = 10 c = 15 d = 5 e = 0 e = (a + b) * c / d #( 30 * 15 ) / 5 print "(a + b) * c / d 運算結果為：", e e = ((a + b) * c) / d # (30 * 15 ) / 5 print "((a + b) * c) / d 運算結果為：", e e = (a + b) * (c / d); # (30) * (15/5) print "(a + b) * (c / d) 運算結果為：", e e = a + (b * c) / d; # 20 + (150/5) print "a + (b * c) / d 運算結果為：", e
以上實例輸出結果：
<code>(a + b) *c
/ d 運算結果為：90
((a + b) *c
) / d 運算結果為：90
(a + b) * (c
/ d) 運算結果為：90
a + (b *c
) / d 運算結果為：50
/<code>
學習筆記：
python中會為每個出現的對象分配內存，哪怕他們的值完全相等（注意是相等不是相同）。如執行a=2.0，b=2.0這兩個語句時會先後為2.0這個Float類型對象分配內存，然後將a與b分別指向這兩個對象。所以a與b指向的不是同一對象：
<code> > a=2.0
> b=2.0
> a is b False > a==b True > e/<code>
但是為了提高內存利用效率對於一些簡單的對象，如一些數值較小的int對象，python採取重用對象內存的辦法，如指向a=2，b=2時，由於2作為簡單的int類型且數值小，python不會兩次為其分配內存，而是隻分配一次，然後將a與b同時指向已分配的對象：
<code> > a=2
> b=2
> a is b True > a==b True/<code>
如但果賦值的不是2而是大的數值，情況就跟前面的一樣了：
<code> > a=4444
> b=4444
> a is b False > a==b True/<code>
如果變量寫在同一行,將會指向同一個對象
<code> > a=4444
; b=4444
; > a is b True > a == b True > c =5555
> d =5555
> c is d False > c == d True > /<code>
以上情況在交互模式會出現，使用腳本運行，不管是否同一行，都是指向同一個地址：
<code># -*- coding: utf-8
-*- a =4444
; b =4444
is
b) #true
c
=5555
d =5555
c
is
d) #true
/<code>
Python 中沒有 ++ 或 -- 自運算符
因為在 Python 裡的數值和字符串之類的都是不可變對象，對不可變對象操作的結果都會生成一個新的對象。
比如：
<code>a = 1 a += 1/<code>
在 C/java 之類的語言中，把 a 指向內存地址單元數據值由 1 改成了 2。
但是在 Python 中是完全不同的另一套機制。
解釋器創建一個新的整數對象 2。
然後把這個對象的地址再次分配給 a。
見下面代碼:
<code> > id(1
)41116008
L > a =1
> id(a)41116008
L > id(2
)41115984
L >a +=1
> id(a)41115984
L > /<code>
所以在 Python 中不可能出現C/java 之類那種單獨一行一個 i++，i-- 的。
Python 基礎的發現個問題，有一個列表 a=[1,2,3,4,5]，賦值給 b 的兩種方式：
<code>b
=ab
=a[:]/<code>
結果都是: [1, 2, 3, 4, 5]
這兩種賦值結果看起來都是一樣的，但是他們有什麼區別麼？
區別就是:
- 前者傳遞引用
- 後者是拷貝
Python 有個叫做
id 的函數能夠得到對象的地址，你打印出來看看就清楚了。直接 = 是引用賦值，引用原來的對象；而 [:] 是重新推導，會生成新的對象。<code> > a=[1
,2
,3
,4
,5
] > b=a > c=a[:
] > id(a)4410359536
> id(b)4410359536
> id(c)4410358240
/<code>
從以上結果上看 id(a) 與 id(b) 的內存地址一樣的，而 id(a) 與 id(c) 內存地址不一樣。
