一、什么是运算符?
运算符(Operator)是编程语言中用于执行特定操作的符号或关键字。
例如:
a = 10
b = 5
result = a + b
这里:
+是运算符。a和b是操作数(Operand)。a + b是一个表达式。- 运算结果为
15。
运算符的核心作用是定义操作行为,例如:
- 数值计算
- 比较判断
- 逻辑运算
- 位操作
- 赋值
- 成员访问
- 类型判断
1.1 运算符的组成
一个运算符表达式通常由运算符和操作数组成。
例如:
result = a + b * c
其中:
| 元素 | 含义 |
|---|---|
a、b、c |
操作数 |
+、* |
运算符 |
b * c |
子表达式 |
a + b * c |
完整表达式 |
运算符根据操作数数量,可以分为以下几类:
| 类型 | 含义 | 示例 |
|---|---|---|
| 一元运算符 | 操作一个操作数 | -a、!a |
| 二元运算符 | 操作两个操作数 | a + b、a == b |
| 三元运算符 | 根据条件选择表达式 | a ? b : c |
需要注意,运算符的符号和行为由具体编程语言定义。同一个符号在不同语言中,可能具有不同语义。
二、什么是表达式?
表达式(Expression)是由字面量、变量、运算符、函数调用等元素组合而成,并能够按照语言规则进行求值的代码结构。
例如:
10 + 20
这是一个表达式,求值结果为 30。
再例如:
age >= 18
这是一个比较表达式,求值结果为布尔值。
表达式可以非常简单,也可以由多个子表达式嵌套组成。
total = price * quantity + shipping_fee
其中:
price * quantity是子表达式。price * quantity + shipping_fee是完整表达式。total = ...是赋值语句。
2.1 表达式与语句的区别
表达式和语句(Statement)是两个不同的语法概念。
表达式通常用于计算并产生值,语句则用于组织程序执行行为。
例如 Python:
a + b
这是一个表达式。
result = a + b
这是一个赋值语句,其中包含表达式 a + b。
if a > b:
print(a)
这是一个条件语句,其中 a > b 是条件表达式。
二者的区别:
| 对比维度 | 表达式 | 语句 |
|---|---|---|
| 英文 | Expression | Statement |
| 主要作用 | 计算并产生值 | 表达程序执行结构 |
| 是否可以嵌套 | 通常可以 | 取决于语言语法 |
| 示例 | a + b |
if、while、赋值语句 |
| 是否一定产生值 | 通常有求值结果 | 不一定 |
不同语言对表达式和语句的划分并不完全相同。
例如,Python 的赋值语句本身不是普通表达式,而 JavaScript 的赋值表达式可以产生赋值后的值。
2.2 表达式的组成
表达式通常可以包含:
- 字面量
- 变量
- 运算符
- 函数调用
- 属性访问
- 数组或对象访问
- 其他子表达式
例如:
const result = user.score * 2 + calculateBonus();
可以拆分为:
flowchart TB
A["完整表达式"] --> B["user.score * 2"]
A --> C["calculateBonus()"]
B --> D["属性访问 user.score"]
B --> E["乘法运算"]
A --> F["加法运算"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
三、算术运算符(Arithmetic Operators)
算术运算符用于执行数值计算,是最常见的运算符类型。
3.1 基本算术运算符
| 运算符 | 名称 | 示例 | 结果 |
|---|---|---|---|
+ |
加法 | 10 + 3 |
13 |
- |
减法 | 10 - 3 |
7 |
* |
乘法 | 10 * 3 |
30 |
/ |
除法 | 10 / 3 |
依语言而定 |
% |
取余 | 10 % 3 |
1 |
** |
幂运算 | 2 ** 3 |
8 |
需要注意,不同语言对除法和取余的规则存在差异。
例如 Python:
print(10 / 3) # 3.3333333333333335
print(10 // 3) # 3
print(10 % 3) # 1
Python 使用 / 执行真除法,使用 // 执行向下取整的除法。
Java:
System.out.println(10 / 3); // 3
System.out.println(10.0 / 3); // 3.3333333333333335
Java 中两个整数相除,结果仍然是整数,小数部分被截断。
3.2 整数除法与浮点数除法
整数除法和浮点数除法是一个容易出错的地方。
例如:
int a = 10;
int b = 3;
double result = a / b;
System.out.println(result);
结果是:
3.0
原因是:
a和b都是整数。a / b首先执行整数除法。- 整数除法得到
3。 - 再将结果转换为
double,得到3.0。
如果希望得到浮点数结果,需要在运算之前转换操作数:
double result = (double) a / b;
结果为:
3.3333333333333335
类型转换发生的时间,会直接影响表达式的计算结果。
3.3 取余运算
取余运算通常用于获得除法运算后的余数。
例如:
print(10 % 3) # 1
取余运算常见用途:
- 判断奇偶数
- 循环索引
- 时间换算
- 周期性计算
- 哈希算法
例如判断奇偶数:
number = 10
if number % 2 == 0:
print("偶数")
else:
print("奇数")
需要注意,负数参与取余时,不同语言可能采用不同规则。
Python:
print(-7 % 3) # 2
Java:
System.out.println(-7 % 3); // -1
Python 的取余结果与除数的符号相关;Java 的余数符号与被除数相关。
因此,跨语言处理负数取余时,不能假设结果完全一致。
四、关系运算符(Relational Operators)
关系运算符用于比较两个操作数之间的关系。
通常返回布尔结果。
| 运算符 | 含义 | 示例 |
|---|---|---|
== |
等于 | a == b |
!= |
不等于 | a != b |
> |
大于 | a > b |
< |
小于 | a < b |
>= |
大于等于 | a >= b |
<= |
小于等于 | a <= b |
例如:
age = 20
print(age >= 18) # True
print(age == 20) # True
print(age < 18) # False
4.1 等值比较与引用比较
在一些语言中,需要区分比较两个对象的值是否相等,以及比较两个引用是否指向同一个对象。
Java:
String a = new String("hello");
String b = new String("hello");
System.out.println(a == b); // false
System.out.println(a.equals(b)); // true
这里:
==对引用类型比较引用身份,即是否指向同一个对象。equals()默认继承自Object,但String重写了它,用于比较字符串内容。
Python:
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # True
print(a is b) # False
这里:
==比较对象的值是否相等。is比较两个名称是否指向同一个对象。
这说明相等性比较与对象身份比较是两个不同概念。
4.2 浮点数比较
浮点数由于精度限制,直接使用相等运算符比较计算结果可能产生问题。
例如:
a = 0.1 + 0.2
b = 0.3
print(a == b) # False
实际开发中,通常需要根据业务精度要求设置容差:
a = 0.1 + 0.2
b = 0.3
epsilon = 1e-9
print(abs(a - b) < epsilon)
对于不同数量级的数据,固定绝对误差可能不够,还需要考虑相对误差。
五、逻辑运算符(Logical Operators)
逻辑运算符用于组合或反转布尔条件。
常见逻辑运算包括:
| 运算 | Python | Java / C | JavaScript |
|---|---|---|---|
| 逻辑与 | and |
&& |
&& |
| 逻辑或 | or |
|| |
|| |
| 逻辑非 | not |
! |
! |
5.1 逻辑与(AND)
只有所有条件都成立,结果才为真。
| A | B | A AND B |
|---|---|---|
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
例如:
age = 25
is_member = True
result = age >= 18 and is_member
只有年龄满足要求并且是会员,结果才为真。
5.2 逻辑或(OR)
只要有一个条件成立,结果就为真。
| A | B | A OR B |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
例如:
is_admin = False
is_owner = True
result = is_admin or is_owner
管理员或者资源所有者都可以满足访问条件。
5.3 逻辑非(NOT)
逻辑非用于反转布尔值。
| A | NOT A |
|---|---|
| True | False |
| False | True |
例如:
is_login = False
if not is_login:
print("请先登录")
5.4 短路求值(Short-Circuit Evaluation)
短路求值是逻辑运算中非常重要的执行机制。
当逻辑表达式的结果已经可以确定时,运行时可能不再计算剩余操作数。
对于常见的短路逻辑运算:
A && B:当 A 为假时,不再计算 B。A || B:当 A 为真时,不再计算 B。
例如 JavaScript:
let user = null;
if (user && user.name) {
console.log(user.name);
}
当 user 为 null 时,user && user.name 的结果已经可以确定,不会继续访问 user.name。
短路求值的流程:
flowchart TD
A["开始计算逻辑表达式"] --> B["计算左操作数"]
B --> C{"是否可以确定结果"}
C -->|"可以"| D["返回当前结果"]
C -->|"不可以"| E["计算右操作数"]
E --> F["得到最终结果"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
短路求值不仅能够提高效率,还经常用于保护可能产生异常的表达式。
例如:
if user is not None and user.name == "Alice":
print("匹配成功")
先判断 user 是否为空,再访问其属性。
需要注意,并非所有逻辑运算符都采用短路求值。部分语言还提供不短路的逻辑运算或位运算形式。
六、赋值运算符(Assignment Operators)
赋值运算符用于将值赋给变量,或者更新变量当前关联的数据。
6.1 基本赋值
age = 25
name = "Alice"
= 表示赋值,而不是数学意义上的相等判断。
例如:
x = 10
x = x + 5
第二行表示:
- 读取当前
x的值。 - 计算
x + 5。 - 将结果重新赋给
x。
最终 x 的值为 15。
6.2 复合赋值运算符
复合赋值将运算与赋值组合在一起。
| 运算符 | 等价形式 |
|---|---|
+= |
a = a + b |
-= |
a = a - b |
*= |
a = a * b |
/= |
a = a / b |
%= |
a = a % b |
&= |
a = a & b |
|= |
a = a \| b |
^= |
a = a ^ b |
<<= |
a = a << b |
>>= |
a = a >> b |
例如:
count = 10
count += 5
print(count) # 15
需要注意,复合赋值不一定在所有语言中都与展开后的表达式完全等价。
例如 Python:
a = [1, 2]
a += [3]
这通常会原地扩展列表。
而:
a = [1, 2]
a = a + [3]
会创建新的列表对象并重新绑定 a。
对于具有重载运算符或自定义赋值行为的类型,这种区别可能更加明显。
6.3 自增与自减运算符
C、C++、Java、JavaScript 等语言提供:
++:自增。--:自减。
例如:
int count = 10;
count++;
count--;
自增和自减还存在前置与后置形式。
int a = 10;
int x = ++a;
int y = a++;
区别:
| 表达式 | 行为 |
|---|---|
++a |
先增加,再使用结果 |
a++ |
先使用原值,再增加 |
执行过程:
flowchart TD
A["变量 a = 10"] --> B["执行 ++a"]
B --> C["a 变为 11"]
C --> D["表达式结果为 11"]
D --> E["执行 a++"]
E --> F["表达式结果为 11"]
F --> G["a 变为 12"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
Python 不支持 ++ 和 -- 作为自增、自减运算符。
七、位运算符(Bitwise Operators)
位运算符直接对整数的二进制位进行操作。
位运算在底层开发、网络协议、权限控制、图形计算和性能优化中非常常见。
7.1 按位与(AND)
运算符:&
只有对应的两个二进制位都为 1,结果才为 1。
0101
& 0011
------
0001
例如:
print(5 & 3) # 1
7.2 按位或(OR)
运算符:|
只要对应位置有一个为 1,结果就是 1。
0101
| 0011
------
0111
print(5 | 3) # 7
7.3 按位异或(XOR)
运算符:^
两个对应位不同时结果为 1,相同时结果为 0。
0101
^ 0011
------
0110
print(5 ^ 3) # 6
7.4 按位取反(NOT)
运算符:~
对整数的二进制位进行取反。
在 Python 中:
print(~5) # -6
Python 整数使用无限精度的有符号整数语义,因此不能简单地把 ~5 理解为固定 8 位或 32 位补码取反。
对于 Python 整数:
7.5 左移与右移
| 运算符 | 含义 |
|---|---|
<< |
左移 |
>> |
右移 |
例如:
print(5 << 1) # 10
print(8 >> 1) # 4
二进制示意:
5 = 0101
5 << 1 = 1010 = 10
8 = 1000
8 >> 1 = 0100 = 4
对于非负整数,左移一位通常相当于乘以 2,右移一位通常相当于除以 2 后向下取整。
但这不是所有情况下都能直接套用的数学规则:
- 左移可能导致整数溢出。
- 有符号右移可能涉及符号位扩展。
- 逻辑右移与算术右移的行为不同。
- 移位位数和操作数类型受到语言规范约束。
7.6 位运算的实际用途
权限控制
可以使用不同二进制位表示不同权限。
READ = 1 # 0001
WRITE = 2 # 0010
EXECUTE = 4 # 0100
permissions = READ | WRITE
print(permissions & READ) # 1
判断奇偶数
number = 10
if number & 1:
print("奇数")
else:
print("偶数")
判断某一位是否被设置
flags = 0b1010
mask = 0b0010
if flags & mask:
print("目标标志位已设置")
八、条件运算符(三元运算符)
条件运算符用于根据条件选择不同的表达式结果。
常见形式:
条件 ? 表达式1 : 表达式2
例如 JavaScript:
const age = 20;
const result = age >= 18 ? "成年人" : "未成年人";
当条件为真时,返回第一个表达式的结果;否则返回第二个表达式的结果。
部分语言采用不同语法。
Python:
age = 20
result = "成年人" if age >= 18 else "未成年人"
条件表达式可以简化简单的分支逻辑。
但如果条件嵌套过多,会降低可读性:
const result = score >= 90
? "优秀"
: score >= 60
? "及格"
: "不及格";
复杂逻辑通常更适合使用 if、else 或其他分支结构。
九、其他常见运算符
除了上述运算符,不同编程语言还提供了许多具有特殊用途的运算符。
9.1 成员访问运算符
用于访问对象属性或结构体成员。
例如:
user.name
其中 . 用于访问 user 对象的 name 属性。
C 语言:
user.age
如果通过结构体指针访问成员:
user_ptr->age
9.2 数组与索引访问运算符
通过索引访问数组或集合中的元素。
numbers = [10, 20, 30]
print(numbers[0]) # 10
这里 [] 用于索引访问。
9.3 函数调用运算符
使用圆括号调用函数。
result = calculate(10, 20)
() 在这里表示函数调用。
9.4 类型判断运算符
用于判断对象或表达式的类型。
JavaScript:
console.log(typeof "hello"); // string
console.log(typeof 123); // number
Java:
if (obj instanceof String) {
System.out.println("字符串");
}
Python:
isinstance(123, int)
9.5 空值合并运算符
JavaScript 提供 ??,用于在左侧操作数为 null 或 undefined 时使用右侧默认值。
const username = inputName ?? "Guest";
与逻辑或 || 不同,?? 不会把 0、false 和空字符串当作需要替换的空值。