【Python 基础教程运算符06】Python3运算符超详细解析：全面入门教程，初学者必读-阿里云开发者社区

1. 引言

1.1 Python3运算符的重要性

Python3运算符（Python3 Operators）在编程中扮演着至关重要的角色。它们是用于执行特定任务的符号，例如进行数学运算、比较值或执行逻辑操作。在Python3中，我们有多种类型的运算符，包括算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符和身份运算符。

对于有C/C++基础的读者来说，Python3的运算符与C/C++的运算符在很多方面都是相似的，但也有一些重要的区别。例如，Python3中的赋值运算符（Assignment Operators）与C/C++中的赋值运算符在功能上是相似的，但Python3提供了更多的赋值运算符，如 //= 和 **=，这些在C/C++中是不存在的。

让我们来看一个简单的例子：

# Python3
a = 10
b = 3
a //= b
print(a)  # 输出：3

在这个例子中，//= 是一个赋值运算符，它将左操作数（a）除以右操作数（b）的结果进行向下取整，然后将结果赋值给左操作数（a）。这是Python3特有的赋值运算符，C/C++中没有对应的运算符。

在Python3编程中，理解和掌握运算符的使用是非常重要的。它们是构建和操作数据的基础工具，无论是进行简单的数学计算，还是构建复杂的数据结构和算法，运算符都是不可或缺的。

在口语交流中，我们通常会说 “Assign the result of integer division of a by b to a”（将a除以b的整数除法结果赋值给a）。在这个句子中，“Assign”（赋值）对应的是赋值运算符，“integer division”（整数除法）对应的是 // 运算符。

在接下来的章节中，我们将深入探讨Python3的各种运算符，包括它们的基本用法、高级应用和在实际编程中的应用案例。我们将从Python3的角度出发，结合C/C++的对比，帮助读者更好地理解和掌握Python3的运算符。

Python3运算符	C/C++运算符	描述
`+`	`+`	加法
`-`	`-`	减法
`*`	`*`	乘法
`/`	`/`	除法
`//`	无	整数除法
`**`	`^`	幂运算
`%`	`%`	取模
`=`	`=`	赋值
`+=`	`+=`	加法赋值
`-=`	`-=`	减法赋值
`*=`	`*=`	乘法赋值
`/=`	`/=`	除法赋值
`//=`	无	整数除法赋值
`**=`	无	幂运算赋值
`%=`	`%=`	取模赋值

1.2 运算符在编程中的角色

运算符在编程中的角色是至关重要的。它们是编程语言的基础组成部分，用于执行各种操作，包括数学运算、比较、逻辑操作等。在Python3（Python3）和C/C++（C/C++）等编程语言中，运算符的使用是无处不在的。

在Python3中，运算符的使用非常广泛。例如，我们可以使用算术运算符进行数学计算，使用比较运算符比较两个值的大小，使用逻辑运算符进行逻辑操作，等等。这些运算符的使用使得我们可以更方便地编写代码，实现各种复杂的功能。

对于有C/C++基础的读者来说，你可能已经对运算符有了一定的了解。然而，Python3的运算符与C/C++的运算符在一些方面存在一些差异。例如，Python3支持一些C/C++不支持的运算符，如//（整数除法）和**（幂运算）。这些运算符的存在使得Python3在处理某些问题时更加方便和高效。

让我们来看一个简单的例子：

# Python3
a = 10
b = 3
c = a ** b
print(c)  # 输出：1000

在这个例子中，**是一个幂运算符，它将左操作数（a）的值提升到右操作数（b）的幂。这是Python3特有的运算符，C/C++中没有对应的运算符。

在口语交流中，我们通常会说 “Raise a to the power of b”（将a的值提升到b的幂）。在这个句子中，“Raise … to the power of …”（将…的值提升到…的幂）对应的是**运算符。

2. Python3基础运算符

2.1 算术运算符

Python3的算术运算符（Arithmetic Operators）包括加（+）、减（-）、乘（*）、除（/）、取模（%）、幂（**）和取整除（//）。这些运算符在Python3中的使用和在C/C++中的使用大致相同，但也有一些细微的差别。

2.1.1 加法运算符（+）

在Python3中，加法运算符（+）用于两个对象的相加。这可以是两个数字，或者两个字符串，甚至是两个列表。这是Python3和C/C++的一个主要区别，因为在C/C++中，加法运算符只能用于数字。

例如：

# 数字相加
print(3 + 2)  # 输出：5
# 字符串相加
print('Hello, ' + 'World!')  # 输出：Hello, World!
# 列表相加
print([1, 2, 3] + [4, 5, 6])  # 输出：[1, 2, 3, 4, 5, 6]

在英语口语中，我们通常会说 “Add 3 and 2”（将3和2相加），或者 “Concatenate 'Hello, ’ and ‘World!’”（将’Hello, '和’World!'连接起来）。

2.1.2 减法运算符（-）

在Python3中，减法运算符（-）用于返回两个数字的差。这与C/C++中的用法相同。

例如：

# 数字相减
print(3 - 2)  # 输出：1

在英语口语中，我们通常会说 “Subtract 2 from 3”（从3中减去2）。

2.1.3 乘法运算符（*）

在Python3中，乘法运算符（*）用于返回两个数字的乘积，或者返回一个被重复的字符串。这是Python3和C/C++的一个主要区别，因为在C/C++中，乘法运算符只能用于数字。

例如：

# 数字相乘
print(3 * 2)  # 输出：6
# 字符串重复
print('Hello, ' * 3)  # 输出：Hello, Hello, Hello,

在英语口语中，我们通常会说 “Multiply 3 by 2”（将3乘以2），或者 “Repeat 'Hello, ’ three times”（重复三次’Hello, '）。

2.1.4 除法运算符（/）

在Python3中，除法运算符（/）用于返回两个数字的商，结果是浮点数。这与C/C++中的用法不同，因为在C/C++中，如果两个操作数都是整数，那么结果也是整数。

例如：

# 数字相除
print(3 / 2)  # 输出：1.5

在英语口语中，我们通常会说 “Divide 3 by 2”（将3除以2）。

2.1.5 取模运算符（%）

在Python3中，取模运算符（%）用于返回除法的余数。这与C/C++中的用法相同。

例如：

# 取模
print(10 % 3)  # 输出：1

在英语口语中，我们通常会说 “The remainder of 10 divided by 3”（10除以3的余数）。

2.1.6 幂运算符（**）

