---
# System prepended metadata

title: Python運算子(2)
tags: [Python基礎教學]

---

# Python運算子(2)

### ***忘記了很正常，不正常的是你根本沒記起來過***

### ***by 幻宇***

Python的運算子(operator)可以分成幾個主要類型
- **算數**運算子(Arithmetic Operators)
- **比較**運算子(Comparison Operators)
- **邏輯**運算子 (Logical Operators)
- **賦值**(**指定**)運算子(Assignment Operators)
- **位元**運算子(Bitwise Operators)
- **成員**運算子(Member Operators)
- **身分**運算子(Identity Operators)

##### 註:字串運算子在分類上並不屬於運算子，Python的字串運算子行為是由類別方法來控制的，而不是由語法層級直接支持。而字串運算子的部分會在下一篇 ***Python字串的基本操作與進階應用*** 中說明


## 算數運算子

算數運算子主要負責程式中的四則運算
- `+`:加法
```python
a = 5 + 3 #數字相加
#8
```

- `-`:減法
```python
a = 5 - 3 #數字相減
#2
```

- `*`:乘法
```python
a = 5 * 3 #數字相乘
#15
```

- `/`:除法
```python
a = 5 / 3 #數字相除，結果必為浮點數
#1.666666666666666......
```

- `%`:取餘數
```python
a = 5 % 3 #數字相除取餘數
#2
```

- `//`:取商數
```python
a = 5 // 3 #數字相除取商數
#1
```

- `**`:次方
```python
a = 5 ** 3 #5 的 3 次方
#125
```

##### 註:在python，數學運算也適用先乘除後加減和括號內先算，但`()`並不屬於運算子類別，而是語法結構(syntax structure)

## 比較運算子

比較運算子用於比較兩個值，結果為布林值（`True`or`False`）

- `==`:等於
```python
a = 5
b = 5
a == b
#True
a = 5
b = 3
a == b
#Flse
```

- `!=`:不等於
```python
a = 5
b = 3
a != b
#True
a = 5
b = 5
a != b
#Flse
```

- `>`:大於
```python
a = 6
b = 5
a > b
#True
a = 2
b = 3
a > b
#Flse
a = 3
b = 3
a > b
#Flse
```
- `<`:小於
```python
a = 3
b = 5
a < b
#True
a = 5
b = 3
a < b
#Flse
a = 3
b = 3
a < b
#Flse
```
- `>=`:大於等於
```python
a = 6
b = 5
a >= b
#True
a = 2
b = 3
a >= b
#Flse
a = 3
b = 3
a >= b
#True
```

- `<=`:小於等於
```python
a = 3
b = 5
a <= b
#True
a = 5
b = 3
a <= b
#Flse
a = 3
b = 3
a <= b
#True
```

## 邏輯運算子

邏輯運算子用於邏輯運算，主要用於處理布林值

- `and`:邏輯且
兩個條件都為`True`才回傳`True`
- `or`:邏輯或
有一個條件為`True`就回傳`True`
- `not`:邏輯非
反轉布林值，例如`not True`結果為`False`

## 位元運算子

位元運算子用於位元級操作，主要用來對整數的二進位表示進行運算

- `&`:位元的`and`
對應位元皆為1時，結果為1，否則為0
```python
a = 5  #二進位:0101
b = 3  #二進位:0011

result = a & b  #結果:0001(1)
print(result)  #輸出:1
```

- `|`:位元的`or`
只要有對應位元為1時，結果就為1，否則為0
```python
a = 5  #二進位:0101
b = 3  #二進位:0011

result = a | b  #結果:0111(7)
print(result)  #輸出:7
```

- `^`:位元獨有的`xor`兩值不同時為`true`相同時為`False`
對應位元不同時為1時，相同時為0
```python
a = 5  #二進位:0101
b = 3  #二進位:0011

result = a ^ b  #結果:0110(6)
print(result)  #輸出:6
```

##### 註:Python沒有內建的XOR運算子但可以透過`^`運算子來實現XOR運算

- `~`:位元`not`
將所有位元取反，即1變0，0變1，正變負
```python
a = 5  #二進位:0000 0101

result = ~a  #結果:1111 0110 (-6)
print(result)  #輸出:-6

```
這裡大家可能會想問`0101`反相不是應該變成`-1010`嗎?

其實Python使用補數表示法來處理有符號整數，這是二進位數字表示負數的一種方式。在32位元或64位元的計算機中，正數的位元反相會產生負數。

在 Python 中，負數是使用二進位補數來表示的。在補數系統中，負數`-x`的表示為`~(x-1)`所以`~5`實際上等於`-(5+1)`
```
~(x-1)=~5
x=6
∵~(6-1)
∴-6
```
所以，5 的反相表示是 -6，因為 Python中整數的位元反相操作會影響到其補數的負數表示。這就是為什麼輸出會是 -6 而不是 -10，具體的細節我們就不做說明了

