运算符

算术运算符

算术运算符也即数学运算符，用来对数字进行数学运算，比如加减乘除。下表列出了 Python (opens new window) 支持所有基本算术运算符。

常用算数运算符的优先级： -> * -> / // % -> + -**

x = 2 ** 2 - 1 * 2
print(x)

赋值运算符

赋值运算符用来把右侧的值传递给左侧的变量（或者常量）

可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。

赋值运算符：=

复合运算符：+= -= *= /=

关系比较：== != >= <=

"""
赋值运算符用来把右侧的值传递给左侧的变量（或者常量）
可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。
"""

x = 1
x += 1  # x = x + 1
print(x)

x **= 2  # x = x**2
print(x)

连续赋值

Python 中的赋值表达式也是有值的，它的值就是被赋的那个值，或者说是左侧变量的值；如果将赋值表达式的值再赋值给另外一个变量，这就构成了连续赋值。请看下面的例子：

a = b = c = 100

具有右结合性，我们从右到左分析这个表达式：

• c = 100 表示将 100 赋值给 c，所以 c 的值是 100；同时，c = 100 这个子表达式的值也是 100。
• b = c = 100 表示将 c = 100 的值赋给 b，因此 b 的值也是 100。
• 以此类推，a 的值也是 100。

最终结果就是，a、b、c 三个变量的值都是 100。

= 和 ==

= 和 == 是两个不同的运算符，= 用来赋值，而 == 用来判断两边的值是否相等，千万不要混淆。

逻辑运算

运算顺序：() => not => and => or

逻辑运算符的本质

以下两点极其重要，了解这两点不会让你在使用逻辑运算的过程中产生疑惑。

• 第一点：and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。(计算一边)
• 第二点：另外，如果同时计算了两边的值，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。(计算两边) 计算二边直接返回后面表达式的值

第一点：

对于 and 运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以 Python 按照下面的规则执行 and 运算：

• 如果左边表达式的值为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时 and 会把左边表达式的值作为最终结果。
• 如果左边表达式的值为真，那么最终值是不能确定的，and 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。

对于 or 运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个值为真，那么最终结果就是真，所以 Python 按照下面的规则执行 or 运算：

• 如果左边表达式的值为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时 or 会把左边表达式的值作为最终结果。
• 如果左边表达式的值为假，那么最终值是不能确定的，or 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。

第二点：

如果同时计算两边的值，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果

"""
运算顺序：() => not => and => or

重点注意:
    - 第一点：and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。
        and
            如果左边表达式的值为假，那么就不用计算右边表达式的值了
            如果左边表达式的值为真，那么最终值是不能确定的，and 会继续计算右边表达式的值
        or
            如果左边表达式的值为真，那么就不用计算右边表达式的值了
            如果左边表达式的值为假，那么最终值是不能确定的，or 会继续计算右边表达式的值
    - 第二点：如果同时计算了两边的值，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。
        计算二边直接返回后面表达式的值
"""

# 基础用法
print(True and True)
print(True and False)
print(True or False)
print(False or False)
print(not False)

print('*'*50)

# 重点注意 第一点(只计算一边)
print(0 > 1 and print("bbb"))  # False
print(0 < 1 and print("bbb"))  # bbb None
print(0 < 1 or print("xxx"))  # True
print(0 > 1 or True)  # True

print('*'*50)

# 重点注意 第二点(计算两边)

print(0 < 1 or "xxx")  # 计算一边（or:前面为True不走后面）True
print(0 > 1 or "xxx")  # 计算二边（or:前面为False,需要计算后面） xxx ，返回xxx不是True和False
print(0 or 0.0)  # 计算二边直接返回后面表达式的值

print(0 < 1 and "xxx")  # 计算二边（and:前面为True,需要计算后面）xxx，返回xxx不是True和False
print(0 > 1 and "xxx")  # 计算一边（and:前面为False，直接就为False） False
print("xxx1" and "xxx")  # 计算二边直接返回后面表达式的值

"""
True
False
True
False
True
**************************************************
False
bbb
None
True
True
**************************************************
True
xxx
0.0
xxx
False
xxx

"""

位运算符

Python位运算符详解 (opens new window)

位运算按照数据在内存中的二进制位（Bit）进行操作，Python 位运算符只能用来操作整数类型，它按照整数在内存中的二进制形式进行计算。

比如
1 等于二进制 00000001 
2 等于二进制 00000010

比较运算符

比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）。

True 和 False 都是 bool 类型，它们专门用来表示一件事情的真假，或者一个表达式是否成立，我们将在《Python bool布尔类型 (opens new window)》中详细讲解。

print("89是否大于100：", 89 > 100)
print("24*5是否大于等于76：", 24*5 >= 76)
print("86.5是否等于86.5：", 86.5 == 86.5)
print("34是否等于34.0：", 34 == 34.0)
print("False是否小于True：", False < True)
print("True是否等于True：", True < True)

"""
89是否大于100： False
24*5是否大于等于76： True
86.5是否等于86.5： True
34是否等于34.0： True
False是否小于True： True
True是否等于True： False
"""

== 和 is 的区别

== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象

# == 和 is 的区别
# == 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象

import time  # 引入time模块

t1 = time.gmtime()  # gmtime()用来获取当前时间
t2 = time.gmtime()
print(t1)
print(t2)
print(t1 == t2)  # 输出True
print(t1 is t2)  # 输出False
"""
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=4, tm_hour=6, tm_min=31, tm_sec=4, tm_wday=3, tm_yday=124, tm_isdst=0)
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=4, tm_hour=6, tm_min=31, tm_sec=4, tm_wday=3, tm_yday=124, tm_isdst=0)
True
False
"""

time 模块的 gmtime() 方法用来获取当前的系统时间，精确到秒级，因为程序运行非常快

成员及身份运算

成员运算符：in、not in (在其中，不在其中)

身份运算符：is 、is not(是，或者不是)

"""
**成员运算符**：in、not in (在其中，不在其中)

**身份运算符**：is 、is not(是，或者不是)

"""

print(2 in [1,2,3])

if 21 not in [1,2,3]:
    print("不在其中")

if "2" is "2":
    print("是")

print("2" is not "xxzza2")

三目运算符（三元运算符）

我们从一个具体的例子切入本节内容。假设现在有两个数字，我们希望获得其中较大的一个，那么可以使用 if else 语句，例如：

if a>b:
    max = a;
else:
    max = b;

但是 python 提供了一种更加简洁的写法，如下所示：

max = a if a>b else b

前面的语句 max = a if a>b else b 的含义是：

• 如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；
• 如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。

三目运算符的嵌套

Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：

a if a>b else c if c>d else d

应该理解为：

a if a>b else ( c if c>d else d )

a = 2
b = 3
if a > b:
    max = a
else:
    max = b

print(max)

"""
- 如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；
- 如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。
"""
# 优化
max = a if a > b else b
print(max)

print("*" * 50)

# 三目运算符的嵌套
c = 2
d = 3
x = a if a > b else c if c > d else d
print(x)

# 理解为
print(a if a > b else (c if c > d else d))

"""
3
3
**************************************************
3
3
"""

运算符优先级

所谓优先级，就是当多个运算符同时出现在一个表达式中时，先执行哪个运算符。

例如 对于表达式 a + b * c ，Python 会先计算乘法再计算加法；

运算符结合性

所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性

例如对于表达式 100 / 25 * 16 , / 和 * 的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/ *都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。

Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有 ** 乘方运算符、单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。表 1 中列出了所有 Python 运算符的结合性。