什么是运算符
运算符是用于进行各种运算操作的符号或关键词。
在数学和计算机编程中，运算符被用来表示不同的运算操作，例如加法、减法、乘法、除法等。
比如:
4 + 5，其中，4和5为操作数，+为运算符。a = 10， 其中，a和10为操作数，=为运算符。print(), 其中，print为操作数，()为运算符。
Python 中提供了丰富的运算符，通过这些运算符可以在开过程中实现复杂的逻辑计算。
Python 语言常用运算符如下:
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 成员运算符
- 身份运算符
- 运算符优先级
这些运算符，根据使用操作数的不同，可分为：
- 单目运算符
- 双目运算符
- 三目运算符
在每一门语言中，运算符都是非常简单，但是非常重要，非常难以熟练掌握和灵活应用的知识点。
算术运算符
在编写程序时，可以使用算术运算符来进行基本的数学计算。
Python 中的算术运算符包括加法、减法、乘法、除法、取模和幂运算
| 运算符 | 描述 |
|---|---|
+ | 加法 ： 两个操作数相加 |
- | 减法 ： 两个操作数相减 |
* | 乘法 ： 两个操作数相乘 |
/ | 除法 ： 两个操作数相除，结果为浮点数类型 |
% | 取模 ： 也称为求余运算符， 两个操作相除，取余数为计算结果 |
** | 幂运算 ：返回 x 的 y 次幂 |
// | 整除 ： 两个操作数相除，取商，结果为整数类型 |
加法运算符 +
加法运算符用于将两个数相加。
例如，a + b 表示将 a 和 b 相加的结果。 如果 a 和 b 都是数字，则加法运算符将执行数学加法操作。 如果 a 和 b 是字符串，则加法运算符将执行字符串连接操作。
a = 10
b = 20
c = a + b
print("a + b 的值为：", c)
s1 = "hello"
s2 = "Sinocare"
res = s1 + s2
print("字符串拼接结果为：", res)
减法运算符 -
减法运算符用于将一个数减去另一个数。例如，a - b 表示将 b 从 a 中减去的结果。
a = 10
b = 20
c = a - b
print("a - b 的值为：", c)
乘法运算符 *
乘法运算符用于将两个数相乘。例如，a * b 表示将 a 和 b 相乘的结果。
a = 10
b = 20
c = a * b
print("a * b 的值为：", c)
除法运算符 /
除法运算符用于将一个数除以另一个数。例如，a / b 表示将 a 除以 b 的结果。需要注意的是，如果除数为 0，将会抛出异常。
在Python中，使用 / 进行除法运算时，会得到一个浮点数，如果需要整除运算需要使用 // 整除运算符
a = 10
b = 20
c = b / a
print("b / a 的值为：", c)
取模运算符 %
取模运算符用于获取两个数相除的余数。例如，a % b 表示将 a 除以 b 的余数。
需要注意的是，取模运算本质上也是除法运算，如果除数为 0，将会抛出异常。
a = 10
b = 20
c = b % a
print("b % a 的值为：", c)
幂运算符**
幂运算符用于获取一个数的指数幂。例如，a ** b 表示将 a 的 b 次方。
a = 2
b = 10
c = a ** b
print("a ** b 的值为：", c)
整除运算符 //
整除运算符用于将一个数除以另一个数，该运算符会得到一个整数的商。
需要注意的是，如果除数为 0，也将会抛出异常。
a = 10
b = 20
c = b // a
print("b // a 的值为：", c)for example:
def clac_info():
# 加法 +
print(1 + 2)
print(10 + 200)
print("Hello" + "World")
print("Hello" + str(1))
# 减法 -
print(20 - 19)
print(10 - 12)
# 乘法 *
print(2 * 3)
print(100 * 20)
print("Hello" * 3)
print(3 * "Hello")
# 除法 /
print(8 / 2)
print(9 / 2)
# print(1 /0)
# 取模 （求余）
print(8 % 2)
print(9 % 2)
n = int(input("请输入任意数字:"))
print(n % 10 + 1)
# 整除 //
print(8 // 2)
print(9 // 2)
print(7 // 2)
# 幂运算符 **
print(2 ** 10)
print(2 ** 11)
print(2 ** 225)
clac_info()
赋值运算符
赋值运算符是使用 = 做为运算符号，将运算符右侧的数据或表达式的结果，保存到运算符左侧的标识符中。
在使用赋值运算符时，运算符右侧可以是任意类型的数据，但左侧必须是一个变量，否则会报错。
除普通的赋值运算符外，赋值运算符还可以和算术运算符组合成为复合赋值运算符。
Python 中提供的赋值运算符如下表所示：
| 运算符 | 描述 | 实例 |
|---|---|---|
= | 简单的赋值运算符 |c = a + b将a + b的运算结果赋值为c` | ||
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
%= | 取模赋值运算符 | c %= a 等效于 c = c % a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
普通赋值运算符 =
将等号左侧的数据保存到等号右侧的变量中
a = 1
s = "Hello"
sum = 1 + 2
赋值运算符还支持同时定义多个变量
a, b, c = 1, 2, 3
print(a, b, c)
复合赋值运算符 +=
+= 运算符是算术运算符 + 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。
表达式会将等号左侧变量中的数据与等号右侧的值进行加法计算，然后将计算结果重新保存到等号左侧的变量中。
a = 10
a += 20 # 相当于表达式 a = a + 20
print(a)
复合赋值运算符 -=
-= 运算符是算术运算符 - 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。
表达式会将等号左侧变量中的数据与等号右侧的值进行减法计算，然后将计算结果重新保存到等号左侧的变量中。
a = 10
a -= 20 # 相当于表达式 a = a - 20
print(a)
复合赋值运算符 *=
*= 运算符是算术运算符 * 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。
表达式会将等号左侧变量中的数据与等号右侧的值进行乘法计算，然后将计算结果重新保存到等号左侧的变量中。
a = 10
a *= 20 # 相当于表达式 a = a * 20
print(a)
复合赋值运算符 /=
/= 运算符是算术运算符 / 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。
表达式会将等号左侧变量中的数据与等号右侧的值进行除法计算，然后将计算结果重新保存到等号左侧的变量中。
a = 10
a /= 20 # 相当于表达式 a = a / 20
print(a)
复合赋值运算符 //=
//= 运算符是算术运算符 // 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。
表达式会将等号左侧变量中的数据与等号右侧的值进行整除计算，然后将计算结果重新保存到等号左侧的变量中。
a = 10
a //= 20 # 相当于表达式 a = a // 20
print(a)
复合赋值运算符 %=
%= 运算符是算术运算符 % 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。
表达式会将等号左侧变量中的数据与等号右侧的值进行取模计算，然后将计算结果重新保存到等号左侧的变量中。
a = 10
a %= 20 # 相当于表达式 a = a % 20
print(a)
复合赋值运算符 **=
**= 运算符是算术运算符 ** 与 赋值运算符 = 的组合形式，用来简化计算赋值操作。
表达式会将等号左侧变量中的数据与等号右侧的值进行幂运算，然后将计算结果重新保存到等号左侧的变量中。
a = 10
a **= 20 # 相当于表达式 a = a ** 20
print(a)
复合赋值运算符使用注意
当使用复合赋值运算符时，计算过程上看似对运算符进行展开后运算，而实际执行过程中，复合赋值运算符并不会进行展开操作。
特别是复合赋值运算符和其它运算符一起使用时，要特别注意。
n = 2
# 该表达式结果为 14， 并不是10
# 如果一定要展开，可以理解展开后为 n = n * ( 3 + 4)
n *= 3 + 4
print(n)for example:
# 赋值运算符
def ass_info():
# 赋值运算符 =
num = 2 + 3 * 5
print(num)
# 同时定义多个变量
a, b, c, d = 1, 2, 3333, 44
print(a, b, c, d)
# 复合赋值运算符
# 加法赋值运算符（+=）
num = 10
num += 20 # num=num +20
print(num)
# 减法赋值运算符（-=）
num = 10
num -= 20 # num=num -20
print(num)
# 幂赋值运算符（**=）
num = 10
num **= 20
print(num)
# 取整除赋值运算符（//=）
num = 10
num //= 20 # num=num //20
print(num)
# 乘法赋值运算符（*=）
num = 2
num *= 3 + 4 # num = 2*（3 +4） 算术和赋值运算符混合时，算术运算符优先级高于赋值运算符
print(num)
# 除法赋值运算符（/=)
num = 9
num /= 20
print(num)
ass_info()
关系运算符
关系运算符也称为比较运算符，用来对参与运算的两个操作数进行比较，确认两个操作数之间的关系，运算结果会返回一个布尔值
Python 中提供的关系运算符如下表所示：
| 运算符 | 描述 |
|---|---|
== | 等于 ： 比较对象是否相等 |
!= | 不等于 ： 比较两个对象是否不相等 |
> | 大于 ： 返回 x 是否大于 y |
< | 小于 ： 返回 x 是否小于 y |
>= | 大于等于 ： 返回 x 是否大于等于 y。 |
<= | 小于等于 ： 返回 x 是否小于等于 y。 |
等于 ==
== 用来判断两个操作数是否相同，如果相同，结果为真 True，如果不同，结果为假 False。
print( 1 == 2)
print( 1 == 1)
print( 1 == "2")
print( 2 == "2")
print( "abc" == "abc")
print( "abc" == "ABC")
不等于 !=
!= 用来判断两个操作数是否不同，如果不同，结果为真 True，如果相同，结果为假 False。
print( 1 != 2)
print( 1 != 1)
print( 1 != "2")
print( 2 != "2")
print( "abc" != "abc")
print( "abc" != "ABC")
大于 >
> 用来判断左操作数是否大于右操作数，如果大于，结果为真 True，否则，结果为假 False。
print( 1 > 2)
print( 1 > 1)
print( 1 > "2")
print( 2 > "2")
print( "abc" > "abc")
print( "abc" > "ABC")
小于 <
< 用来判断左操作数是否小于右操作数，如果小于，结果为真 True，否则，结果为假 False。
print( 1 < 2)
print( 1 < 1)
print( 1 < "2")
print( 2 < "2")
print( "abc" < "abc")
print( "abc" < "ABC")
大于等于 >=
>= 用来判断左操作数是否大于或等于右操作数，如果大于或等于，结果为真 True，否则，结果为假 False。
print( 1 >= 2)
print( 1 >= 1)
print( 1 >= "2")
print( 2 >= "2")
print( "abc" >= "abc")
print( "abc" >= "ABC")
小于等于 <=
<= 用来判断左操作数是否小于或等于右操作数，如果小于或等于，结果为真 True，否则，结果为假 False。
print( 1 <= 2)
print( 1 <= 1)
print( 1 <= "2")
print( 2 <= "2")
print( "abc" <= "abc")
print( "abc" <= "ABC")for example:
# 关系比较运算符
def rela_info():
# 等于 ==
print(1 == 1) # True
print(1 == 2) # False
print(1 == "1") # False
print(1 == "2") # False
print("abc" == "abc") # True
print("abc" == "ABC") # False
# 不等于 !=
print(1 != 1) # False
print(1 != 2) # True
print(1 != "1") # True
print(1 != "2") # True
print("abc" != "abc") # False
print("abc" != "ABC") # True
# 大于 >
print(1 > 2) # False
print(1 > 1) # False
print(1 > 0) # True
print("a" > "A") # True
print("abc" > "ABC") # True
print("aBC" > " Abed ") # True
# print(1 > "a") # True 不支持数值和字符串比较
# 大于等于 >=
print(1 >= 1)
print(1 >= 0)
print(1 >= 2)
# 小于
print(1 < 1)
print(1 < 2)
# 小于等于 <=
print(1 <= 1)
print(1 <= 0)
print(1 <= 2)
rela_info()
逻辑运算符
逻辑运算符一般用来解决当有多个关系条件需要判断时使用，用来确定这些条件组合的方式，运算结果为布尔类型值。
Python 中提供的逻辑运算符如下表所示：
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
and | x and y | 逻辑"与" ： 如果 x 为 False，x and y 返回 False，否则它返回 y的计算值。 |
or | x or y | 逻辑"或" ： 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。 |
not | not x | 逻辑"非" ： 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 |
逻辑与运算符 and
逻辑与运算符用来连接多个关系条件运算，只有当多个条件同时满足时，结果为真 True，否则为假 False
print(3 > 2 and 2 > 1)
print(3 < 2 and 2 > 1)
print(3 < 2 and 2 < 1)
print(1 < 2 and "H" + "W")
逻辑或运算符 or
逻辑或运算符用来连接多个关系条件运算，只有当多个条件同时不满足时，结果为假 False，只要其中有一个条件为真，结果即为真 True
print(3 > 2 or 2 > 1)
print(3 < 2 or 2 > 1)
print(3 < 2 or 2 < 1)
print(1 > 2 and "H" + "w")
逻辑非运算符 not
逻辑非运算符用来对表达式结果进行取反运算，如果表达式结果为真，则取反结果为假 False，如果表达式结果为假，则结果即为真 True
print(not (3 > 2))
print(not (3 < 2))
短路特性
在使用 逻辑与 运算符和 逻辑或 运算符时，如果自左向右计算结果可以确定整个表达式的结果时，后面的表达式条件便不在计算。
非短路操作
result = True and print("Hello, World!1") # 第一个操作数为True，不能确定后续都为真，所以print语句会执行
print(result) # 输出 None，print语句的返回值为None
result = False or print("Hello, World!2") # 第一个操作数为False，不能确定后续都为假，所以print语句会执行
print(result) # 输出 None，print语句的返回值为None
短路操作
result = False and 1/0 # 第一个操作数为False，已经可以确认整个表达式的结果，虽然表达式有除0错误，但并不会执行
print(result) # 结果为False
result = True or 1/0 # 第一个操作数为True，已经可以确认整个表达式的结果，虽然表达式有除0错误，但并不会执行
print(result) # 结果为True成员运算符
Python 提供了成员运算符，用于判断实例中是否包含了一系列的成员，包括字符串，列表或元组。
如下表所示：
| 运算符 | 描述 |
|---|---|
in | 如果在指定的序列中找到值返回 True，否则返回 False。 |
not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 |
成员运算符 in
如果被查询成员在目标中存在，结果为真 True，如果不存在，结果为假 False
print("o" in "sinocare")
print("K" in "sinocare")
print(0 in [1,2,3,4,5])
print(3 in [1,2,3,4,5])
成员运算符 not in
如果被查询成员在目标中不存在，结果为真 True，如果存在，结果为假 False
print("o" not in "Sinocare")
print("K" not in "Sinocare")
print(0 not in [1,2,3,4,5])
print(3 not in [1,2,3,4,5])
身份运算符
Python 中的身份运算符用来判断两个对象的引用是否为同一个，换言之，就是用来比较两个对象的内存地址是否相同。
Python 对数字和字符串做了一些优化以提高性能和减少内存开销。以下是 Python 对数字和字符串做的一些优化：
-
整数池（Integer Pool）：Python 会在程序运行时预先创建一些整数对象，并将其保存在整数池中。这样，在创建整数对象时，可以重用已存在的对象，而不是创建新的对象。这在一定程度上减少了内存开销。
-
字符串池（String Pool）：对于较短的字符串，Python 会使用字符串池进行优化。字符串池是一个缓存区，保存着所有共享相同内容的字符串对象。当创建新的字符串对象时，Python 会首先检查是否已经存在相同内容的字符串对象，如果存在，则直接重用已有的对象，避免重复创建新的对象。
因此，在某些情况下，字面量相同的两个对象，实际并不是同一个对象，此时如果需要区分对象的话，就需要使用身份运算符。
身份运算符如下表所示：
| 运算符 | 描述 |
|---|---|
is | is 是判断两个标识符是不是引用自一个对象 |
is not | is not 是判断两个标识符是不是引用自不同对象 |
身份运算符 is
is 用来判断两个对象内存引用地址是否相同，如果相同，结果为真 True，如果不相同，结果为假 False
# 示例 1
str1 = "Hello"
str2 = "Hello"
print(id(str1)) # 输出第一个字符串对象的内存地址
print(id(str2)) # 输出第二个字符串对象的内存地址
print(str1 == str2)
print(str1 is str2)
# 示例 2
str3 = "Hello, World!" * 1000
str4 = "Hello, World!" * 1000
print(id(str3)) # 输出第一个字符串对象的内存地址
print(id(str4)) # 输出第二个字符串对象的内存地址
print(str3 == str4)
print(str3 is str4)
注意：两个字面量相同的对象，内存地址未必相同，就像两个双胞胎，长的相同，但是是两个独立的个体。
身份运算符 is not
is not 用来判断两个对象内存引用地址是否不同，如果不同，结果为真 True，如果相同，结果为假 False
# 示例 1
str1 = "Hello"
str2 = "Hello"
print(id(str1)) # 输出第一个字符串对象的内存地址
print(id(str2)) # 输出第二个字符串对象的内存地址
print(str1 == str2)
print(str1 is not str2)
# 示例 2
str3 = "Hello, World!" * 1000
str4 = "Hello, World!" * 1000
print(id(str3)) # 输出第一个字符串对象的内存地址
print(id(str4)) # 输出第二个字符串对象的内存地址
print(str3 == str4)
print(str3 is not str4)
is 和 == 的区别
在 Python 中，万物皆对象，而对象的三个基本要素:
- 内存地址
- 数据类型
- 值
而 is 与 == 都作为常用的判断语句去进行使用，这两者之间的主要区别是：
==运算符: 只比较两个对象的值，相同返回True，不同返回False。is运算符: 比较两个对象的地址引用，相同返回True，不同返回False。
在这种场景下， 两个判断的执行结果均为 True。
a, b = 1,1
# 判断a，b 是否相等
print(a == b)
print(a is b)
在这种场景下， 两个判断的执行结果不一致。
a = [1,2,3]
b = [1,2,3]
# 对比值一致，返回True
print(a == b)
# 对比内存地址不一致，返回False
print(a is b)for example:
# 身份运算符
def ident_info():
# s1 = "hello"
# s2 = "hello"
# print("s1:",id(s1))
# print("s2:",id(s2))
# print(s1 == s2)
# print(s1 is s2)
s1 = "hello , world!!!" * 1000
s2 = "hello, world!!!" * 1000
print("s1:", id(s1))
print("s2:", id(s2))
print(s1 == s2)
print(s1 is s2)
s1 = "hello"
s2 = "hello"
print("s1:", id(s1))
print("s2:", id(s2))
print(s1 == s2)
print(s1 is not s2)
a = [1, 2, 3]
b = [1, 2, 3]
# 对比值一致，返回True
print(a == b)
# 对比内存地址不一致，返回False
print(a is b)
ident_info()
三目运算符
三目运算符也称为三元运算符，是指运算符在使用时，需要有三个操作数参与计算。
Python 中也提供三目运算符，但语法上与传统的三目运算符并不相同。
可以将 Python 中的三目运算符理解成是 if-else 分支语句的简化单行模式
语法格式： [on_true] if [expression] else [on_false]
on_true: 条件为真时的结果on_false: 条件为假时的结果expression: 判断条件
Python 会先判断 expression 条件表达式的结果：
- 如果条件为真，则结果为
[on_true]的值 - 如果条件为假，则结果为
[on_false]的值
print("Yes" if True else "No")
print("Yes" if False else "No")
实际开发过程中，不建议使用三目运算符，相比较 if-else 结构的分支语句，三目运算符的可读性不高。
for example:
# 三目运算符
def ternary_operator():
# 其他语言的格式
age = 10
# result = age >= 18 ? "成年" : "未成年"
result = "成年" if age >= 18 else "未成年"
print(result)
ternary_operator()
运算符优先级
Python 中的运算符非常丰富，但在使用过程中除了需要注意各自的特性外，不同的运算符也具有不同的优先级别。
Python 运算符优先级如下表所示：
| 运算符 | 描述 |
|---|---|
| (expressions...) | 绑定或加圆括号的表达式 |
| [expressions...]， {key: value...}， {expressions...} | 列表显示，字典显示，集合显示 |
| x[index]， x[index:index]， x(arguments...)， x.attribute | 抽取，切片，调用，属性引用 |
| ** | 乘方 |
| +x， -x | 正，负 |
| *， @， /， //， % | 乘，矩阵乘，除，整除，取余 |
| +， - | 加和减 |
| in， not in， is， is not， <， <=， >， >=， !=， == | 比较运算，包括成员检测和标识号检测 |
| not | 逻辑非 |
| and | 逻辑与 |
| or | 逻辑或 |
| if -- else | 条件表达式 |
| =， +=， -=， *=， /=， //=， **= | 赋值表达式 |
注意：
因为位运算在后期课程使用过程中使用场景非常少，所以在本课程中并没有讲解（不代表在其它场景中不会使用）。
小技巧：
如果在使用运算符的过程中，不能很好的掌握其优先级顺序，最简单的办法就是在需要先计算的表达式上加括号
print((2+3)*5)for example:
# 运算符优先级
def priority():
# 左结合性
result = 1 + 2 + 3 + 4 + 5
print(result)
# 右结合性
a = b = c = d = 10
print(a, b, c, d)
# 改变优先级
result = (1 + 2) * 3
print(result)
# 关系运算高于逻辑运算符
result = (1 + 2) * 5 > (0 and 6) < (10 or 3) < 1 and 7 + 2
print(result)
priority()
1555
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
