零基础学Python——第二章基础语法（三）运算符与表达式

程工人士

已于 2025-03-11 22:10:19 修改

阅读量511

点赞数 11

分类专栏： # Python入门文章标签： python

于 2025-03-04 23:57:52 首次发布

本文链接：https://blog.csdn.net/bingrrx/article/details/146030379

版权

Python入门专栏收录该内容

8 篇文章

订阅专栏

文章目录

- 第三节运算符与表达式

第三节运算符与表达式

新建一个Python代码文件pybasic_1_3_op.py，用于演示运算符与表达式相关的示例。

运算符

运算符是一种告知解释器执行特定数学或逻辑操作的符号。

算术运算符

算术运算符用于执行数值计算（如整数、浮点数或复数），其结果为数值类型，与数学上的定义基本一致。算术运算包括加法（+）、减法（-）、乘法（*）、除法（/）、整数除法（//）、取模（%）和幂运算（**）。

print("算术运算符...")
a = 7
b = 3
print(f"a = {a}, b = {b}, a + b = {a + b}")     # 加法 7 + 3 = 10
print(f"a = {a}, b = {b}, a - b = {a - b}")     # 减法 7 - 3 = 4
print(f"a = {a}, b = {b}, a * b = {a * b}")     # 乘法 7 * 3 = 21
# 注意：整数除法会返回浮点数，
# 除法 7 / 3 = 2.3333333333333335
print(f"a = {a}, b = {b}, a / b = {a / b}")
print(f"a = {a}, b = {b}, a // b = {a // b}")   # 整数除法 7 // 3 = 2
print(f"a = {a}, b = {b}, a % b = {a % b}")     # 取模（余数） 7 % 3 = 1
print(f"a = {a}, b = {b}, a ** b = {a ** b}")   # 幂运算 7 ** 3 = 343

注意：
除法运算符/：在Python 3.x中，整数除法会返回浮点数。
整除运算符//：执行除法运算并返回商的整数部分（向下取整）。

赋值运算符

赋值运算符用于给变量赋值，也可进行复合赋值操作，结果为数值类型。

= 赋值：将右侧的值赋给左侧的变量。例如a = 5，将5赋值给变量a。
+= 加法赋值：a += b (等价于a = a + b)
-= 减法赋值：a -= b (等价于a = a - b)
*= 乘法赋值：a *= b (等价于a = a * b)
/= 除法赋值：a /= b (等价于a = a / b)
%= 取模赋值：a %= b (等价于a = a % b)
**= 幂赋值：a **= b (等价于a = a ** b)
//= 整数除法赋值：a //= b (等价于a = a // b)

比较运算符

比较运算符用于比较两个值，并返回一个布尔值（True或False）。

print("比较运算符...")
a = 7
b = 3
print(f"a = {a}, b = {b}, a == b = {a == b}")   # 等于 7 == 3 = False
print(f"a = {a}, b = {b}, a != b = {a != b}")   # 不等于 7 != 3 = True
print(f"a = {a}, b = {b}, a > b = {a > b}")     # 大于 7 > 3 = True
print(f"a = {a}, b = {b}, a < b = {a < b}")     # 小于 7 < 3 = False
print(f"a = {a}, b = {b}, a >= b = {a >= b}")   # 大于等于 7 >= 3 = True
print(f"a = {a}, b = {b}, a <= b = {a <= b}")   # 小于等于 7 <= 3 = False

注意：判断两个变量是否相等用==（两个等号），而=（一个等号）是变量的赋值运算。

逻辑运算符

逻辑运算符用于组合多个布尔表达式，并返回一个布尔值。

逻辑与运算符and：只有当两个操作数都为True时，结果才为True。例如True and True的结果是True，True and False的结果是False。
逻辑或运算符or：只要两个操作数中有一个为True，结果就为True。例如True or False的结果是True，False or False的结果是False。
逻辑非运算符not：对单个操作数取反。例如not True的结果是False，not False的结果是True。

print("逻辑运算符...")
print("  逻辑与运算符...")
print("False and False =", False and False)    # 输出 False
print("False and True =", False and True)      # 输出 False
print("True and False =", True and False)      # 输出 False
print("True and True =", True and True)        # 输出 True

print("  逻辑或运算符...")
print("False or False =", False or False)      # 输出 False
print("False or True =", False or True)        # 输出 True
print("True or False =", True or False)        # 输出 True
print("True or True =", True or True)          # 输出 True

print("  逻辑非运算符...")
print("not False =", not False)                # 输出 True
print("not True =", not True)                  # 输出 False

