Python3基础之运算符的一些开发使用注意事项和代码示例详解

Python是一种功能强大且流行的编程语言，它提供了多种运算符，用于执行各种数学和逻辑操作。在本篇文章中，我将为大家详细介绍和总结Python3中常用的运算符的使用，分别包括：算术运算符、比较运算符、逻辑运算符、赋值运算符、成员运算符、身份运算符、运算符优先级、比较运算符和逻辑运算符、运算符特俗方法。

1. 算术（数学）运算符

首先介绍的是用于执行基本的数学操作，包括加减乘除，取反，四舍五入等内置函数的数学函数等。

加法运算符：用于将两个操作数相加。例如，a + b将返回a和b的和。
减法运算符：用于从第一个操作数中减去第二个操作数。例如，a - b将返回a和b的差。
乘法运算符：用于将两个操作数相乘。例如，a * b将返回a和b的积。
除法运算符：用于将第一个操作数除以第二个操作数。例如，a / b将返回a除以b的结果。
取模运算符：用于返回除法的余数。例如，a % b将返回a除以b的余数。
幂运算符：用于将第一个操作数作为底数，第二个操作数作为指数进行幂运算。例如，a ** b将返回a的b次幂。
整除运算符：用于返回除法的商，省略小数部分。例如，a // b将返回a除以b的整数部分。
乘方运算符：乘方运算符（**）用于计算一个值的乘方，即将一个数字以指数形式进行计算。乘方运算符的左操作数是底数，右操作数是指数。对应的内置函数式pow(x, y)。
开方运算符：在Python中，开方运算符的语法没有直接提供。如果要计算一个数的开方，可以使用数学模块（math module）中的sqrt()函数。
取反运算符（-x）：表示取x反值。
abs(x)：表示x 的绝对值或大小。
math.trunc(x)：表示将x截断为整数。
round(x[, n])：表示将x四舍五入为n位小数，一半的数值会舍入为偶数，如果省略n，则默认为0。
math.floor(x)：表示Integral <= x，向下取整。
math.ceil(x)：表示Integral >= x，向上取整。

代码示例

1. 算术运算符

num1 = 10

num2 = 3

print(num1 + num2) # 输出13，表示a和b的和

print(num1 - num2) # 输出7，表示a减去b

print(num1 * num2) # 输出30，表示a和b的乘积

print(num1 / num2) # 输出3.3333333333333335，表示a除以b的结果（浮点数）