- `<<`:左移
將位元往左移動指定的位數，右側用 0 填充
```
a = 5  #二進位:0101

result = a << 1  #結果:1010 (10)
print(result)  #輸出:10
```

- `>>`:右移
將位元往右移動指定的位數，左側視情況填充 0 或 1（視正負數而定）
```
a = 5  #二進位:0101

result = a >> 1  #結果:0010 (2)
print(result)  #輸出:2

```
在填充時通常都會遵守以下兩點
- 正數右移：左側用 0 填充。
- 負數右移：左側用 1 填充

##### 補充:這是基於算數右移規定的，算術右移（Arithmetic Right Shift）是一種位元操作，用於保留數值的符號位（正負號）不變。這種操作在對二進位數字進行右移時，根據數值是正數還是負數，來決定填充的位元，也就是說當右移負數時，左側用 1 填充，以保留符號位（正負號），所以右移無法像左移那樣直接加 0 


## 賦值(指定)運算子
這類運算子用於將值賦予變數

- `=`:基本賦值
```python
x = 5 #將 5 賦予變數 x
```

- `+=`:加後賦值
```python
x += 1 #等於 x = x + 1
```

- `-=`:減後賦值
```python
x -= 1 #等於 x = x - 1
```

- `*=`:乘後賦值
```python
x *= 2 #等於 x = x * 2
```

- `/=`:除後賦值
```python
x /= 2 #等於 x = x / 2
```

- `%=`:取餘後賦值
```python
x %= 2 #等於 x = x % 2
```

- `//=`:取商後賦值
```python
x //= 2 #等於 x = x // 2
```

- `**=`:次方後賦值
```python
x **= 2 #等於 x = x ** 2
```

- `&=`:`&`後賦值
```python
a = 5    #0101
a &= 3   #0011
print(a) #結果是 1，因為 0101 & 0011 = 0001
```

- `|=`:`|`後賦值
```python
a = 5    #0101
a |= 3   #0011
print(a) #結果是 7，因為 0101 | 0011 = 0111
```

- `^=`:`^`後賦值
```python
a = 5    #0101
a ^= 3   #0011
print(a) #結果是 6，因為 0101 ^ 0011 = 0110
```

- `<<=`:`<<`後賦值
```python
a = 5    #0101
a <<= 1  
print(a) #結果是 10，因為 0101 << 1 = 1010
```

- `>>=`:`>>`後賦值
```python
a = 5    #0101
a >>= 1  
print(a) #結果是 2，因為 0101 >> 1 = 0010
```

## 成員運算子
成員運算子用來檢查某個值是否存在於指定的資料結構中，結果為布林值，且只能用於字串

- `in`:是否存在於
- `not in`:是否不存在於
```python
# 檢查元素是否在列表中
fruits = ['apple', 'banana', 'cherry']
print('apple' in fruits)  #True
print('orange' in fruits)  #False
print('apple' not in fruits)  #False
print('orange' not in fruits)  #True

# 檢查字元是否在字串中
text = "hello world"
print('h' in text)  #True
print('z' in text)  #False
print('h' not in text)  #False
print('z' not in text)  #True
```

## 身分運算子

身份運算子用來比較兩個物件是否是相同的物件。這裡的「相同」並不是指值是否相同，而是指兩者是否引用了相同的記憶體位置。

- `is`:如果兩個變數引用的是同一個物件，則回傳`True`
- `is not`:如果兩個變數引用的不是同一個物件，則回傳`True`

```python
a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is b)  #True，因為 b 是 a 的參考，它們引用的是同一個物件
print(a is c)  #False，儘管 a 和 c 的內容一樣，但它們是不同的物件
print(a == c)  #True，這裡比較的是值，a 和 c 的內容相同
print(a is not b)  #False
print(a is not c)  #True
```
##### 有些人會把身份運算子和相等運算子搞混，因為他們的功能都是比較但兩者其實是有差的
- `is`用來判斷兩個變數是否是**同一個物件**（即記憶體位置是否相同）
- `==`用來判斷兩個變數的**值**是否相等

## 總結
以上就是在python中可能會用到的運算子，為了方便記憶，我將他整理成表格，但在這裡的變數中文名稱可能會和上面的有所不同，這不影響其實際功能
![Python運算子表](https://hackmd.io/_uploads/HyszAdnJ1l.png)

## [下一篇](https://hackmd.io/@Huanyu763/Python字串的基本操作與進階應用)
## [回到主頁](https://hackmd.io/@Huanyu763/home)

