python的運算子

算數運算子

算數運算子主要用作于計算機的算數運算

種類

+

# 數字型別的加法運算
print(1 + 1)                # 2
print(False + 1)            # 1
print(0j + 1)               # (1+0j)

# 字串的拼接
var1 = 'hello'
var2 = 'motherland'
print(var1 + ' ' + var2)    # hello motherland

*

# 數字型別的乘法運算
print(1 * 1)                # 1
print(False * 1)            # 0
print(0j * 1)               # 0j

# 字串的重復
var1 = 'hello'
print(var1)                 # hello
print(var1 * 2)             # hellohello
print(var1 * 3)             # hellohellohello

/

# 數字型別的除法運算，結果總是小數，至少回傳一位小數
print(1 / 1)                # 1.0
print(False / 1)            # 0.0
# print(False / False)        # 除數不能為0
print(10 / 5)               # 2.0
print(10 / 3)               # 3.3333333333333335
print(10 / 2.25)            # 4.444444444444445

//

# 數字型別的除法運算
# // 的運算結果只有在除數或者是被除數為小數的時候才是小數，并且永遠是一位小數，小數位為0
print(1 // 1)                # 1
print(100 // 5)              # 20
print(10.9 // 1)             # 10.0
print(10 // 1.5)             # 6.0
print(10.5 // 1.1)           # 9.0
print(10.0 // 3)             # 3.0

%

# 不會將數除盡，求出除法中的余數
print(10 % 3)       # 1

# 如果被除數和除數都是負數，余數是正常余數取反
# 如果除數是負數，余數是正常余數+除數
# 如果被除數是負數，余數就是第二種情況的取反
print(10 % 3)       # 1
print(-10 % -3)       # -1
print(10 % -3)       # -2
print(-10 % 3)       # 2

print(11 % 4)       # 3
print(-11 % -4)     # -3
print(11 % -4)      # -1
print(-11 % 4)      # 1

print(15 % 6)       # 3
print(-15 % -6)     # -3
print(15 % -6)      # -3
print(-15 % 6)      # 3

**

# 求一個數的冪次方
print(2 ** 1)       # 2
print(2 ** 2)       # 4
print(2 ** 3)       # 8
print(2 ** 4)       # 16

-

# 數字型別的減法運算
print(1 - 1)                # 0
print(False - 1)            # -1
print(0j - 1)               # (-1+0j)

比較運算子

概念

1. 比較兩個值是否相同，結果只會是布林值，條件成立回傳True，反之False;
2. 可以比較任何型別的資料；
3. python沒有向其它語言中一樣區分等于和絕對等于的概念，等于就是絕對等于，是區分資料型別的；

種類

print(1234 == '1234')       # False
print(1234 == 1234)         # True

賦值運算子

概念

1. 給某個資料賦予新的值
2. 除了=之外的其它賦值運算子，都是在算數運算子的基礎上添加了=，使用的方法則和原有的意義基本相同，是將算數出來的結果替換原有的資料
3. 比較兩個值是否相同，結果只會是布林值，條件成立回傳True，反之False;
4. python沒有其它語言的自增和自減概念；

種類

# 直接賦值
var = 'msr'
print(var)      # msr
var = 'hello'
print(var)      # hello

# 通過算數運算得出結果，然后替代原有的資料
var *= 3
print(var)      # hellohellohello

成員運算子

作用

用于針對容器型資料，查詢某個資料是否是容器當中的元素；回傳布林值，條件成立回傳True，反之False；

種類

字串

# 只可以連續的元素，就是說不支持模糊查詢

var = '你是Java的大神，他是PHP的開發者，我是Python的小白，'
print('Java的大神' in var)         # True
print('Python的小白' not in var)   # False

字典

# 在字典當中只會判斷鍵，不會判斷值
var = {'及時雨': '宋江', '玉麒麟': '盧俊義'}
print('及時雨' in var)  # True
print('宋江' in var)  # False

身份運算子

作用

檢測兩個資料在記憶體當中是否是同一個值，回傳布林值

種類

Python的記憶體優化

• 整型：-5 ~~ 正無窮的范圍內的數記憶體地址相同
• 浮點型：非負數的記憶體的地址相同
• 布爾型：同值記憶體地址相同
• 復數：實數+虛數的的格式永不相同
• 容器型別：只有字串和空元組的情況相同

intvar = 100
strvar = 'hello'

# 利用id()函式檢查是否是同一地址
res = id(intvar) == id(strvar)
print(res)      # False

# 使用身份運算子
res = intvar is strvar
print(res)      # fasle

邏輯運算子

作用

判斷運算子兩邊的布林值，回傳布林值

種類

and——邏輯與

運算子兩遍的值都為真，回傳真，其余情況回傳假

# 為真的概率低
res = True and True		# True
res = True and False	# False
res = False and True	# False
res = False and False	# False

or——邏輯與

運算子兩遍的值都為假，回傳假，其余情況回傳真

# 為假得概率低
res = True or True		# True
res = True or False		# True
res = False or True		# True
res = False or False	# False

not——邏輯非

將左側的進行反轉，真的轉為假，假的轉為真

res = not True		# False
res = not False		# True

布林值為假的十種情況還記得嗎？？？

0 0.0 0j False "" [] () set() {} None

邏輯短路

• True or 運算式
• False and 運算式

在邏輯運算式中，or的特點是一真則真，所以True or首先是發現前面已經有了真，所以or就無需再檢查后面的資料是真是假，直接回傳前面的真，導致不在執行后面的代碼，造成邏輯短路，

False and同理，and一假則假，所以當and前面出現假的時候，就不在需要知道后面的資料是真是假，直接回傳假，造成邏輯短路，

# 邏輯短路，不會執行后面的print函式

True  or  print('hello world')
False and print('hello world')

# 沒有短路
False  or  print('hello world')
True   and print('hello world')

邏輯運算子的優先級

() > not > and > or

和數學的運算一樣，要先運算括號內的資料，

在多邏輯運算子的算數中，按照優先級計算，

0 or 6 and not 9 and (1 or 3)
# 按照優先級依次運算，得出結果為False

位運算子

作用

位運算子用二進制數補碼進行運算

種類

&（按位與）

將數字的補碼中，同位數都為真的保留下來，組合成新數字

19的補碼： 0000 ... 10011
15的補碼： 0000 ... 01111
同位數都為真的保留下來： 0000 ... 00011 => 3

print(15 & 19)

|（按位或）

將數字的補碼中，同位數只要有一個為真就保留下來，組合成新數字

19的補碼： 0000 ... 10011
15的補碼： 0000 ... 01111
同位數一個為真的保留下來： 0000 ... 11111 => 31

print(15 | 19)

^（按位異或）

將數字的補碼中，同位數相同回傳假，不同回傳真，組合成新數字

19的補碼： 0000 ... 10011
15的補碼： 0000 ... 01111
同位數不同的回傳真： 0000 ... 11100 => 28

print(15 ^ 19)

<<（左移位）

整個數字向左移位，原位補0，組合成新數字

左移位相當于做乘法，左移n位，就相當于乘 2 的n次冪

19的補碼：0001 0011
左移1位： 0010 0110 => 38

print(19 << 1)

>>（右移位）

整個數字向右移位，原位補0，溢位消失，組合成新數字
右移位相當于做除法，左移n位，就相當于除以 2 的n次冪

19的補碼：0001 0011
右移1位： 0000 1001 => 9

print(19 >> 1)

~ 按位非

按位取反，包括符號位，
公式：-(n + 1)

十進制數：19

原碼： 0001 0011
反碼： 0001 0011
補碼： 0001 0011 （先得到一個數的補碼）
按位非：1110 1100 （按位非，包括符號位在內的全部取反）
補碼： 1110 1100 （結果還是補碼）
取反： 1001 0011
原碼： 1001 0100 （根據這個補碼還原的原碼）

十進制數：-20 -(19 + 1) = -20

print(~19)

運算子總結：

運算子種類

1. 算術運算子： + - * / // % **
2. 比較運算子： > < >= <= == !=
3. 賦值運算子： = += -= *= /= //= %= **=
4. 成員運算子： in 、 not in
5. 身份運算子： is 、 is not
6. 邏輯運算子： and 、 or 、 not
7. 位運算子： & | ^ ~ << >>

運算子優先級

權重從小之下

1. 當多種運算子混合使用：
   算數 > 位 > 比較 > 身份 > 成員 > 邏輯 > 賦值

2. 一元運算子 > 二元運算子
   一元運算子：同一時間只操作一個值，比如按位非（~19）、邏輯非（not True）
   二元運算子：同一時間操作兩個值，多數是這樣的，比如冪運算（2 ** 3）、邏輯與（True and False）

3. 算數運算子：
   冪運算 > 乘除 > 加減

4. 位運算子：
   按位非 > 左右移 > 按位與 > 按位異或 > 按位或

5. 邏輯運算子：
   () > not > and > or

6. 賦值運算子：
   = 最小

小經驗

這是我的一點心得：

寫出機器看得懂的代碼是行業門欖，質量高的代碼是行業的水準，讓人看得懂的代碼是行業的標桿，一個優秀的編程作業者寫的代碼會看起來更加的直觀，

在撰寫復雜的運算式的時候要注意盡量的讓代碼直觀，比如可以使用括號，下面的兩行運算式的結果一樣，但是給人的截然不同，

# 你也可以試著根據運算子優先級 推算一下結果

res = 5 + 5 << 6 // 3 is 40 and True
print(res)

res = (5+5) << (6//3) is 40 and True
print(res)

標籤：其他

上一篇：Java學習-JDBC

下一篇：牛逼！MySQL 8.0 中的索引可以隱藏了…