print(num1 // num2) # 输出3，表示a除以b的结果（整数部分）

print(num1 % num2) # 输出1，表示a除以b的余数

print(math.trunc(1.345)) # 1

print(round(1.234345,2)) # 1.23

print(round(1.234345)) # 1

print(round(2.5)) # 2

print(math.floor(1.2)) # 1

print(math.ceil(1.2)) # 2

2. 乘方运算符（**）

num1 = 2

num2 = 3

print(num1 ** num2) # 8 表示2的3次方（exponentiation）

print(4.5 ** 2) # 计算4.5的平方输出：20.25

3. 开方运算符（math.sqrt()）

import math

print(math.sqrt(16)) # 4.0，表示对16进行开方

2. 比较（关系）运算符

接下来是介绍用于比较两个操作数之间的关系，并返回True或False。这里一共总结了有8个比较运算，这8个比较运算的优先级是一样的，但是比较运算的优先级比布尔运算的优先级高。

等于运算符：用于检查两个操作数是否相等。例如，a == b将返回True如果a等于b。
不等于运算符：用于检查两个操作数是否不相等。例如，a != b将返回True如果a不等于b。
大于运算符：用于检查第一个操作数是否大于第二个操作数。例如，a > b将返回True如果a大于b。
小于运算符：用于检查第一个操作数是否小于第二个操作数。例如，a < b将返回True如果a小于b。
大于等于运算符：用于检查第一个操作数是否大于或等于第二个操作数。例如，a >= b将返回True如果a大于或等于b。
小于等于运算符：用于检查第一个操作数是否小于或等于第二个操作数。例如，a <= b将返回True如果a小于或等于b。
is：表示是（对象标识）。
is not：表示不是（否定的对象标识）。

除了不同的数字类型外，所有其他不同的类型都认为是不等的。将不合适的类型进行比较时，会抛出TypeError。

from datetime import datetime, timedelta

now = datetime.now()

yesterday = now + timedelta(days=1)

print(now, yesterday) # 2023-10-17 23:24:46.355663 2023-10-18 23:24:46.355663

print(now > yesterday) # False

print(2 < 1.5) # False

print(type(now)) # <class 'datetime.datetime'>

# print(2 < now) # TypeError: '<' not supported between instances of 'int' and 'datetime.datetime'

关于这里的from import 的使用可以关注公众号CTO Plus后面的文章《Python3基础之语句的开发使用注意事项和代码示例详解》中的介绍，这里先直接按照代码示例来使用即可。

元组是不可变类型，下面例子中的t1== t2和t1 is t2的结果都为True，并且打印出t1、t2的内存地址都一样，说明Python在背后做了一些优化，t1和t2的值是一样的，所以在定义d的时候，直接复用了已经创建好t1的值，t1和t2指向了同一个对象。

t1 = (11, 22)

t2 = (11, 22)

t3, t4 = ("SteveRocket", 28), ("SteveRocket", 28)

print(t1==t2) # True

print(t1 is t2) # True

print(id(t1), id(t2)) # 2403642442944 2403642442944

print(t3==t4) # True

print(t3 is t4) # True

print(id(t3), id(t4)) # 2403642133440 2403642133440

另外，还有in和 not in，如果element是elements的一个成员，element in elements 则为 True，否则就是False 。not in是正好相反的。

print(11 in t1) # True

print(11 not in t1) # False

关于更细节的内容，可以查看后文中的身份运算符，以及关注CTO Plus后面的文章《Python3基础之语句的开发使用注意事项和代码示例详解》和《Python3基础之条件判断语句、分支结构以及逻辑控制详解》。

比较运算符的注意事项

此处介绍下对于Python3的比较运算符，哪些是可以比较哪些是不可以比较的，以及开发过程中的一些注意事项。

这些比较运算符可以用于比较以下数据类型的值：

1. 数值型（如整数、浮点数等）

2. 字符串

3. 布尔型（True和False）

4. 列表、元组和集合

5. 字典

6. 自定义对象（根据实现的__eq__方法来进行比较）

需要注意的是，以下情况下可能会出现比较运算符不可用的情况：

1. 不同数据类型之间的比较：例如，不能直接比较整数和字符串，因为它们是不同的数据类型。在这种情况下，可以使用类型转换将它们转换为相同类型，然后进行比较（不建议将一些无意义的拿来做比较）。

2. 无法比较的对象类型：某些对象类型可能没有实现比较运算符，或者实现的比较方式不符合预期。在这种情况下，可能需要自定义对象的比较逻辑。

3. 对象的不可比较性：某些对象可能定义了自己的不可比较行为，这意味着它们不能使用比较运算符进行比较。这些对象的比较可能会引发TypeError异常。

在使用比较运算符时，还需要注意以下事项：

1. 链式比较：Python允许同时比较多个值，例如a < b < c，这个表达式会先比较a < b，然后再比较b < c。这使得我们可以使用简洁的方式进行多个比较操作。

2. 注意布尔运算：比较运算符可以与逻辑运算符（如and、or）一起使用。但需要注意的是，and运算符优先级高于比较运算符，所以a and b < c会先进行and运算，然后再进行比较。

3. None的比较：None表示空值，它可以与任何对象进行比较。但需要注意，None只能使用is和is not进行比较，不能使用==和!=。这是因为is运算符比较的是对象的身份标识，而==比较的是对象的值。

4. 字符串比较：在比较字符串时，Python使用的是字典顺序，即按照字符的Unicode码进行比较。例如，对于大写字母'A'和小写字母'a'，'A'会被认为比'a'小。

5. 比较运算如果成立，就是为真，返回True，否则返回False，说明比较不成立。

代码示例

a = 5

b = 3

print(a == b) # 输出False，表示a是否等于b

print(a != b) # 输出True，表示a是否不等于b

print(a > b) # 输出True，表示a是否大于b

print(a < b) # 输出False，表示a是否小于b

print(a >= b) # 输出True，表示a是否大于等于b

print(a <= b) # 输出False，表示a是否小于等于b

除了数字之外，还可以对字符串进行比较。字符串中的比较是按照“字典顺序”进行比较的。当然，这里说的是英文的字典，不是前面说的字典数据类型。

s1 = "abcd"

s2 = "efgh"

s3 = "ABCD"

print(s1 > s2) # False

print(s3 > s1) # False

print(s2 > s3) # True

在Python中，如果是两种不同类型的对象，虽然可以比较，但我还是不赞成这样的比较操作，这样的比较也不合理。

但是请注意，上面的比较操作是在Python2中是被允许的，如下在Python3中就会报错

3. 逻辑运算符以及和布尔类型的协同使用

接下来介绍下Python3中的逻辑运算符的逻辑含义以及逻辑运算符的使用注意事项，然后介绍下Python3布尔类型的变量来源背景以及使用注意事项。

Python3中的逻辑运算符包括与、或和非三种，分别对应的是"and"、"or"和"not"，用于执行逻辑操作。

与运算符：用于检查所有操作数是否都为True。例如，a and b将返回True如果a和b都为True。
或运算符：用于检查任何一个操作数是否为True。例如，a or b将返回True如果a或b为True。
非运算符：用于对操作数进行取反操作。例如，not a将返回True如果a为False。

下面详细介绍每个逻辑运算符的逻辑含义和使用注意事项：

1. 逻辑与运算符（and）

and，翻译为“与”运算。逻辑含义：当所有操作数都为True时，返回True；否则返回False。

A and B，含义是：首先运算A，如果A的值是true，就计算B，并将B的结果返回做为最终结果，如果B是False，那么A and B的最终结果就是False，如果B的结果是True，那么A and B的结果就是True；如果A的值是False，就不计算B了，直接返回A and B的结果为False。

使用注意事项：

如果第一个操作数为False，那么不会计算第二个操作数，直接返回False。这种情况下称为"短路求值"，可以提高程序的效率。
当至少有一个操作数为False时，整个表达式结果必定为False，可以用于编写条件判断语句。

print(4>3 and 4<9)  # Trueprint(4>3 and 4<2)  # Falseprint(4<3 and 4<9)  # Falseprint(4<3 and 4<2)  # Falseif True and False:    print("is true")else:    print("is false") # is false

4>3 and 4<9，首先看4>3的值是True，再看4<9的值是True，那么最终这个表达式的结果为True。

4>3 and 4<2，先看4>3，返回True，再看4<2，返回的是False，那么最终结果是False。

4<3 and 4<9，先看4<3返回False，就不看后面的值了，直接返回这个结果做为最终结果，这种现象也称之为“短路”。

2. 逻辑或运算符（or）

or，翻译为“或”运算。逻辑含义：当至少有一个操作数为True时，返回True；否则返回False。

使用注意事项：

如果第一个操作数为True，那么不会计算第二个操作数，直接返回True。这种情况下也是"短路求值"。
当所有的操作数都为False时，整个表达式结果才为False。

代码示例：

if True or False:    print("is true")  # is trueelse:    print("is false")

3. 逻辑非运算符（not）

not，翻译成“非”或“否”，不论面对什么，就是要否定它。

逻辑含义：对操作数进行取反操作，即True变为False，False变为True。

print(4 > 3) # True

print(not 4 > 3) # False

print(not "") # True

print(not 4 < 3) # True

print(not object) # False

print(not True) # False

print(not False) # True

使用注意事项：

逻辑非运算符的优先级较高，因此在使用时可以使用括号来明确运算的顺序。
可以将逻辑非运算符与其他逻辑运算符（如与、或）结合使用，将不同的逻辑表达式组合起来。

布尔运算符

Python3中的布尔类型变量源于布尔代数，用来表示真和假的值。在Python3中，True和False是两个关键字，分别表示真和假。

使用布尔类型变量时，需要注意以下几点：

布尔类型变量只能取True或False两个值。
布尔类型变量可以用于条件判断语句（如if语句），根据条件的真假执行不同的代码块。
布尔类型变量可以与逻辑运算符一起使用，进行复杂的逻辑判断。

例如，可以使用逻辑与运算符（and）来检查两个条件是否同时满足：

x = 5

y = 10

if x > 0 and y < 20:

print("Both conditions are true.")

使用逻辑或运算符（or）来检查多个条件是否至少有一个满足：

x = 5

y = 25

if x > 0 or y < 20:

print("At least one condition is true.")

使用逻辑非运算符（not）对条件进行取反操作：

x = 5

if not x > 10:

print("Condition is not true.")

需要注意的是，在处理布尔类型变量时，要确保表达式的结果是True或False，避免因为类型错误而导致意外的结果。

a = True

b = False

print(a and b) # 输出False，表示a和b的逻辑与

print(a or b) # 输出True，表示a和b的逻辑或

print(not b) # 输出True，表示b的逻辑非

关于if条件判断语句的使用可以参考公众号CTO Plus后面的文章《Python3基础之条件判断语句、分支结构以及逻辑控制详解》和《Python3基础之语句的开发使用注意事项和代码示例详解》，这里先直接使用。

4. 赋值运算符

赋值运算符用于为变量赋值。赋值运算符应该是最为常见的运算符，它的作用是将右边的值赋给左边的变量。

简单赋值运算符：用于将右侧的值赋给左侧的变量。例如，a = b将使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 = 5

b = 3

b += a# 等同于 b = b + a

print(b)# 输出8，表示b加上a的值

a -= b# 等同于 a = a - b

print(a)# 输出-3，表示a减去b的值

b *= a# 等同于 b = b * a

print(b)# 输出-24，表示b乘以a的值

a /= b# 等同于 a = a / b

print(a)# 输出-0.125，表示a除以b的值

b %= a# 等同于 b = b % a

print(b)# 输出-6.0，表示b除以a的余数

a **= b# 等同于 a = a ** b

print(a)# 输出0.000003814697265625，表示a的b次方的值

a *= a + 2 # 相当于：a = a * (a + 2)

5. 成员运算符

成员运算符用于判断一个值是否属于指定序列（例如列表、字符串等）。Python 3中的成员运算符有两个：in和not in。

代码示例

from FeaturesVersion import AGE, AUTHOR, BLOG, WEIXIN_URLuser_infos = [AGE, AUTHOR, BLOG, WEIXIN_URL]print(user_infos)  # [28, 'steverocket', '微信公众号：CTO Plus', 'https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q']print(28 in user_infos) # True 表示28在列表user_infos中print("Cramer" not in user_infos) # True 表示" Cramer "不在列表user_infos中

6. 身份运算符

Python3中的身份运算符用于比较两个对象的内存地址是否相同，即判断两个对象是否是同一个对象。身份运算符包括"is"和"is not"。

"is"运算符

用于判断两个对象是否是同一个对象。如果两个对象的内存地址相同，则返回True；否则返回False。例如：

a = [1, 2, 3]

b = a

print(a is b) # 输出True，a和b指向同一个列表对象

"is not"运算符

用于判断两个对象是否不是同一个对象。如果两个对象的内存地址不同，则返回True；否则返回False。例如：

a = [1, 2, 3]

b = [1, 2, 3]

print(a is not b) # 输出True，a和b指向不同的列表对象

需要注意的是，身份运算符比较的是对象的内存地址，而不是对象的值。即使两个对象的值相同，但如果它们的内存地址不同，身份运算符也会返回False。

比较运算符

此外，Python中还有一个"=="运算符用于比较两个对象的值是否相等。与身份运算符不同，"=="运算符比较的是对象的值，而不是内存地址。例如：

a = [1, 2, 3]

b = [1, 2, 3]

print(a == b) # 输出True，a和b的值相等

代码示例

num1 = 123

num2 = 123

num3 = int("123")

print(num1 == num2) # True

print(num1 is num2, num1 is num3) # True True

print(id(num1), id(num2), id(num3)) # 140735343489640 140735343489640 140735343489640

上述代码中，num1 == num2 只要num1和num2表示的值是一样的，就被认为是相等，但是is需要num1和num2是同一个对象（地址相同）才行。对于类对象来说==和is是一样的。

li1 = [11,22]

li2 = [11,22]

print(li1 == li2) # True

print(li1 is li2) # False

print(id(li1), id(li2)) # 2972199640896 2972203093504

需要注意的是，对于不可变对象（如整数、字符串等），身份运算符和"=="运算符的结果是一样的，因为不可变对象的值不会改变。但对于可变对象（如列表、字典等），身份运算符和"=="运算符的结果可能不一样，因为可变对象的值可以改变。

7. 运算符优先级

Python 3中的运算符具有不同的优先级。当多个运算符同时出现时，具有较高优先级的运算符会被先计算。如果优先级相同，则根据从左到右的顺序计算。当然，我们可以使用括号来改变运算符的计算顺序。

以下是Python 3中常见的运算符优先级（高优先级排在前面）：

一个要注意的地方是，Python 3中的乘方运算符和成员运算符的优先级较高，而开方运算符和三元操作符的优先级较低。所以，在复合表达式中，可能需要使用括号来控制运算的顺序。

Python的运算符和其他语言类似，我们暂时只了解这些运算符的基本用法，方便我们展开后面的内容，高级应用部分我将在公众号CTOPlus后面的文章中继续输出，敬请关注。

总结

以上就是Python3中常用的运算符。通过熟悉并灵活使用它们，我们可以轻松进行各种数学和逻辑操作，从而更好地编写高效的代码。无论我们是初学者还是有经验的开发者，了解和掌握这些运算符都是非常重要的。通过合理运用运算符，我们可以更好地利用Python进行编程，并解决实际问题。

Python3中的身份运算符用于判断两个对象的内存地址是否相同，包括"is"和"is not"。身份运算符比较的是对象的内存地址，而不是对象的值。与之不同的是，"=="运算符比较的是对象的值。通过使用身份运算符，可以判断两个对象是否是同一个对象，从而更好地理解和掌握Python中对象的比较和判断。

在实际开发中，如果搞不清楚运算符的优先级，可以使用括号来确保运算的执行顺序。

欢迎关注微信公众号CTO Plus，有问题欢迎后台留言交流。

Python专栏
https://blog.csdn.net/zhouruifu2015/category_5742543

欢迎关注公众号CTO Plus，有问题欢迎后台留言交流。

更多精彩，关注我公号，一起学习、成长

CTO Plus

一个有深度和广度的技术圈，技术总结、分享与交流，我们一起学习。涉及网络安全、C/C++、Python、Go、大前端、云原生、SRE、SDL、DevSecOps、数据库、中间件、FPGA、架构设计等大厂技术。每天早上8点10分准时发文。

306篇原创内容

公众号

标准库系列-推荐阅读：