2022-Python基础运算符

Python语言支持以下类型的运算符:
算术运算符
运算符"+" 代表 “加 – 两个对象相加 ”
运算符"-" 代表 “ 减 – 两个对象相减 ”
运算符"*" 代表 “ 乘 – 两个对象相乘 ”
运算符"/" 代表 “ 乘 – 两个对象相除 ”
运算符"%" 代表 “ 取模 - 返回除法的余数 ”
运算符"**" 代表 “ 幂 - 返回x的y次幂 ”
运算符"//" 代表 “ 取整除 - 向下取接近商的整数 ”
下面用例子来展示一下：

a = 10
b = 12
c = 0
c = a + b
print ("1 - c 的值为：", c)
c = b - a
print ("2 - c 的值为：", c)
c = a * b
print ("3 - c 的值为：", c)
c = a / b
print ("4 - c 的值为：", c)
c = a % b
print ("5 - c 的值为：", c)
c = a ** b
print ("6 - c 的值为：", c)
c = a // b
print ("7 - c 的值为：", c)

输出：

1 - c 的值为： 22
2 - c 的值为： 2
3 - c 的值为： 120
4 - c 的值为： 0.8333333333333334
5 - c 的值为： 10
6 - c 的值为： 1000000000000
7 - c 的值为： 0

比较（关系）运算符
比较运算符又叫关系运算符，比如：
运算符 “==“ 的意思是” 等于 – 比较对象是否相等“
运算符 “!=“ 的意思是” 不等于 - 比较两个对象是否不相等 “
运算符 “>“ 的意思是” 大于 - 返回x是否大于y “
运算符 “<“ 的意思是” 小于 - 返回x是否小于y “
运算符 “>= “ 的意思是” 小于 - 返回x是否小于y “
运算符 “<= “ 的意思是” 小于等于 - 返回x是否小于等于y “
需要注意的是：所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价，注意，这些变量名的大写。
下面用例子来展示一下：

#比较运算符
a = 10
b = 5
c = 0
#判断变量a、b是不是相等
if (a == b):
    print("1 - a 等于 b")
else:
    print("1 - a 不等于 b")
#判断变量a、b是不是不相等
if (a != b):
    print("2 - a 不等于 b")
else:
    print("2 - a 等于 b")
#判断变量a是不是小于b
if (a < b):
    print("3 - a 小于 b")
else:
    print("3 - a 大于等于 b")
#判断变量a是不是大于b
if (a > b):
    print("4 - a 大于 b")
else:
    print("4 - a 小于等于 b")

# 修改变量 a 和 b 的值
a = 20
b = 50
if (a <= b):
    print("5 - a 小于等于 b")
else:
    print("5 - a 大于  b")

if (b >= a):
    print("6 - b 大于等于 a")
else:
    print("6 - b 小于 a")

输出：

1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a

赋值运算符
最简单的就是比如a = b 就是将b的值赋给a
运算符 “=” , 就是简单的赋值运算符 ,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
最后一种是Python3.8版本新增的运算符，海象运算符，可在表达式内部为变量赋值

#赋值运算符
a = 50
b = 30
c = 0
#将a+b的值赋值给c
c = a + b
print("1 - c 的值为：", c)
#将a+c的值赋值给c
c += a
print("2 - c 的值为：", c)
#将a*c的值赋值给c
c *= a
print("3 - c 的值为：", c)
#将c除以a的值赋值给c
c /= a
print("4 - c 的值为：", c)
#取c%a的模赋值给c
c = 2
c %= a
print("5 - c 的值为：", c)
#取c**a的值赋值给c
c **= a
print("6 - c 的值为：", c)
#取c整除a的值赋值给c
c //= a
print("7 - c 的值为：", c)
#将c-a的差赋值给c
c -= a
print("8 - c 的值为：",c)

输出：

1 - c 的值为： 80
2 - c 的值为： 130
3 - c 的值为： 6500
4 - c 的值为： 130.0
5 - c 的值为： 2
6 - c 的值为： 1125899906842624
7 - c 的值为： 22517998136852
8 - c 的值为： 22517998136802

逻辑运算符
逻辑运算符就是判断返回值的布尔类型是True或是False
布尔–“与”–运算符”and“的逻辑运算符x and y
布尔–”或“–运算符”or“的逻辑运算符x or y
布尔–”not“–运算符”not“的逻辑运算符x not y