比较运算符和逻辑运算符一般一起使用进行复杂条件判断。

成员运算符

成员运算符用于检查一个值是否是另一个序列（如列表、元组、字符串等）的成员。

in：如果指定的值在序列中，则返回True，否则返回False。例如3 in [1, 2, 3]的结果是True。
not in：如果指定的值不在序列中，则返回True，否则返回False。例如4 not in [1, 2, 3]的结果是True。

# 成员运算符
str = "Hello World!"      # 字符串变量
print("'e' in str:", 'e' in str)    # 输出 True
print("'e' not in str:", 'e' not in str)  # 输出 False

身份运算符

身份运算符用于比较两个对象的内存地址，即判断它们是否是同一个对象。

is：如果两个对象的内存地址相同，则返回True，否则返回False。例如a = [1, 2, 3]; b = a; a is b的结果是True。
is not：如果两个对象的内存地址不同，则返回True，否则返回False。例如a = [1, 2, 3]; b = [1, 2, 3]; a is not b的结果是True（因为a和b虽然值相同，但它们是不同的列表对象）。
身份运算符和None结合使用用来检查一个变量的值是否为None。

# 身份运算符
is_true = True      # 布尔变量, 真值
print("身份运算符...")
print("is 运算符：is_true is True", is_true is True)  # 输出 True
print("is 运算符：is_true is not True", is_true is not True)  # 输出 False

# 身份运算符与None结合
is_none = None      # 空变量
print("is 运算符：is_none is None", is_none is None)  # 输出 True
print("is 运算符：is_none is not None", is_none is not None)  # 输出 False

表达式

表达式是由操作数（如变量、常量）和运算符组成的代码片段，用于计算一个值。Python中有多种类型的表达式：

print("   表达式...")
print("3 + 2 * 4 =", 3 + 2 * 4)     # 算术表达式，输出 11
print("(3 + 2) * 4 =", (3 + 2) * 4)  # 算术表达式，输出 20
print("3 > 2 = ", 3 > 2)           # 比较表达式，输出 True
# 比较表达式，输出 True，先计算3 + 2，再比较结果是否大于4
print("3 + 2 > 4 =", 3 + 2 > 4)     
print("(5 > 3) and (2 < 4) =", (5 > 3) and (2 < 4))  # 逻辑表达式，输出 True
print("'a' in 'abc' =", 'a' in 'abc')  # 成员运算符，输出 True
print("3 in [1, 2, 3] =", 3 in [1, 2, 3])  # 成员运算符，输出 True

1、表达式的优先级

运算符具有不同的优先级，决定了表达式中运算的执行顺序。具体的优先级顺序从高到低大致为：

括号（(...)）（最高优先级，表达式结构而非运算符）

与括号同一级别的还有：属性访问（.）、函数调用（func(...)）和索引 / 切片（lst[...]/lst[;...;]）

这些在后面的章节会陆续出现，现在先不用关心。

幂运算（**）

注意：幂运算优先级高于正负号，如a = -4**2，结果是-16，而a = (-4)**2，结果是16。

正负号（+x、-x）

与正负号同一级别的，还有一个位运算符号：位取反（~x），这几个符号都作用于一个变量上，统称为一元操作符。

位运算需要理解整数的二进制，学习难度较大，并且使用的场合也比较复杂，本教程后面的示例也用不到，初学者先不用学习。

算术运算符（*、/、//、%）
加法和减法（+、-）

例如，乘法和除法的优先级高于加法和减法。在表达式3 + 5 * 2中，先计算5 * 2，再计算3 + 10。

另外，在加减法下面，还有两级优先级：全都是位运算符号。

位运算需要理解整数的二进制，学习难度较大，并且使用的场合也比较复杂，本教程后面的示例也用不到，初学者先不用学习。

移位运算符（<<, >>）

按位与（&）、按位异或（^）、按位或（|）

比较（关系）运算符（==、!=、>、<、>=、<=）
成员运算符和身份运算符（in、not in、is、is not）
逻辑非运算符（not）
逻辑与运算符（and）
逻辑或运算符（or）
赋值运算符（=、+=、\*=等）。

如果记不住运算符的优先级顺序，以下有一些方法可以帮助读者：

利用括号明确指定运算顺序，同时也能增加表达式的可读性。
- 明确运算顺序：括号内的运算会优先进行。无论括号内是何种运算，都会先于括号外的运算执行。

例如：在表达式2 * (3 + 4)中，会先计算括号内的3 + 4 = 7，再计算2 * 7 = 14。

如果没有括号，按照正常的运算符优先级，乘法会先于加法计算，结果就会不同。