在Python3中，幂运算符（**）用于返回x的y次幂。这是Python3和C/C++的一个主要区别，因为在C/C++中，没有专门的幂运算符，通常使用函数pow()来计算幂。

例如：

# 幂运算
print(2 ** 3)  # 输出：8

在英语口语中，我们通常会说 “2 to the power of 3”（2的3次方）。

2.1.7 取整除运算符（//）

在Python3中，取整除运算符（//）用于返回商的整数部分。这是Python3和C/C++的一个主要区别，因为在C/C++中，没有专门的取整除运算符。

例如：

# 取整除
print(10 // 3)  # 输出：3

在英语口语中，我们通常会说 “The integer quotient of 10 divided by 3”（10除以3的整数商）。

在Python3中，运算符的使用非常灵活，可以应用于多种数据类型。这使得Python3在处理字符串和列表等数据结构时，比C/C++更加方便和强大。同时，Python3还提供了一些C/C++中没有的运算符，如幂运算符和取整除运算符，这使得Python3在数学计算方面也更加强大。

在《Python3 Cookbook》中，作者David Beazley和Brian K. Jones也强调了Python3运算符的灵活性和强大性，并通过大量的实例展示了如何在实际编程中有效地使用Python3的运算符。

在Python3的源码中，运算符的实现是通过一系列的内置函数来完成的。例如，加法运算符的实现是通过内置函数__add__()来完成的，减法运算符的实现是通过内置函数__sub__()来完成的，等等。这些内置函数都定义在Python3的内核中，我们可以通过阅读Python3的源码来深入理解这些运算符的实现原理。

下表总结了Python3中的算术运算符和C/C++中的对应关系：

Python3运算符	C/C++运算符	描述
+	+	加法
-	-	减法
*	*	乘法
/	/	除法（Python3结果为浮点数，C/C++结果为整数）
%	%	取模
**	pow()	幂（Python3使用运算符，C/C++使用函数）
//	无	取整除（Python3有，C/C++无）

这是一个初步的介绍，后续我们将深入探讨Python3运算符的更多细节和高级应用。

2.2 比较（关系）运算符

Python3的比较运算符（Comparison Operators）用于比较两个对象的值。这些运算符包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。这些运算符在Python3中的使用和在C/C++中的使用大致相同，但也有一些细微的差别。

2.2.1 等于运算符（==）

在Python3中，等于运算符（==）用于检查两个对象的值是否相等。这与C/C++中的用法相同。

例如：

# 数字比较
print(3 == 2)  # 输出：False
# 字符串比较
print('Hello' == 'Hello')  # 输出：True

在英语口语中，我们通常会说 “Check if 3 is equal to 2”（检查3是否等于2），或者 “Check if ‘Hello’ is equal to ‘Hello’”（检查’Hello’是否等于’Hello’）。

2.2.2 不等于运算符（!=）

在Python3中，不等于运算符（!=）用于检查两个对象的值是否不相等。这与C/C++中的用法相同。

例如：

# 数字比较
print(3 != 2)  # 输出：True
# 字符串比较
print('Hello' != 'Hello')  # 输出：False

在英语口语中，我们通常会说 “Check if 3 is not equal to 2”（检查3是否不等于2），或者 “Check if ‘Hello’ is not equal to ‘Hello’”（检查’Hello’是否不等于’Hello’）。

2.2.3 大于运算符（>）和小于运算符（<）

在Python3中，大于运算符（>）和小于运算符（<）用于比较两个对象的值的大小。这与C/C++中的用法相同。

例如：

# 数字比较
print(3 > 2)  # 输出：True
print(3 < 2)  # 输出：False

在英语口语中，我们通常会说 “Check if 3 is greater than 2”（检查3是否大于2），或者 “Check if 3 is less than 2”（检查3是否小于2）。

2.2.4 大于等于运算符（>=）和小于等于运算符（<=）

在Python3中，大于等于运算符（>=）和小于等于运算符（<=

）用于比较两个对象的值的大小。这与C/C++中的用法相同。

例如：

# 数字比较
print(3 >= 2)  # 输出：True
print(3 <= 2)  # 输出：False

在英语口语中，我们通常会说 “Check if 3 is greater than or equal to 2”（检查3是否大于或等于2），或者 “Check if 3 is less than or equal to 2”（检查3是否小于或等于2）。

2.2.5 Python3中的特殊比较运算符

Python3还提供了一些C/C++中没有的比较运算符，如身份运算符（is和is not）和成员运算符（in和not in）。

身份运算符用于比较两个对象的身份，即它们是否指向同一个对象，而不是它们的值是否相等。这是Python3和C/C++的一个主要区别，因为在C/C++中，我们通常使用指针来比较两个对象的身份。

例如：

# 身份比较
a = [1, 2, 3]
b = a
print(a is b)  # 输出：True
c = [1, 2, 3]
print(a is c)  # 输出：False

在英语口语中，我们通常会说 “Check if a is b”（检查a是否是b）。

成员运算符用于检查一个对象是否是另一个对象的成员。这是Python3和C/C++的一个主要区别，因为在C/C++中，我们通常使用循环和条件语句来检查一个对象是否是另一个对象的成员。

例如：

# 成员比较
a = [1, 2, 3]
print(1 in a)  # 输出：True
print(4 in a)  # 输出：False

在英语口语中，我们通常会说 “Check if 1 is in a”（检查1是否在a中）。

在Python3中，比较运算符的使用非常灵活，可以应用于多种数据类型。这使得Python3在处理字符串和列表等数据结构时，比C/C++更加方便和强大。同时，Python3还提供了一些C/C++中没有的比较运算符，如身份运算符和成员运算符，这使得Python3在对象比较方面也更加强大。

在《Python3 Cookbook》中，作者David Beazley和Brian K. Jones也强调了Python3比较运算符的灵活性和强大性，并通过大量的实例展示了如何在实际编程中有效地使用Python3的比较运算符。

在Python3的源码中，比较运算符的实现是通过一系列的内置函数来完成的。例如，等于运算符的实现是通过内置函数__eq__()来完成的，不等于运算符的实现是通过内置函数__ne__()来完成的，等等。这些内置函数都定义在Python3的内核中，我们可以通过阅读Python3的源码来深入理解这些运算符的实现原理。

下表总结了Python3中的比较运算符和C/C++中的对应关系：

Python3运算符	C/C++运算符	描述
==	==	等于
!=	!=	不等于
>	>	大于
<	<	小于
>=	>=	大于等于
<=	<=	小于等于
is	无	身份运算符（Python3有，C/C++无）
in	无	成员运算符（Python3有，C/C++无）

这是一个初步的介绍，后续我们将深入探讨Python3比较运算符的更多细节和高级应用。

2.3 赋值运算符

赋值运算符在Python3和C/C++中都是一个基本的运算符，用于将右侧的值赋给左侧的变量。Python3和C/C++都支持基本的赋值运算符（=），以及一系列的复合赋值运算符，如加法赋值（+=）、减法赋值（-=）、乘法赋值（*=）、除法赋值（/=）等。

2.3.1 基本赋值运算符（=）

在Python3和C/C++中，基本赋值运算符（=）的使用方法是相同的。它将右侧的值赋给左侧的变量。

例如：

# Python3
a = 3
print(a)  # 输出：3

在英语口语中，我们通常会说 “Assign 3 to a”（将3赋给a）。

2.3.2 复合赋值运算符

复合赋值运算符是一种更简洁的赋值方式，它将赋值和其他运算（如加法、减法、乘法、除法等）合并在一起。Python3和C/C++都支持一系列的复合赋值运算符，如加法赋值（+=）、减法赋值（-=）、乘法赋值（*=）、除法赋值（/=）等。

例如：

# Python3
a = 3
a += 2  # 相当于 a = a + 2
print(a)  # 输出：5

在英语口语中，我们通常会说 “Add 2 to a”（将a加2）。

在Python3中，赋值运算符的使用非常灵活，可以应用于多种数据类型。这使得Python3在处理字符串和列表等数据结构时，比C/C++更加方便和强大。

在《Python3 Cookbook》中，作者David Beazley和Brian K. Jones也强调了Python3赋值运算符的灵活性和强大性，并通过大量的实例展示了如何在实际编程中有效地使用Python3的赋值运算符。

在Python3的源码中，赋值运算符的实现是通过一系列的内置函数来完成的。例如，加法赋值运算符的实现是通过内置函数__iadd__()来完成的，减法赋值运算符的实现是通过内置函数__isub__()来完成的，等等。这些内置函数都定义在Python3的内核中，我们可以通过阅读Python3的源码来深入理解这些运算符的实现原理。

下表总结了Python3中的赋值运算符和C/C++中的对应关系：

Python3运算符	C/C++运算符	描述
=	=	基本赋值
+=	+=	加法赋值
-=	-=	减法赋值
*=	*=	乘法赋值
/=	/=	除法赋值
%=	%=	取模赋值
**=	无	幂赋值（Python3有，C/C++无）
//=	无	整除赋值（Python3有，C/C++无）

这是一个初步的介绍，后续我们将深入探讨Python3赋值运算符的更多细节和高级应用。

2.4 位运算符

位运算符在Python3和C/C++中都是一种基本的运算符，用于对二进制位进行操作。Python3和C/C++都支持一系列的位运算符，如按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）和右移（>>）。

2.4.1 按位与运算符（&）

在Python3和C/C++中，按位与运算符（&）的使用方法是相同的。它对操作数进行二进制AND运算。

例如：

# Python3
a = 60  # 60的二进制表示是 0011 1100
b = 13  # 13的二进制表示是 0000 1101
print(a & b)  # 输出：12，12的二进制表示是 0000 1100

在英语口语中，我们通常会说 “Perform bitwise AND on a and b”（对a和b进行按位与运算）。

2.4.2 按位或运算符（|）

在Python3和C/C++中，按位或运算符（|）的使用方法是相同的。它对操作数进行二进制OR运算。

例如：

# Python3
a = 60  # 60的二进制表示是 0011 1100
b = 13  # 13的二进制表示是 0000 1101
print(a | b)  # 输出：61，61的二进制表示是 0011 1101

在英语口语中，我们通常会说 “Perform bitwise OR on a and b”（对a和b进行按位或运算）。

2.4.3 按位异或运算符（^）

在Python3和C/C++中，按位异或运算符（^）的使用方法是相同的。它对操作数进行二进制XOR运算。

例如：

# Python3
a = 60  # 60的二进制表示是 0011 1100
b = 13  # 13的二进制表示是 0000 1101
print(a ^ b)  # 输出：49，49的二进制表示是 0011 0001

在英语口语中，我们通常会说 “Perform bitwise XOR on a and b”（对a和b进行按位异或运算）。

2.4.4 按位取反运算符（~）

在Python3和C/C++中，按位取反运算符（~）的使用方法是相同的。它对操作数进行二进制NOT运算。

例如：

# Python
3
a = 60  # 60的二进制表示是 0011 1100
print(~a)  # 输出：-61，-61的二进制表示是 1100 0011

在英语口语中，我们通常会说 “Perform bitwise NOT on a”（对a进行按位取反运算）。

2.4.5 左移运算符（<<）和右移运算符（>>）

在Python3和C/C++中，左移运算符（<<）和右移运算符（>>）的使用方法是相同的。它们将操作数的二进制表示向左或向右移动指定的位数。

例如：

# Python3
a = 60  # 60的二进制表示是 0011 1100
print(a << 2)  # 输出：240，240的二进制表示是 1111 0000
print(a >> 2)  # 输出：15，15的二进制表示是 0000 1111

在英语口语中，我们通常会说 “Shift a left by 2 bits”（将a左移2位）和 “Shift a right by 2 bits”（将a右移2位）。

在Python3中，位运算符的使用非常灵活，可以应用于整数和其他支持位运算的数据类型。这使得Python3在处理二进制数据时，比C/C++更加方便和强大。

在《Python3 Cookbook》中，作者David Beazley和Brian K. Jones也强调了Python3位运算符的灵活性和强大性，并通过大量的实例展示了如何在实际编程中有效地使用Python3的位运算符。

在Python3的源码中，位运算符的实现是通过一系列的内置函数来完成的。例如，按位与运算符的实现是通过内置函数__and__()来完成的，按位或运算符的实现是通过内置函数__or__()来完成的，等等。这些内置函数都定义在Python3的内核中，我们可以通过阅读Python3的源码来深入理解这些运算符的实现原理。

下表总结了Python3中的位运算符和C/C++中的对应关系：

Python3运算符	C/C++运算符	描述
&	&	按位与
\|	\|	按位或
^	^	按位异或
~	~	按位取反
<<	<<	左移
>>	>>	右移

这是一个初步的介绍，后续我们将深入探讨Python3位运算符的更多细节和高级应用。

2.5 逻辑运算符

Python3和C/C++都有逻辑运算符，但是在使用上有一些差异。Python3的逻辑运算符包括and、or和not，而C/C++的逻辑运算符则是&&、||和!。

2.5.1 and运算符

Python3的and运算符在所有操作数都为真时返回True，否则返回False。这与C/C++的&&运算符的行为是一致的。

例如：

# Python3
print(True and False)  # 输出：False

在英语口语中，我们通常会说 “Evaluate whether both True and False are true”（评估True和False是否都为真）。

2.5.2 or运算符

Python3的or运算符在至少有一个操作数为真时返回True，否则返回False。这与C/C++的||运算符的行为是一致的。

例如：

# Python3
print(True or False)  # 输出：True

在英语口语中，我们通常会说 “Evaluate whether either True or False is true”（评估True或False是否为真）。

2.5.3 not运算符

Python3的not运算符用于反转操作数的逻辑状态。如果操作数为True，则返回False；如果操作数为False，则返回True。这与C/C++的!运算符的行为是一致的。

例如：

# Python3
print(not True)  # 输出：False

在英语口语中，我们通常会说 “Evaluate the negation of True”（评估True的否定）。

Python3的逻辑运算符在处理逻辑表达式时非常有用。它们可以用于控制程序的流程，例如在if语句和while循环中。

在《Python3 Cookbook》中，作者David Beazley和Brian K. Jones详细介绍了Python3逻辑运算符的使用方法，并通过大量的实例展示了如何在实际编程中有效地使用这些运算符。

在Python3的源码中，逻辑运算符的实现是通过一系列的内置函数来完成的。例如，and运算符的实现是通过内置函数__and__()来完成的，or运算符的实现是通过内置函数__or__()来完成的，等等。这些内置函数都定义在Python3的内核中，我们可以通过阅读Python3的源码来深入理解这些运算符的实现原理。

下表总结了Python3中的逻辑运算符和C/C的对应关系：

Python3运算符	C/C++运算符	描述
and	&&	逻辑与
or
not	!	逻辑非

2.7 身份运算符

Python3和C/C++在身份运算符上有明显的区别。Python3有is和is not两个身份运算符，而C/C++没有对应的身份运算符。

2.7.1 is运算符

Python3的is运算符用于比较两个对象的身份，也就是比较它们是否为同一个对象，是否指向同一个内存地址。如果是，则返回True；否则，返回False。

例如：

# Python3
a = [1, 2, 3]
b = a
print(a is b)  # 输出：True

在英语口语中，我们通常会说 “Check if a is b”（检查a是否是b）。

2.7.2 is not运算符

Python3的is not运算符与is运算符的行为相反。它用于比较两个对象的身份，也就是比较它们是否不是同一个对象，是否指向不同的内存地址。如果不是，则返回True；否则，返回False。

例如：

# Python3
a = [1, 2, 3]
b = [1, 2, 3]
print(a is not b)  # 输出：True

在英语口语中，我们通常会说 “Check if a is not b”（检查a是否不是b）。

Python3的身份运算符在处理对象比较时非常有用。它们可以用于控制程序的流程，例如在if语句和while循环中。

在《Python3 Cookbook》中，作者David Beazley和Brian K. Jones详细介绍了Python3身份运算符的使用方法，并通过大量的实例展示了如何在实际编程中有效地使用这些运算符。

在Python3的源码中，身份运算符的实现是通过一系列的内置函数来完成的。例如，is运算符的实现是通过内置函数__eq__()来完成的，等等。这些内置函数都定义在Python3的内核中，我们可以通过阅读Python3的源码来深入理解这些运算符的实现原理。

下表总结了Python3中的身份运算符和C/C++的对应关系：

Python3运算符	C/C++运算符	描述
is	N/A	身份检查
is not	N/A	非身份检查

这是一个初步的介绍，后续我们将深入探讨Python3身份运算符的更多细节和高级应用。

3. Python3运算符的深入理解

3.1 运算符优先级

在Python3中，运算符优先级（Operator Precedence）是一个重要的概念。它决定了在表达式中运算符的执行顺序。例如，乘法和除法运算符的优先级高于加法和减法运算符，所以在表达式 3 + 4 * 2 中，先执行乘法，然后再执行加法，得到结果 11。

在C/C++中，运算符优先级的概念也是相同的，但是具体的优先级顺序可能会有所不同。例如，Python3中的幂运算符 ** 的优先级是最高的，而在C/C++中，没有这个运算符。

以下是Python3中的一些主要运算符的优先级顺序，从高到低：

运算符	描述
`**`	幂 (Exponentiation)
`~` `+` `-`	按位取反, 正负号 (Bitwise NOT, Unary plus and minus)
`*` `/` `//` `%`	乘，除，取整除，取模 (Multiplication, Division, Floor division, Modulus)
`+` `-`	加法，减法 (Addition, Subtraction)
`>>` `<<`	右移，左移 (Right, Left bitwise shift)
`&`	位 ‘AND’ (Bitwise ‘AND’)
`^` `\|`	位运算符 (Bitwise exclusive `OR` and regular `OR`)
`<=` `<` `>` `>=`	比较运算符 (Comparison operators)
`<>` `==` `!=`	等于运算符 (Equality operators)
`=` `%=` `/=` `//=` `-=` `+=` `=` `*=`	赋值运算符 (Assignment operators)
`is` `is not`	身份运算符 (Identity operators)
`in` `not in`	成员运算符 (Membership operators)
`not` `or` `and`	逻辑运算符 (Logical operators)

在实际编程中，为了避免因为运算符优先级引起的混淆，建议使用括号 () 来明确指定运算的顺序。

例如，如果你想先执行加法运算，然后再执行乘法运算，你可以这样写：

result = (3 + 4) * 2  # result is 14

在口语交流中，我们通常会这样描述这个表达式： “Three plus four, times two”（三加四，乘以二）。

在Python3的名著《Fluent Python》中，作者Luciano Ramalho在书中强调了理解运算符优先级的重要性，并建议在编程中尽可能使用括号来避免混淆。

如果你想进一步了解Python3运算符优先级，以下是一些很好的资源：

在Python3的源码中，运算符优先级是通过语法解析阶段的语法规则来实现的。这些规则定义在Python的语法定义文件Grammar/Grammar中。例如，+ 和 - 运算符的优先级是通过以下的语法规则来定义的：

factor: ('+'|'-'|'~') factor | power
term: factor (('*'|'@'|'/'|'%'|'//') factor)*
arith_expr: term (('+'|'-') term)*

这些规则说明了在没有括号的情况下，*、/、% 和 // 运算符的优先级高于 + 和 - 运算符。

在编程中，理解和正确使用运算符优先级是非常重要的。它不仅可以帮助我们写出正确的代码，也可以使我们的代码更易读，更易理解。

3.2 运算符重载

在Python3中，运算符重载（Operator Overloading）是一种特殊的语言特性，它允许我们改变已有运算符的行为，使其能够用于自定义类型的对象。例如，我们可以重载 + 运算符，使其能够用于合并两个自定义类型的对象。

在C/C++中，运算符重载的概念也是存在的，但是实现方式和Python3有所不同。在C/C++中，运算符重载是通过定义一个运算符函数来实现的，而在Python3中，运算符重载是通过定义一个特殊的方法（也称为魔术方法或dunder方法）来实现的。

以下是Python3中一些常见运算符对应的魔术方法：

运算符	魔术方法
`+`	`__add__`
`-`	`__sub__`
`*`	`__mul__`
`/`	`__truediv__`
`//`	`__floordiv__`
`%`	`__mod__`
`**`	`__pow__`
`>>`	`__rshift__`
`<<`	`__lshift__`
`&`	`__and__`
`	`
`^`	`__xor__`
`==`	`__eq__`
`!=`	`__ne__`
`<`	`__lt__`
`<=`	`__le__`
`>`	`__gt__`
`>=`	`__ge__`

例如，如果我们定义了一个自定义的类 Vector，我们可以通过定义 __add__ 方法来实现 + 运算符的重载：

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2  # v3 is a new Vector(4, 6)

在口语交流中，我们通常会这样描述这个代码： “We define a class Vector, and overload the plus operator by defining the dunder add method”（我们定义了一个类Vector，并通过定义dunder add方法来重载加号运算符）。

在Python3的名著《Fluent Python》中，作者Luciano Ramalho详细介绍了运算符重载的概念和使用方法，并强调了在设计自定义类型时，应当遵循Python的运算符重载的约定，以保证代码的一致性和可读性。

3.3 位运算符

位运算符（Bitwise Operators）在Python3中是一种特殊的运算符，它直接对整数的二进制位进行操作。Python3支持以下几种位运算符：

&（按位与）
|（按位或）
^（按位异或）
~（按位取反）
<<（左移）
>>（右移）

这些运算符在C/C++中也是存在的，但是在Python3中，由于Python3的整数类型是动态大小的，所以Python3的位运算符可以处理任意大的整数，而不会像C/C++那样出现溢出的问题。

以下是一些位运算符的使用示例：

x = 10  # binary: 1010
y = 4   # binary: 0100
print(x & y)  # Output: 0 (binary: 0000)
print(x | y)  # Output: 14 (binary: 1110)
print(x ^ y)  # Output: 14 (binary: 1110)
print(~x)     # Output: -11 (binary: -1011)
print(x << 2) # Output: 40 (binary: 101000)
print(x >> 2) # Output: 2 (binary: 10)

在口语交流中，我们通常会这样描述这个代码：“We perform various bitwise operations on the variables x and y. The bitwise AND of x and y is 0, the bitwise OR is 14, the bitwise XOR is 14, the bitwise NOT of x is -11, the left shift of x by 2 is 40, and the right shift of x by 2 is 2.”（我们对变量x和y进行了各种位运算。x和y的位与是0，位或是14，位异或是14，x的位非是-11，x左移2位是40，x右移2位是2。）

在Python3的名著《Fluent Python》中，作者Luciano Ramalho详细介绍了位运算符的概念和使用方法，并强调了在处理二进制数据时，位运算符的重要性。

如果你想进一步了解Python3的位运算符，以下是一些很好的资源：

在Python3的源码中，位运算符是通过Python的解释器（CPython）的字节码执行阶段来实现的。

3.4 逻辑运算符

逻辑运算符（Logical Operators）在Python3中用于组合条件语句。Python3支持以下几种逻辑运算符：

and（逻辑与）
or（逻辑或）
not（逻辑非）

这些运算符在C/C++中也是存在的，但是在Python3中，and 和 or 运算符的行为与C/C++有所不同。在Python3中，and 和 or 运算符是短路运算符，它们的运算过程中会返回第一个确定了整个表达式真假的值，而不是返回布尔值。而在C/C++中，&& 和 || 运算符只会返回布尔值。

以下是一些逻辑运算符的使用示例：

x = True
y = False
print(x and y)  # Output: False
print(x or y)   # Output: True
print(not x)    # Output: False

在口语交流中，我们通常会这样描述这个代码：“The logical AND of x and y is False, the logical OR is True, and the logical NOT of x is False.”（x和y的逻辑与是False，逻辑或是True，x的逻辑非是False。）

在Python3的名著《Fluent Python》中，作者Luciano Ramalho详细介绍了逻辑运算符的概念和使用方法，并强调了在处理复杂条件语句时，逻辑运算符的重要性。

如果你想进一步了解Python3的逻辑运算符，以下是一些很好的资源：

在Python3的源码中，逻辑运算符是通过Python的解释器（CPython）的字节码执行阶段来实现的。这些字节码定义在Python的字节码定义文件Include/opcode.h中。例如，逻辑与运算符对应的字节码是JUMP_IF_FALSE_OR_POP，逻辑或运算符对应的字节码是JUMP_IF_TRUE_OR_POP，逻辑非运算符对应的字节码是UNARY_NOT。

4. Python3运算符的高级应用

4.1 运算符在数据结构中的应用

Python3提供了一系列的内置数据结构，如列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）。这些数据结构在日常编程中非常常用，而Python3的运算符可以使我们更有效地操作这些数据结构。

列表（List）

在Python3中，我们可以使用 + 运算符来连接两个列表，这在C/C++中是无法做到的。例如：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = list1 + list2
print(list3)  # 输出：[1, 2, 3, 4, 5, 6]

在上述代码中，+ 运算符被用于连接两个列表。这是Python3的一个特性，它允许我们使用熟悉的数学运算符来操作非数值类型的数据。

在英语口语中，我们可以这样描述上述代码：“We have two lists, list1 and list2. We use the plus operator to concatenate them into a new list, list3.”（我们有两个列表，list1和list2。我们使用加号运算符将它们连接成一个新的列表，list3。）

字典（Dictionary）

Python3的字典（Dictionary）是一种键值对（Key-Value）的数据结构。我们可以使用 in 运算符来检查一个键是否存在于字典中。例如：

dict1 = {'a': 1, 'b': 2, 'c': 3}
if 'b' in dict1:
    print('Key "b" exists in the dictionary.')
else:
    print('Key "b" does not exist in the dictionary.')

在上述代码中，in 运算符被用于检查键 'b' 是否存在于字典 dict1 中。这是Python3的另一个特性，它允许我们使用简洁的语法来完成复杂的操作。

在英语口语中，我们可以这样描述上述代码：“We have a dictionary, dict1. We use the ‘in’ operator to check if the key ‘b’ exists in the dictionary.”（我们有一个字典，dict1。我们使用 ‘in’ 运算符来检查键 ‘b’ 是否存在于字典中。）

集合（Set）

Python3的集合（Set）是一种无序且元素唯一的数据结构。我们可以使用 - 运算符来求两个集合的差集。例如：

set1
在Python3中，我们可以使用 `+` 运算符来连接两个列表，这在C/C++中是无法做到的。例如：
```python
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = list1 + list2
print(list3)  # 输出：[1, 2, 3, 4, 5, 6]

在上述代码中，+ 运算符被用于连接两个列表。这是Python3的一个特性，它允许我们使用熟悉的数学运算符来操作非数值类型的数据。

字典（Dictionary）

Python3的字典（Dictionary）是一种键值对（Key-Value）的数据结构。我们可以使用 in 运算符来检查一个键是否存在于字典中。例如：

dict1 = {'a': 1, 'b': 2, 'c': 3}
if 'b' in dict1:
    print('Key "b" exists in the dictionary.')
else:
    print('Key "b" does not exist in the dictionary.')

在上述代码中，in 运算符被用于检查键 'b' 是否存在于字典 dict1 中。这是Python3的另一个特性，它允许我们使用简洁的语法来完成复杂的操作。

集合（Set）

Python3的集合（Set）是一种无序且元素唯一的数据结构。我们可以使用 - 运算符来求两个集合的差集。例如：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = set1 - set2
print(set3)  # 输出：{1, 2}

在上述代码中，- 运算符被用于求 set1 和 set2 的差集。这是Python3的另一个特性，它允许我们使用熟悉的数学运算符来操作非数值类型的数据。

4.2 运算符在函数和类中的应用

Python3的运算符不仅可以用于数据结构，还可以在函数和类中发挥重要作用。下面我们将详细介绍这些应用。

函数中的运算符

在Python3的函数中，我们可以使用运算符来进行各种计算和操作。例如，我们可以定义一个函数，使用 * 运算符来计算两个数的乘积：

def multiply(a, b):
    return a * b
result = multiply(3, 4)
print(result)  # 输出：12

在上述代码中，* 运算符被用于计算 a 和 b 的乘积。这是Python3的一个特性，它允许我们在函数中使用运算符来完成各种计算。

在英语口语中，我们可以这样描述上述代码：“We define a function named ‘multiply’ that takes two parameters, ‘a’ and ‘b’. We use the asterisk operator to multiply ‘a’ and ‘b’.”（我们定义了一个名为 ‘multiply’ 的函数，它接受两个参数，‘a’ 和 ‘b’。我们使用星号运算符来乘 ‘a’ 和 ‘b’。）

类中的运算符

在Python3的类中，我们可以重载（Overload）运算符，使其在类的对象上执行自定义的操作。例如，我们可以定义一个 Vector 类，并重载 + 运算符，使其可以对两个 Vector 对象进行向量加法：

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2
print(v3.x, v3.y)  # 输出：4 6

在上述代码中，+ 运算符被重载，用于执行向量加法。这是Python3的一个特性，它允许我们在类中重载运算符，以实现自定义的操作。

在英语口语中，我们可以这样描述上述代码：“We define a class named ‘Vector’ with a method ‘add’ that overloads the plus operator. The plus operator is now used to perform vector addition on ‘Vector’ objects.”（我们定义了一个名为 ‘Vector’ 的类，其中有一个 ‘add’ 方法，该方法重载了加号运算符。现在，加号运算符被用于对 ‘Vector’ 对象执行向量加法。）

5. Python3运算符的实际应用案例

5.1 使用运算符进行数学计算

在Python3中，我们可以使用各种运算符来进行数学计算。这些运算符包括基本的加法(+), 减法(-), 乘法(*), 除法(/), 取余(%), 幂运算(**), 整除(//)等。

示例1

# 加法
print(5 + 3)  # 输出：8
# 减法
print(5 - 3)  # 输出：2
# 乘法
print(5 * 3)  # 输出：15
# 除法
print(5 / 3)  # 输出：1.6666666666666667
# 取余
print(5 % 3)  # 输出：2
# 幂运算
print(5 ** 3)  # 输出：125
# 整除
print(5 // 3)  # 输出：1

在C/C++中，这些基本的数学运算符的使用方式与Python3基本相同。但是，Python3中的除法运算符(/)在处理整数除法时，会返回浮点数结果，而在C/C++中，整数除法会返回整数结果，即舍去小数部分。例如，5 / 3在Python3中的结果是1.6666666666666667，而在C/C++中的结果是1。

此外，Python3中的幂运算符(**)在C/C++中没有对应的运算符，C/C++中进行幂运算需要使用函数如pow()。

在Python3中，我们还可以使用复合赋值运算符，如+=，-=，*=，/=，%=，**=，//=等。这些运算符可以在原有变量的基础上进行运算并赋值。

示例2

a = 5
a += 3  # 等价于 a = a + 3
print(a)  # 输出：8
a -= 2  # 等价于 a = a - 2
print(a)  # 输出：6
a *= 2  # 等价于 a = a * 2
print(a)  # 输出：12
a /= 3  # 等价于 a = a / 3
print(a)  # 输出：4.0
a %= 3  # 等价于 a = a % 3
print(a)  # 输出：1.0
a **= 3  # 等价于 a = a ** 3
print(a)  # 输出：1.0
a //= 2  # 等价于 a = a // 2
print
在Python3中，我们可以使用复合赋值运算符，如`+=`，`-=`，`*=`，`/=`，`%=`，`**=`，`//=`等。这些运算符可以在原有变量的基础上进行运算并赋值。
### <font face="楷体" size =3 color=#9999>示例</font>
```python
a = 5
a += 3  # 等价于 a = a + 3
print(a)  # 输出：8
a -= 2  # 等价于 a = a - 2
print(a)  # 输出：6
a *= 2  # 等价于 a = a * 2
print(a)  # 输出：12
a /= 3  # 等价于 a = a / 3
print(a)  # 输出：4.0
a %= 3  # 等价于 a = a % 3
print(a)  # 输出：1.0
a **= 3  # 等价于 a = a ** 3
print(a)  # 输出：1.0
a //= 2  # 等价于 a = a // 2
print(a)  # 输出：0.0

在C/C++中，这些复合赋值运算符的使用方式与Python3基本相同。但是，需要注意的是，Python3的除法赋值运算符(/=)在处理整数除法时，会返回浮点数结果，而在C/C++中，整数除法会返回整数结果，即舍去小数部分。

此外，Python3中的幂运算赋值运算符(**=)在C/C++中没有对应的运算符，C/C++中进行幂运算需要使用函数如pow()。

如果你想进一步了解Python3运算符，以下是一些推荐的阅读资源：

这些资源都是Python3运算符的详细介绍，包括基础的运算符使用，运算符优先级，以及运算符在实际编程中的应用等内容。

5.2 使用运算符进行数据比较

Python3提供了一系列的比较运算符，用于比较两个值的大小。这些比较运算符包括等于(==)，不等于(!=)，大于(>)，小于(<)，大于等于(>=)，小于等于(<=)等。

示例1

# 等于
print(5 == 3)  # 输出：False
# 不等于
print(5 != 3)  # 输出：True
# 大于
print(5 > 3)  # 输出：True
# 小于
print(5 < 3)  # 输出：False
# 大于等于
print(5 >= 3)  # 输出：True
# 小于等于
print(5 <= 3)  # 输出：False

在C/C++中，这些比较运算符的使用方式与Python3基本相同。但是，Python3中的等于运算符(==)和不等于运算符(!=)在处理对象比较时，会比较对象的值，而在C/C++中，这两个运算符会比较对象的地址。

此外，Python3还提供了is和is not运算符，用于比较两个对象是否相同，即比较对象的地址是否相同。这在C/C++中没有对应的运算符。

示例2

a = [1, 2, 3]
b = [1, 2, 3]
# `==`比较对象的值
print(a == b)  # 输出：True
# `is`比较对象的地址
print(a is b)  # 输出：False

5.3 Python3的逻辑运算符

Python3提供了三种逻辑运算符，即and，or，和not。

and运算符：如果两个操作数都为真，则条件变为真。

or运算符：如果两个操作数中的任何一个为真，则条件变为真。

not运算符：用于反转操作数的逻辑状态。如果条件为真，则逻辑NOT条件为假。

示例

a = True
b = False
# and运算符
print(a and b)  # 输出：False
# or运算符
print(a or b)  # 输出：True
# not运算符
print(not a)  # 输出：False
print(not b)  # 输出：True

在C/C++中，逻辑运算符的使用方式与Python3基本相同，但是，C/C++使用符号(&&，||，!)来表示逻辑运算符，而Python3使用英文单词(and，or，not)。

6. Python3运算符的注意事项

6.1 运算符使用的常见错误

在Python3编程中，运算符的使用是非常常见的，但是也容易出现一些错误。这些错误可能是由于对运算符的误解，或者是对Python3语言特性的不熟悉。在这一节中，我们将详细介绍这些常见的错误，并提供一些解决方案。

6.1.1 使用错误的运算符

在Python3中，每个运算符都有其特定的用途和规则。例如，==（等于）和is（身份）运算符在表面上看起来很相似，但它们实际上有着根本的区别。==运算符比较的是两个对象的值是否相等，而is运算符比较的是两个对象是否是同一个对象（即，是否指向同一个内存地址）。

在C/C++中，我们通常使用==来比较两个对象是否相等，而在Python3中，我们需要根据具体的情况来选择使用==还是is。

例如，当我们比较两个列表是否相等时，我们应该使用==运算符：

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)  # 输出：True

但是，如果我们想要检查两个列表是否指向同一个对象，我们应该使用is运算符：

list1 = [1, 2, 3]
list2 = list1
print(list1 is list2)  # 输出：True

在英语口语交流中，我们可以这样描述这两个运算符的区别：“The ‘==’ operator checks if the values of two objects are equal (等于运算符检查两个对象的值是否相等)，while the ‘is’ operator checks if they are the same object (而身份运算符检查它们是否是同一个对象)。”

6.1.2 忽视运算符的优先级

在Python3中，运算符有不同的优先级。例如，乘法和除法运算符的优先级高于加法和减法运算符。这意味着，在没有括号的情况下，乘法和除法运算符会先于加法和减法运算符执行。

这一点与C/C++是一致的。然而，由于Python3的动态类型特性，有时候运算符的优先级可能会导致一些非预期的结果。

6.2 如何避免运算符使用中的陷阱

在Python3编程中，理解并正确使用运算符是非常重要的。以下是一些避免在使用运算符时陷入常见陷阱的建议：

6.2.1 明确运算符的优先级

Python3的运算符优先级规则与C/C++大致相同，但由于Python3的动态类型特性，有时候运算符的优先级可能会导致一些非预期的结果。因此，当表达式中含有多个运算符时，最好使用括号来明确运算的顺序。

例如，以下的表达式：

result = 3 + 4 * 5

在Python3和C/C++中，由于乘法运算符的优先级高于加法运算符，所以result的值将会是23，而不是35。如果你想先进行加法运算，你应该使用括号：

result = (3 + 4) * 5  # result的值现在是35

在英语口语交流中，我们可以这样描述这个问题：“In Python, as in C/C++, the multiplication operator has higher precedence than the addition operator (在Python和C/C++中，乘法运算符的优先级高于加法运算符). So, to change the order of operations, we can use parentheses (所以，要改变运算的顺序，我们可以使用括号).”

6.2.2 正确理解和使用`==`和`is`运算符

在Python3中，==和is运算符有着根本的区别。==运算符比较的是两个对象的值是否相等，而is运算符比较的是两个对象是否是同一个对象（即，是否指向同一个内存地址）。在C/C++中，我们通常使用==来比较两个对象是否相等，但在Python3中，我们需要根据具体的情况来选择使用==还是is。

例如，当我们比较两个列表是否相等时，我们应该使用==运算符。但是，如果我们想要检查两个列表是否指向同一个对象，我们应该使用is运算符。

在英语口语交流中，我们可以这样描述这个问题：“In Python, the '’ operator checks if the values of two objects are equal, while the ‘is’ operator checks if they are the same object (在Python中，''运算符检查两个对象的值是否相等，而’is’运算符检查它们是否是同一个对象).”

7. 结论

7.1 Python3运算符的重要性回顾

Python3运算符在编程中起着至关重要的作用。它们是实现各种计算、比较、逻辑判断和赋值操作的基础工具。理解和熟练使用Python3的运算符，可以帮助我们编写出更高效、更简洁的代码。

在Python3中，运算符的使用和C/C++有一些重要的区别。例如，Python3中的赋值运算符=和C/C++中的赋值运算符功能相同，都是用来给变量赋值。但是，Python3中的等于运算符==和C/C++中的等于运算符有一些不同。在Python3中，==运算符用来比较两个对象的值是否相等，而在C/C++中，==运算符用来比较两个变量的值是否相等。

此外，Python3还引入了一些C/C++中没有的运算符，如身份运算符is。is运算符用来比较两个对象是否是同一个对象，即比较两个对象的内存地址是否相同。这是Python3相比C/C++的一个独特之处。

让我们通过一个例子来看看Python3运算符的使用：

# Python3
a = 10
b = 20
print(a == b)  # 输出：False
print(a is b)  # 输出：False

在这个例子中，我们首先定义了两个变量a和b，然后使用==运算符比较它们的值是否相等，结果为False。然后我们使用is运算符比较a和b是否是同一个对象，结果也为False。

在英语口语交流中，我们通常会这样描述上述代码：“We have two variables, a and b. We use the equal to operator to check if their values are the same, and the result is False. Then we use the is operator to check if a and b are the same object, and the result is also False.”（我们有两个变量，a和b。我们使用等于运算符来检查它们的值是否相同，结果是False。然后我们使用is运算符来检查a和b是否是同一个对象，结果也是False。）

在Python3的经典著作《Python核心编程》中，作者对Python3运算符的使用进行了详细的介绍。书中指出，理解和熟练使用Python3的运算符，是成为一名优秀Python程序员的关键步骤。

下表总结了一些优秀的资源，你可以参考这些来深入学习Python3的运算符：

Python 3 - Basic Operators - 这是一个非常基础的Python3运算符的教程，适合初学者。
Python: Operators - 这个页面详细介绍了Python的各种运算符，包括算术运算符、比较运算符、赋值运算符等。
Python Operators - A Quick Reference | DigitalOcean - 这是一个快速参考指南，列出了Python的所有运算符。
How To Do Math in Python 3 with Operators | DigitalOcean - 这个教程介绍了如何使用Python的运算符进行数学计算。
Operators In Python - 这个页面详细介绍了Python的运算符，包括算术运算符、比较运算符、逻辑运算符等。
Python Operators Overview - 这个页面提供了Python运算符的概述，包括位运算符、算术运算符、比较运算符等。
Basic Python Semantics: Operators - 这个页面介绍了Python的基本语义，包括运算符。

这些资源都是由Python专家编写的，非常适合有C/C++基础的人学习Python3运算符。

7.2 对Python3运算符的深入理解的重要性

理解Python3运算符的重要性不仅在于能够编写出有效的代码，更在于能够深入理解Python语言的工作原理。Python3运算符是Python语言的基础组成部分，它们定义了Python中各种数据类型之间的交互方式。

例如，考虑以下Python代码：

a = 10
b = 20
print(a == b)  # 输出：False
print(a is b)  # 输出：False

在这段代码中，我们首先定义了两个变量a和b，然后使用==运算符比较它们的值是否相等，结果为False。然后我们使用is运算符比较a和b是否是同一个对象，结果也为False。

通过深入理解Python3运算符，我们可以更好地理解Python代码的工作原理，从而编写出更高效、更可读的代码。

【Python 基础教程 运算符06】Python3运算符超详细解析：全面入门教程，初学者必读

1. 引言

1.1 Python3运算符的重要性

1.2 运算符在编程中的角色

2. Python3基础运算符

2.1 算术运算符

2.1.1 加法运算符（+）

2.1.2 减法运算符（-）

2.1.3 乘法运算符（*）

2.1.4 除法运算符（/）

2.1.5 取模运算符（%）

2.1.6 幂运算符（**）

2.1.7 取整除运算符（//）

2.2 比较（关系）运算符

2.2.1 等于运算符（==）

2.2.2 不等于运算符（!=）

2.2.3 大于运算符（>）和小于运算符（<）

2.2.4 大于等于运算符（>=）和小于等于运算符（<=）

2.2.5 Python3中的特殊比较运算符

2.3 赋值运算符

2.3.1 基本赋值运算符（=）

2.3.2 复合赋值运算符

2.4 位运算符

2.4.1 按位与运算符（&）

2.4.2 按位或运算符（|）

2.4.3 按位异或运算符（^）

2.4.4 按位取反运算符（~）

2.4.5 左移运算符（<<）和右移运算符（>>）

2.5 逻辑运算符

2.5.1 and运算符

2.5.2 or运算符

2.5.3 not运算符

2.7 身份运算符

2.7.1 is运算符

2.7.2 is not运算符

3. Python3运算符的深入理解

3.1 运算符优先级

3.2 运算符重载

3.3 位运算符

3.4 逻辑运算符

4. Python3运算符的高级应用

4.1 运算符在数据结构中的应用

列表（List）

字典（Dictionary）

集合（Set）

字典（Dictionary）

集合（Set）

4.2 运算符在函数和类中的应用

函数中的运算符

类中的运算符

5. Python3运算符的实际应用案例

5.1 使用运算符进行数学计算

示例1

示例2

5.2 使用运算符进行数据比较

示例1

示例2

5.3 Python3的逻辑运算符

示例

6. Python3运算符的注意事项

6.1 运算符使用的常见错误

6.1.1 使用错误的运算符

6.1.2 忽视运算符的优先级

6.2 如何避免运算符使用中的陷阱

6.2.1 明确运算符的优先级

6.2.2 正确理解和使用==和is运算符

7. 结论

7.1 Python3运算符的重要性回顾

7.2 对Python3运算符的深入理解的重要性

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

【Python 基础教程运算符06】Python3运算符超详细解析：全面入门教程，初学者必读

6.2.2 正确理解和使用`==`和`is`运算符