a = 50
b = 100

if (a and b):
    print("1 - 变量 a 和 b 都为 true")
else:
    print("1 - 变量 a 和 b 有一个不为 true")

if (a or b):
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值
a = 0
if (a and b):
    print("3 - 变量 a 和 b 都为 true")
else:
    print("3 - 变量 a 和 b 有一个不为 true")

if (a or b):
    print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("4 - 变量 a 和 b 都不为 true")

if not (a and b):
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")

输出：

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

位运算符
位运算符就是将数字看成二进制来进行计算
"&"按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
“|” 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1
"^"按位异或运算符：当两对应的二进位相异时，结果为1
"~"按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1
"<<“左移动运算符：运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0
">>“右移动运算符：把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数
以下实例演示了Python所有位运算符的操作：

a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0

c = a & b  # 12 = 0000 1100
print("1 - c 的值为：", c)

c = a | b  # 61 = 0011 1101
print("2 - c 的值为：", c)

c = a ^ b  # 49 = 0011 0001
print("3 - c 的值为：", c)

c = ~a  # -61 = 1100 0011
print("4 - c 的值为：", c)

c = a << 2  # 240 = 1111 0000
print("5 - c 的值为：", c)

c = a >> 2  # 15 = 0000 1111
print("6 - c 的值为：", c)

输出：

1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15

成员运算符
Python还支持成员运算符，包含了一系列的成员，包括字符串，列表或元组
in 如果在指定的序列中找到值返回 True，否则返回 False, x 在 y 序列中 , 如果 x 在 y 序列中返回 True
not in 如果在指定的序列中没有找到值返回 True，否则返回 False,x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True
以下实例演示了Python所有成员运算符的操作：

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

输出：

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中

身份运算符
身份运算符主要是用于比较两个对象的存储单元
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False

a = 50
b = 10

if (a is b):
    print("1 - a 和 b 有相同的标识")
else:
    print("1 - a 和 b 没有相同的标识")

if (id(a) == id(b)):
    print("2 - a 和 b 有相同的标识")
else:
    print("2 - a 和 b 没有相同的标识")

# 修改变量 b 的值
b = 30
if (a is b):
    print("3 - a 和 b 有相同的标识")
else:
    print("3 - a 和 b 没有相同的标识")

if (a is not b):
    print("4 - a 和 b 没有相同的标识")
else:
    print("4 - a 和 b 有相同的标识")

输出：

1 - a 和 b 没有相同的标识
2 - a 和 b 没有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

运算符优先级
运输优先级由高到低：
(expressions…),[expressions…], {key: value…}, {expressions…}圆括号的表达式

x[index], x[index:index], x(arguments…), (x.attribute 读取，切片，调用，属性引用)

await x (await 表达式)

** (乘方(指数))

+x, -x, ~x (正，负，按位非 NOT)

*, @, /, //, % (乘，矩阵乘，除，整除，取余)

+, - (加和减)

<<, >> (移位)

& (按位与 AND)

^ (按位异或 XOR)

| (按位或 OR)

in,not in, is,is not, <, <=, >, >=, !=, == (比较运算，包括成员检测和标识号检测)

not x (逻辑非 NOT)

and (逻辑与 AND)

or (逻辑或 OR)

if – else (条件表达式)

lambda lambda (表达式)

:= (赋值表达式)
以下实例演示了Python所有运算符优先级的操作：

a = 40
b = 10
c = 15
d = 5
e = 0

e = (a + b) * c / d  # ( 50 * 15 ) / 5
print("(a + b) * c / d 运算结果为：", e)

e = ((a + b) * c) / d  # (50 * 15 ) / 5
print("((a + b) * c) / d 运算结果为：", e)

e = (a + b) * (c / d)  # (50) * (15/5)
print("(a + b) * (c / d) 运算结果为：", e)

e = a + (b * c) / d  # 20 + (150/5)
print("a + (b * c) / d 运算结果为：", e)

输出：

(a + b) * c / d 运算结果为： 150.0
((a + b) * c) / d 运算结果为： 150.0
(a + b) * (c / d) 运算结果为： 150.0
a + (b * c) / d 运算结果为： 70.0

and运算符具有更高的优先级：

x = True
y = False
z = False

if x or y and z:
    print("yes")
else:
    print("no")

输出：

yes