增强可读性：当表达式较为复杂，包含多种运算符和操作数时，合理使用括号可以使表达式的逻辑结构更加清晰，让人一眼就能明白运算的先后顺序。

例如：在通过and和or连接多个条件时，使用括号，可显著增强程序的可读性。

不使用括号前：

condition1 = (a > b) and (c < d) or (e == f) and (a + b > c - d)

使用括号后，增强可读性，但逻辑上与上面等价：

condition2 = ((a > b) and (c < d)) or ((e == f) and (a + b > c - d))

通过口诀来记忆
- 口诀一：“幂指乘除先，加减依次算，关系（比较）成员身份后，逻辑最后判”。这个口诀涵盖了幂运算、算术运算、比较运算符、成员和身份运算符、逻辑运算符的大致顺序。
- 口诀二：“括号优先算，幂次高在前，乘除排中间，加减在后面，关系成员身份随其后，逻辑赋值最后头”。这个口诀把括号运算和赋值运算也加了进去，更为完整。

2、表达式的结合性

当一个表达式中出现多个具有相同优先级的运算符时，结合性决定了运算的执行顺序，例如

乘法和除法具有从左到右的结合性，所以在表达式10 / 2 * 3中，先计算10 / 2得到5，再计算5 * 3得到15。
赋值运算符具有从右到左的结合性，例如a = b = 5会先将5赋给b，然后再将b的值（即5）赋给a。

3、表达式的换行

在 Python 中，表达式通常写在一行内完成。但当表达式过长时，可以通过以下几种方式实现换行：

使用括号 () 换行：这是最推荐的方式，适用于大多数场景。Python 允许在括号内自然换行，无需额外的符号。
- 自然换行，无需额外符号。
- 可读性强，适合复杂表达式。
- Python 官方的代码风格指南（PEP 8 – Style Guide for Python Code）推荐的方式。
```
>>> result = (10 + 20 + 30 +
              40 + 50 + 60)
>>> result
210
```
注意：
- 在标准 Python 终端中，当代码需要换行时，会显示 ... 提示符。
- 但在 Thonny 的终端中，当代码需要换行时，不显示 ... 提示符。
  - 当读者按下回车键后，如果代码尚未完成（例如括号未闭合），光标会自动缩进到下一行，这表明读者可以继续输入代码。
  - 读者只需继续输入即可。Thonny 会通过缩进或语法高亮提示代码尚未完成。
使用反斜杠 \ 换行：反斜杠可以显式地告诉 Python 表达式在下一行继续。
```
>>> result = 10 + 20 + 30 + \
             40 + 50 + 60
>>> result
210
```
注意事项：
- 反斜杠后不能有空格或其他字符 ：如果反斜杠后面不小心多了一个空格或字符，会导致语法错误。
  - \的后面也不能有 # 开始的注释
  - Thonny 集成的终端会把\后面的空格去掉，所以如果不小心多了一个空格不会导致语法错误。
```
>>> # 下面这句代码的'\' 后面有一个空格
>>> result = 10 + 20 + 30 + \ 
  File "<python-input-6>", line 1
    result = 10 + 20 + 30 + \
                             ^
SyntaxError: unexpected character after line continuation character
```
- 不推荐用于简单表达式中，容易出错且可读性较差。

注意事项：

避免不必要的换行：

如果表达式较短，尽量保持在一行内完成，避免过度换行。

过度换行会降低代码的紧凑性和可读性。

PEP 8 规范：

PEP 8 建议每行代码不超过 79 个字符（文档字符串和注释不超过 72 个字符）。

当表达式超过限制时，优先使用括号 () 换行。

避免滥用反斜杠：

反斜杠容易引发错误（如多余空格导致的语法错误）。

尽量只在无法使用括号的情况下使用反斜杠。

另外还有一些利用Python数据类型和语法结构的特性实现的隐式换行方式，在后面章节将会一一详细说明。

对于某些特殊数据类型（如字符串、列表、字典等），可以直接利用其多行特性。

某些语法结构（如函数调用、条件语句等）允许自然换行，无需额外符号。

通过这部分内容的学习，读者已经了解了Python中的运算符与表达式。从算术、赋值、比较等多种运算符，到由操作数和运算符组成的表达式，再到表达式的优先级和结合性，这些知识构成了Python编程的重要基础。掌握好它们，读者将能够编写更复杂、更高效的代码。随着学习的深入，会发现这些基础知识在解决各种编程问题时发挥着不可或缺的作用，期待读者在后续的学习中进一步巩固和运用这些知识。