Python學習筆記Day3 - Python運算符

1. Python 類型轉換

---

2. Python算術運算符

• 2.1加法(+)運算符

m = 10
    n = 97
    sum1 = m + n
    x = 7.2
    y = 15.3
    sum2 = x + y
    print("sum1=%d, sum2=%.2f" % (sum1, sum2) )

運行結果： sum1=107, sum2=22.50

拼接字符串

當+用於數字時表示加法，可是當+用於字符串時，它還有拼接字符串（將兩個字符串鏈接爲一個）的做用：

name = "個人我的博客"  
url = "www.linuxleesinloveyy.cn"  
age = `  
info = name + "的網址是" + url + "，它已經" + str(age) + "歲了"  
print(info)

運行結果：個人我的博客的網址是www.linuxleesinloveyy.cn，它已經1歲了

• 2.2減法(-)運算符

n = 45
    m = -n
    x = -83.5
    y = -x
    print(m, ",", y)

運行結果：-45 , 83.5

求負

-除了能夠用做減法運算以外，還能夠用做求負運算（正數變負數，負數變正數）:

n = 45
n_neg = -n
f = -83.5
f_neg = -f
print(n_neg, ",", f_neg)

運行結果：-45 , 83.5

• 乘法(*)運算符

n = 4 * 25
    f = 34.5 * 2
    print(n, ",", f)

運行結果：100 , 69.0

重複字符串

*除了能夠用做乘法運算，還能夠用來重複字符串，也即將 n 個一樣的字符串鏈接起來：

str1 = "hello "
print(str1 * 4)

運行結果：hello hello hello hello

• 2.3 / 和 // 除法運算符

Python 支持/和//兩個除法運算符，但它們之間是有區別的：

• /表示普通除法，使用它計算出來的結果和數學中的計算結果相同。
• //表示整除，只保留結果的整數部分，捨棄小數部分；注意是直接丟掉小數部分，而不是四捨五入。

實例：

#整數不能除盡
print("23/5 =", 23/5)
print("23//5 =", 23//5)
print("23.0//5 =", 23.0//5)
print("-------------------")
#整數能除盡
print("25/5 =", 25/5)
print("25//5 =", 25//5)
print("25.0//5 =", 25.0//5)
print("-------------------")
#小數除法
print("12.4/3.5 =", 12.4/3.5)
print("12.4//3.5 =", 12.4//3.5)

運行結果：

23/5 = 4.6
23//5 = 4
23.0//5 = 4.0
-------------------
25/5 = 5.0
25//5 = 5
25.0//5 = 5.0
-------------------
12.4/3.5 = 3.542857142857143
12.4//3.5 = 3.0

從運行結果能夠發現：

1. /的計算結果老是小數，不論是否能除盡，也無論參與運算的是整數仍是小數。
2. 當有小數參與運算時，//結果纔是小數，不然就是整數。

• 2.4 求餘(%)運算符

Python % 運算符用來求得兩個數相除的餘數，包括整數和小數。Python 使用第一個數字除以第二個數字，獲得一個整數的商，剩下的值就是餘數。對於小數，求餘的結果通常也是小數。

注意： 求餘運算的本質是除法運算，因此第二個數字也不能是 0，不然會致使 ZeroDivisionError 錯誤

Python % 使用示例：

print("-----整數求餘-----")
print("15%6 =", 15%6)
print("-15%6 =", -15%6)
print("15%-6 =", 15%-6)
print("-15%-6 =", -15%-6)
print("-----小數求餘-----")
print("7.7%2.2 =", 7.7%2.2)
print("-7.7%2.2 =", -7.7%2.2)
print("7.7%-2.2 =", 7.7%-2.2)
print("-7.7%-2.2 =", -7.7%-2.2)
print("---整數和小數運算---")
print("23.5%6 =", 23.5%6)
print("23%6.5 =", 23%6.5)
print("23.5%-6 =", 23.5%-6)
print("-23%6.5 =", -23%6.5)
print("-23%-6.5 =", -23%-6.5)

運行結果：

-----整數求餘-----
15%6 = 3
-15%6 = 3
15%-6 = -3
-15%-6 = -3
-----小數求餘-----
7.7%2.2 = 1.0999999999999996
-7.7%2.2 = 1.1000000000000005
7.7%-2.2 = -1.1000000000000005
-7.7%-2.2 = -1.0999999999999996
---整數和小數運算---
23.5%6 = 5.5
23%6.5 = 3.5
23.5%-6 = -0.5
-23%6.5 = 3.0
-23%-6.5 = -3.5

從運行結果能夠發現兩點：

• 只有當第二個數字是負數時，求餘的結果纔是負數。換句話說，求餘結果的正負和第一個數字沒有關係，只由第二個數字決定
• %兩邊的數字都是整數時，求餘的結果也是整數；可是隻要有一個數字是小數，求餘的結果就是小數。
• 次方（乘方）運算符

Python ** 運算符用來求一個 x 的 y 次方，也即次方（乘方）運算符。

Python ** 運算符示例：

print('----次方運算----')
print('3**4 =', 3**4)
print('2**5 =', 2**5)
print('----開方運算----')
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))

運行結果：

----次方運算----
3**4 = 81
2**5 = 32
----開方運算----
81**(1/4) = 3.0
32**(1/5) = 2.0

---

3. Python賦值運算符

Python 中最基本的賦值運算符是等號=；結合其它運算符，=還能擴展出更強大的賦值運算符。

• 基本賦值運算符號

#將字面量（直接量）賦值給變量
    n1 = 100
    f1 = 47.5
    s1 = "http://c.biancheng.net/python/"
    #將一個變量的值賦給另外一個變量
    n2 = n1
    f2 = f1
    #將某些運算的值賦給變量
    sum1 = 25 + 46 
    sum2 = n1 % 6
    s2 = str(1234)  #將數字轉換成字符串
    s3 = str(100) + "abc"

• 賦值運算符擴展

= 還可與其餘運算符（包括算術運算符、位運算符和邏輯運算符）相結合，擴展成爲功能更增強大的賦值運算符

運算符擴展實例：

n1 = 100
f1 = 25.5
n1 -= 80  #等價於 n1=n1-80
f1 *= n1 - 10 #等價於 f1=f1*( n1 - 10 )
print("n1=%d" % n1)
print("f1=%.2f" % f1)

運行結果：

n1=20
f1=255.00

---

4. 位運算符

Python 位運算符只能用來操做整數類型，它按照整數在內存中的二進制形式進行計算

• 4.1 & 按位與運算符

按位與運算符&的運算規則是：只有參與&運算的兩個位都爲 1 時，結果才爲 1，不然爲 0。

第一個Bit位	第二個Bit位	結果
0	0	0
0	1	0
1	0	0
1	1	1

例如，9&5 能夠轉換成以下的運算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在內存中的存儲）
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在內存中的存儲）
--------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001  （1 在內存中的存儲）

• 4.2 | 按位或運算符

按位或運算符|的運算規則是：兩個二進制位有一個爲 1 時，結果就爲 1，兩個都爲 0 時結果才爲 0。

例如，9 | 5 能夠轉換成以下的運算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在內存中的存儲）
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在內存中的存儲）
---------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101  （13 在內存中的存儲）

-9 | 5 能夠轉換成以下的運算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在內存中的存儲）
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在內存中的存儲）
----------------------------------------------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在內存中的存儲）

• 4.3 ^按位異或運算符

按位異或運算^的運算規則是：參與運算的兩個二進制位不一樣時，結果爲 1，相同時結果爲 0。

9 ^ 5能夠轉換成以下的運算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在內存中的存儲）
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在內存中的存儲）
----------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100  （12 在內存中的存儲）

-9 ^ 5能夠轉換成以下的運算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在內存中的存儲）
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101  （5 在內存中的存儲）
----------------------------------------------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010  （-14 在內存中的存儲）

• 4.4 ~按位取反運算符

按位取反運算符~爲單目運算符（只有一個操做數），右結合性，做用是對參與運算的二進制位取反。

~9能夠轉換爲以下的運算：

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在內存中的存儲）
----------------------------------------------------------------------
  1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110  （-10 在內存中的存儲）

~-9能夠轉換爲以下的運算：

~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在內存中的存儲）
----------------------------------------------------------------------
  0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000  （8 在內存中的存儲）

• 4.5 <<左移運算符

Python 左移運算符<<用來把操做數的各個二進制位所有左移若干位，高位丟棄，低位補 0。

9<<3能夠轉換爲以下的運算：至關於乘以2**3

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在內存中的存儲）
-----------------------------------------------------------------------
   0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000  （72 在內存中的存儲）

(-9)<<3能夠轉換爲以下的運算：至關於除以2**3

<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在內存中的存儲）
------------------------------------------------------------------------
   1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000  （-72 在內存中的存儲）

• 4.6 >>右移運算符

Python 右移運算符>>用來把操做數的各個二進制位所有右移若干位，低位丟棄，高位補 0 或 1。
若是數據的最高位是 0，那麼就補 0；若是最高位是 1，那麼就補 1。

9>>3 能夠轉換爲以下的運算：

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001  （9 在內存中的存儲）
----------------------------------------------------------------------
   0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001  （1 在內存中的存儲）

(-9)>>3 能夠轉換爲以下的運算：

>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111  （-9 在內存中的存儲）
-----------------------------------------------------------------------
   1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110  （-2 在內存中的存儲）

---

5. Python比較運算符

比較運算符，也稱關係運算符，用於對常量、變量或表達式的結果進行大小比較。
若是這種比較是成立的，則返回 True（真），反之則返回 False（假）。

Python 比較運算符的使用舉例：

print("89是否大於100：", 89 > 100)
print("24*5是否大於等於76：", 24*5 >= 76)
print("86.5是否等於86.5：", 86.5 == 86.5)
print("34是否等於34.0：", 34 == 34.0)
print("False是否小於True：", False < True)
print("True是否等於True：", True < True)

運行結果：

89是否大於100： False
24*5是否大於等於76： True
86.5是否等於86.5： True
34是否等於34.0： True
False是否小於True： True
True是否等於True： False

== 和 is 的區別: == 用來比較兩個變量的值是否相等，而 is 則用來比對兩個變量引用的是不是同一個對象

import time  #引入time模塊
t1 = time.gmtime() # gmtime()用來獲取當前時間
t2 =  time.gmtime()
print(t1 == t2) #輸出True
print(t1 is t2) #輸出False

運行結果：

True
False

分析：

time 模塊的 gmtime() 方法用來獲取當前的系統時間，精確到秒級，由於程序運行很是快，因此 t1 和 t1 獲得的時間是同樣的。== 用來判斷 t1 和 t2 的值是否相等，因此返回 True。

雖然 t1 和 t2 的值相等，但它們是兩個不一樣的對象（每次調用 gmtime() 都返回不一樣的對象），因此t1 is t2返回 False。這就好像兩個雙胞胎姐妹，雖然她們的外貌是同樣的，但它們是兩我的。

如何判斷兩個對象是否相同呢？答案是判斷兩個對象的內存地址。若是內存地址相同，說明兩個對象使用的是同一塊內存，固然就是同一個對象了。

---

6. Python邏輯運算符

邏輯運算符實例：

age = int(input("請輸入年齡："))
height = int(input("請輸入身高："))
if age>=18 and age<=30 and height >=170 and height <= 185 :
    print("恭喜，你符合報考飛行員的條件")
else:
    print("抱歉，你不符合報考飛行員的條件")

可能的運行結果：

請輸入年齡：23↙
請輸入身高：178↙
恭喜，你符合報考飛行員的條件

在 Python 中，and 和 or 不必定會計算右邊表達式的值，有時候只計算左邊表達式的值就能獲得最終結果。

另外，and 和 or 運算符會將其中一個表達式的值做爲最終結果，而不是將 True 或者 False 做爲最終結果。

對於and運算符：

• 若是左邊表達式的值爲假，那麼就不用計算右邊表達式的值了，由於無論右邊表達式的值是什麼，都不會影響最終結果，最終結果都是假，此時 and 會把左邊表達式的值做爲最終結果。
• 若是左邊表達式的值爲真，那麼最終值是不能肯定的，and 會繼續計算右邊表達式的值，並將右邊表達式的值做爲最終結果。

對於or運算符：

• 若是左邊表達式的值爲真，那麼就不用計算右邊表達式的值了，由於無論右邊表達式的值是什麼，都不會影響最終結果，最終結果都是真，此時 or 會把左邊表達式的值做爲最終結果.
• 若是左邊表達式的值爲假，那麼最終值是不能肯定的，or 會繼續計算右邊表達式的值，並將右邊表達式的值做爲最終結果。

使用代碼驗證上面的結論：

url = "http://c.biancheng.net/cplus/"
print("----False and xxx-----")
print( False and print(url) )
print("----True and xxx-----")
print( True and print(url) )
print("----False or xxx-----")
print( False or print(url) )
print("----True or xxx-----")
print( True or print(url) )

運行結果：

----False and xxx-----
False
----True and xxx-----
http://c.biancheng.net/cplus/
None
----False or xxx-----
http://c.biancheng.net/cplus/
None
----True or xxx-----
True

---

7. Python 運算符優先級

實際編程中，建議使用括號明確運算符執行順序，不要過分依賴運算符優先級，避免引發沒必要要的錯誤。