裝載自：https://www.cnblogs.com/cisum/p/8064222.html

Python3 運算符

什麼是運算符？

本章節主要說明Python的運算符。舉個簡單的例子 4 +5 = 9 。 例子中，4 和 5 被稱為操作數，"+" 稱為運算符。

Python語言支持以下類型的運算符:

• 算術運算符
• 比較（關係）運算符
• 賦值運算符
• 邏輯運算符
• 位運算符
• 成員運算符
• 身份運算符
• 運算符優先順序

接下來讓我們一個個來學習Python的運算符。

Python算術運算符

以下假設變數a為10，變數b為21：

以下實例演示了Python所有算術運算符的操作：

實例(Python 3.0+)

#!/usr/bin/python3
 
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)

以上實例輸出結果：

1 - c 的值為： 31
2 - c 的值為： 11
3 - c 的值為： 210
4 - c 的值為： 2.1
5 - c 的值為： 1
6 - c 的值為： 8
7 - c 的值為： 2

Python比較運算符

以下假設變數a為10，變數b為20：

以下實例演示了Python所有比較運算符的操作：

實例(Python 3.0+)

#!/usr/bin/python3
 
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")
 
# 修改變數 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
   print ("5 - a 小於等於 b")
else:
   print ("5 - a 大於  b")
 
if ( b >= a ):
   print ("6 - b 大於等於 a")
else:
   print ("6 - b 小於 a")

以上實例輸出結果：

1 - a 不等於 b
2 - a 不等於 b
3 - a 大於等於 b
4 - a 大於 b
5 - a 小於等於 b
6 - b 大於等於 a

Python賦值運算符

以下假設變數a為10，變數b為20：

以下實例演示了Python所有賦值運算符的操作：

實例(Python 3.0+)

#!/usr/bin/python3
 
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)

以上實例輸出結果：

1 - c 的值為： 31
2 - c 的值為： 52
3 - c 的值為： 1092
4 - c 的值為： 52.0
5 - c 的值為： 2
6 - c 的值為： 2097152
7 - c 的值為： 99864

Python位運算符

按位運算符是把數字看作二進位來進行計算的。Python中的按位運演算法則如下：

下表中變數 a 為 60，b 為 13二進位格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

以下實例演示了Python所有位運算符的操作：

實例(Python 3.0+)

#!/usr/bin/python3
 
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)

以上實例輸出結果：

1 - c 的值為： 12
2 - c 的值為： 61
3 - c 的值為： 49
4 - c 的值為： -61
5 - c 的值為： 240
6 - c 的值為： 15

Python邏輯運算符

Python語言支持邏輯運算符，以下假設變數 a 為 10, b為 20:

以上實例輸出結果：

實例(Python 3.0+)

#!/usr/bin/python3
 
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")

以上實例輸出結果：

1 - 變數 a 和 b 都為 true
2 - 變數 a 和 b 都為 true，或其中一個變數為 true
3 - 變數 a 和 b 有一個不為 true
4 - 變數 a 和 b 都為 true，或其中一個變數為 true
5 - 變數 a 和 b 都為 false，或其中一個變數為 false

Python成員運算符

除了以上的一些運算符之外，Python還支持成員運算符，測試實例中包含了一系列的成員，包括字元串，列表或元組。

以下實例演示了Python所有成員運算符的操作：

實例(Python 3.0+)

#!/usr/bin/python3
 
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 中")

以上實例輸出結果：

1 - 變數 a 不在給定的列表中 list 中
2 - 變數 b 不在給定的列表中 list 中
3 - 變數 a 在給定的列表中 list 中

Python身份運算符

身份運算符用於比較兩個對象的存儲單元

註： id() 函數用於獲取對象記憶體地址。

以下實例演示了Python所有身份運算符的操作：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的標識")
else:
   print ("1 - a 和 b 沒有相同的標識")
 
