一、算術運算符

運算符	Rust 🦀	Python 🐍	示例 (Rust)	示例 (Python)	說明
+	加法	加法	let sum = 5 + 3;	sum = 5 + 3
-	減法	減法	let diff = 5 - 3;	diff = 5 - 3
*	乘法	乘法	let product = 5 * 3;	product = 5 * 3
/	除法	除法	let quotient = 5 / 3; → 1	quotient = 5 / 3 → 1.666...
%	取余	取模	let remainder = 5 % 3; → 2	remainder = 5 % 3 → 2
**	無	冪運算	無	result = 2 ** 3 → 8
//	無	整除	無	result = 5 // 2 → 2

關鍵差異：

• 除法：Rust 整數除法會截斷小數，Python 會返回浮點數
• 冪運算：Rust 使用 pow() 方法，Python 使用 **
• 整除：Python 有專門的 // 運算符

// Rust 算術運算
let a = 10;
let b = 3;println!("加法: {}", a + b);      // 13
println!("減法: {}", a - b);      // 7
println!("乘法: {}", a * b);      // 30
println!("除法: {}", a / b);      // 3 (整數除法)
println!("取余: {}", a % b);      // 1
println!("冪運算: {}", a.pow(b)); // 1000

# Python 算術運算
a = 10
b = 3print(f"加法: {a + b}")      # 13
print(f"減法: {a - b}")      # 7
print(f"乘法: {a * b}")      # 30
print(f"除法: {a / b}")      # 3.333... (浮點除法)
print(f"取余: {a % b}")      # 1
print(f"冪運算: {a ** b}")   # 1000
print(f"整除: {a // b}")     # 3

二、比較運算符

運算符	Rust 🦀	Python 🐍	說明
==	相等	相等	值相等
!=	不等	不等	值不相等
>	大于	大于
<	小于	小于
>=	大于等于	大于等于
<=	小于等于	小于等于

關鍵差異：

• 返回值：Rust 返回 bool，Python 返回 bool
• 類型嚴格性：Rust 要求比較的操作數類型必須相同

// Rust 比較運算
let x = 5;
let y = 10;println!("相等: {}", x == y);    // false
println!("不等: {}", x != y);    // true
println!("大于: {}", x > y);     // false
println!("小于: {}", x < y);     // true// 類型必須匹配
// let result = 5 == 5.0; // 錯誤！不能比較 i32 和 f64

# Python 比較運算
x = 5
y = 10print(f"相等: {x == y}")    # False
print(f"不等: {x != y}")    # True
print(f"大于: {x > y}")     # False
print(f"小于: {x < y}")     # True# 類型可以不同（但通常不建議）
print(f"混合類型: {5 == 5.0}")  # True

三、邏輯運算符

運算符	Rust 🦀	Python 🐍	說明
&&	邏輯與	and	兩者都為真
`		`	邏輯或
!	邏輯非	not	取反

關鍵差異：

• 語法不同：Rust 使用符號，Python 使用關鍵字
• 短路求值：兩者都支持短路求值

// Rust 邏輯運算
let a = true;
let b = false;println!("與: {}", a && b);   // false
println!("或: {}", a || b);   // true
println!("非: {}", !a);       // false// 短路求值
let mut count = 0;
let result = false && {count += 1;true
};
println!("Count: {}", count); // 0 (短路，未執行)

# Python 邏輯運算
a = True
b = Falseprint(f"與: {a and b}")   # False
print(f"或: {a or b}")    # True
print(f"非: {not a}")     # False# 短路求值
count = 0
result = False and (count := count + 1)  # 使用海象運算符
print(f"Count: {count}")  # 0 (短路，未執行)

四、位運算符

運算符	Rust 🦀	Python 🐍	說明
&	按位與	按位與
|	按位或	按位或
^	按位異或	按位異或
!	按位取反	~	取反
<<	左移	左移
>>	右移	右移

關鍵差異：

• 取反運算符：Rust 用 !，Python 用 ~
• 移位行為：Rust 有算術移位和邏輯移位之分

// Rust 位運算
let a: u8 = 0b1010; // 10
let b: u8 = 0b1100; // 12println!("與: {:08b}", a & b);   // 00001000 (8)
println!("或: {:08b}", a | b);   // 00001110 (14)
println!("異或: {:08b}", a ^ b); // 00000110 (6)
println!("取反: {:08b}", !a);    // 11110101 (245)
println!("左移: {:08b}", a << 2); // 00101000 (40)
println!("右移: {:08b}", a >> 1); // 00000101 (5)

# Python 位運算
a = 0b1010  # 10
b = 0b1100  # 12print(f"與: {a & b:08b}")   # 00001000 (8)
print(f"或: {a | b:08b}")   # 00001110 (14)
print(f"異或: {a ^ b:08b}") # 00000110 (6)
print(f"取反: {~a & 0xFF:08b}") # 11110101 (245) - 需要掩碼
print(f"左移: {a << 2:08b}") # 00101000 (40)
print(f"右移: {a >> 1:08b}") # 00000101 (5)

五、賦值運算符

運算符	Rust 🦀	Python 🐍	說明
=	賦值	賦值	基本賦值
+=	加后賦值	加后賦值
-=	減后賦值	減后賦值
*=	乘后賦值	乘后賦值
/=	除后賦值	除后賦值
%=	取余后賦值	取模后賦值
**=	無	冪后賦值
//=	無	整除后賦值

關鍵差異：

• Python 有更多復合賦值運算符
• Rust 需要變量聲明為 mut 才能修改

// Rust 賦值運算
let mut x = 10;
x += 5;    // x = 15
x -= 3;    // x = 12
x *= 2;    // x = 24
x /= 4;    // x = 6
x %= 4;    // x = 2// 需要 mut 關鍵字
// let y = 10;
// y += 5; // 錯誤！y 不可變

# Python 賦值運算
x = 10
x += 5    # x = 15
x -= 3    # x = 12
x *= 2    # x = 24
x /= 4    # x = 6.0
x %= 4    # x = 2.0
x **= 3   # x = 8.0
x //= 2   # x = 4.0# 不需要特殊聲明
y = 10
y += 5    # 可以直接修改

六、類型相關運算符

Rust 特有運算符

// 類型轉換 as
let x: i32 = 10;
let y: f64 = x as f64; // 顯式類型轉換// 引用和解引用
let value = 42;
let ref_value = &value;    // 創建引用
let deref_value = *ref_value; // 解引用// 范圍運算符 ..
for i in 0..5 {           // 0, 1, 2, 3, 4println!("{}", i);
}for i in 0..=5 {          // 0, 1, 2, 3, 4, 5println!("{}", i);
}

Python 特有運算符

# 身份運算符 is, is not
a = [1, 2, 3]
b = [1, 2, 3]
c = aprint(a is b)     # False - 不同對象
print(a is c)     # True - 同一對象
print(a == b)     # True - 值相等# 成員運算符 in, not in
numbers = [1, 2, 3, 4, 5]
print(3 in numbers)       # True
print(6 not in numbers)   # True# 海象運算符 := (Python 3.8+)
if (n := len(numbers)) > 3:print(f"列表有 {n} 個元素")

八、運算符重載

Rust 運算符重載

use std::ops::Add;#[derive(Debug)]
struct Point {x: i32,y: i32,
}impl Add for Point {type Output = Point;fn add(self, other: Point) -> Point {Point {x: self.x + other.x,y: self.y + other.y,}}
}let p1 = Point { x: 1, y: 2 };
let p2 = Point { x: 3, y: 4 };
let p3 = p1 + p2;
println!("{:?}", p3); // Point { x: 4, y: 6 }

Python 運算符重載

class Point:def __init__(self, x, y):self.x = xself.y = ydef __add__(self, other):return Point(self.x + other.x, self.y + other.y)def __repr__(self):return f"Point({self.x}, {self.y})"p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2
print(p3)  # Point(4, 6)

九、優先級對比

Rust 運算符優先級（從高到低）

1. () [] . ? !
2. - ! * & &mut (一元)
3. as
4. * / %
5. + -
6. << >>
7. &
8. ^
9. |
10. == != < > <= >=
11. &&
12. ||
13. .. ..=
14. = += -= *= /= %= &= |= ^= <<= >>=

Python 運算符優先級（從高到低）

1. () [] . {}
2. ** (指數)
3. +x -x ~x (一元)
4. * / // %
5. + -
6. << >>
7. &
8. ^
9. |
10. == != < > <= >= is is not in not in
11. not
12. and
13. or
14. := (海象運算符)

九、總結對比

特性	Rust 🦀	Python 🐍
類型安全	????? (編譯時檢查)	??? (運行時檢查)
運算符數量	????	?????
語法一致性	?????	????
學習曲線	?? (較陡峭)	????? (平緩)
表達能力	????	?????
性能	?????	???

選擇建議：

• 選擇 Rust：需要高性能、內存安全、系統級編程
• 選擇 Python：需要快速開發、腳本編寫、數據科學

關鍵記憶點：

• Rust 使用符號邏輯運算符 (&&, ||, !)
• Python 使用關鍵字邏輯運算符 (and, or, not)
• Rust 整數除法會截斷，Python 會返回浮點數
• Rust 需要顯式類型轉換，Python 支持隱式轉換
• Python 有更多專用運算符 (**, //, in, is)