if ( id(a) == id(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 有相同的標識")

以上實例輸出結果：

1 - a 和 b 有相同的標識
2 - a 和 b 有相同的標識
3 - a 和 b 沒有相同的標識
4 - a 和 b 沒有相同的標識

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運算符優先順序

以下表格列出了從最高到最低優先順序的所有運算符：

以下實例演示了Python所有運算符優先順序的操作：

實例(Python 3.0+)

#!/usr/bin/python3
 
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)

以上實例輸出結果：

(a + b) * c / d 運算結果為： 90.0
((a + b) * c) / d 運算結果為： 90.0
(a + b) * (c / d) 運算結果為： 90.0
a + (b * c) / d 運算結果為： 50.0

筆記列表

1. 開始不理解這段：

   以下假設變數 a 為 10, b為 20:
   and x and y 布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。 (a and b) 返回 20。

   百度之後得到結論：

   python 中的 and 從左到右計算表達式，若所有值均為真，則返回最後一個值，若存在假，返回第一個假值；

   or 也是從左到有計算表達式，返回第一個為真的值；

   其中數字 0 是假，其他都是真；

   字元 "" 是假，其他都是真；

    

2.  

   一開始輸入了

   a = 00111100

    

   這麼個賦值語句被提示了錯誤，於是去搜了下相關的博客得知 python 中數字有以下的表示方式：

   2 進位是以 0b 開頭的: 例如: 0b11 則表示十進位的 3

   8 進位是以 0o 開頭的: 例如: 0o11 則表示十進位的 9

   16 進位是以 0x 開頭的: 例如: 0x11 則表示十進位的 17

   但是在測試的時候又遇到了個問題，那就是輸出來的被自動轉化成了十進位：

   >>> a=0b111100
   >>> a
   60

    

   於是又去找了怎麼輸出二進位，得到了以下內容：

   分別使用 bin，oct，hex 可輸出數字的二進位，八進位，十六進位形式，例如：

   >>> a=0b111100
   >>> a=60
   >>> bin(a)
   '0b111100'
   >>> oct(a)
   '0o74'
   >>> hex(a)
   '0x3c'

    

    

3. is 與 == 區別：

   is 用於判斷兩個變數引用對象是否為同一個， == 用於判斷引用變數的值是否相等。

   is not與!=區別於上述一致，一個比較的是引用對象，另一個比較的是兩者的值。

   a = 20
   b = 20
    
   if ( a is b ):
      print ("1 - a 和 b 有相同的標識")
   else:
      print ("1 - a 和 b 沒有相同的標識")
    
   if ( id(a) == id(b) ):
      print ("2 - a 和 b 有相同的標識")
   else:
      print ("2 - a 和 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 有相同的標識")

    

   輸出結果：

   1 - a 和 b 有相同的標識
   2 - a 和 b 有相同的標識
   3 - a 和 b 沒有相同的標識
   4 - a 和 b 沒有相同的標識

    

    

4.    參考地址

   剛開始學 python，當想要自增運算的時候很自然的 a++，結果發現編譯器是不認識 ++ 的，於是去網上搜了一下，結果發現一篇老外的問答很精彩，涉及到了 python 這個語言的設計原理。

   問題無外乎就是 python 沒有自增運算符，自增操作是如何實現的。

   回答中有人介紹了關於自增操作，python 不使用 ++ 的哲學邏輯：編譯解析上的簡潔與語言本身的簡潔，就不具體翻譯了。

   後面還有老外回答並附帶了一個例子非常的精彩，指出了 python 與 c 語言概念上的一些差異，語言描述的可能未必準確，直接上例子：

   >>> b = 5  
   >>> a = 5  
   >>> id(a)  
   162334512  
   >>> id(b)  
   162334512  
   >>> a is b  
   True

    

   可以看出， python 中，變數是以內容為基準而不是像 c 中以變數名為基準，所以只要你的數字內容是5，不管你起什麼名字，這個變數的 ID 是相同的，同時也就說明瞭 python 中一個變數可以以多個名稱訪問。

   這樣的設計邏輯決定了 python 中數字類型的值是不可變的，因為如果如上例，a 和 b 都是 5，當你改變了 a 時，b 也會跟著變，這當然不是我們希望的。

   因此，正確的自增操作應該 a = a + 1 或者 a += 1，當此 a 自增後，通過 id() 觀察可知，id 值變化了，即 a 已經是新值的名稱。

    

5. 糾正一下樓上的一些觀點

   樓上的同學所說的在腳本式編程環境中沒有問題。但是在互動式環境中，編譯器會有一個小整數池的概念，會把（-5，256）間的數預先創建好，而當a和b超過這個範圍的時候，兩個變數就會指向不同的對象了，因此地址也會不一樣，比如下例：

    

   >>> a=1000
   >>> b=1000
   >>> id(a);id(b)
   2236612366224
   2236617350384
   >>>

    

    

    

6. 位運算，是自己平時最不熟悉的一塊，相信很多人也是這樣，但巧妙的運用位運算可以來解決很多題目，例如，劍指offer上面的一道：

   輸入一個整數，輸出該數二進位表示中1的個數。其中負數用補碼表示。

    

   # -*- coding:utf-8 -*-
   
   class Solution:
       def NumberOf1(self, n):
           # write code here
           cnt = 0
           if n<0:
               n = n & 0xffffffff
           while n:
               cnt+=1
               n = (n-1) & n
           return cnt

    

    

   通過按位與，巧妙的計算出二進位中"1"的個數。