python笔记（4）运算符

目录

算数运算符

比较运算符

赋值运算符

位运算符

逻辑运算符

 成员运算符

 身份运算符

运算符优先级

---

算数运算符

a=21
b=10
print(a+b)#加法
print(a-b)#减法
print(a*b)#乘法
print(a/b)#除法
print(a%b)#取余
print(a**b)#指数
print(a//b)#整除
运算结果：
31
11
210
2.1
1
16679880978201
2

比较运算符

a=21
b=10
print(a==b)#等于
print(a!=b)#不等于
print(a>b)#大于
print(a<b)#小于
print(a>=b)#大于等于
print(a<=b)#小于等于
运算结果为：
False
True
True
False
True
False

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。

注意：True和False的首字母为大写。

赋值运算符

运算符	描述	讲解
=	赋值	c=10
+=	加法赋值	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 为 60，b 为 13。

	按位与运算（a&b）	按位或运算(a|b)	按位异或（a^b）
a（60）的二进制表示	0011 1100	0011 1100	0011 1100
b（13）的二进制表示	0000 1101	0000 1101	0000 1101
运算结果	0000 1100	0011 1101	0011 0001
结果的十进制表示	12	61	49

	按位取反（~a）	左移（a<<2）	右移(a>>2)
a（60）的二进制表示	0011 1100	0011 1100	0011 1100
运算结果	1100 0011	1111 0000	0000 1111
运算结果的十进制表示	-61	240	15

注：关于原码，补码和反码：
原码：假设机器字长为n，原码就是用一个n位的二进制数，其中最高位为符号位：正数是0，负数是1。剩下的表示概数的绝对值，位数如果不够就用0补全。
反码：在原码的基础上， 符号位不变其他位取反，也就是就是0变1，1变0。
补码：在反码的基础上加1。  
PS：正数的原、反、补码都一样，0的原码跟反码都有两个，因为这里0被分为+0和-0。
按位取反和反码有一定的相似之处但又不尽相同（反码符号位不取反）。
在计算机中，是以补码的形式存放数据的。1100 0011刚好对应-61。
-61的原码->  1011 1101->反码->1100 0010->补码->1100 0011

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为  1,则该位的结果为 1,否则为 0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为 1 时，结果位就为 1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异（不同）时，结果为 1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把 1 变为 0，把 0 变为 1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补 0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

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中，and 是一个逻辑运算符，用于对两个布尔表达式进行逻辑“与”操作。当使用 and 连接两个表达式时，它遵循以下规则：

1. 短路求值：Python从左到右依次评估两边的表达式。
2. 条件判断：如果左侧表达式的值为 False，则整个 and 表达式的值即为 False，且不再计算右侧表达式（因为无论右侧如何，整个结果都已经是 False）。
3. 真值测试：如果左侧表达式的值为 True，则继续计算右侧表达式。整个 and 表达式的值取决于右侧表达式的值。如果右侧也为 True，则整个 and 表达式的值为 True；否则为 False。

对于数值类型的变量如整数 a 和 b，在进行逻辑运算时，它们会被隐式地转换为布尔值。在Python中，非零数值（包括正数和负数）被视为 True，而零被视为 False。

所以假设a=10,b=20

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

 成员运算符

除了以上的一些运算符之外，Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

a='aafsdfsgdsgerwr'
b=[1,2,3,45,6,7,8,9,0]
c={'a':1,'b':2,'c':3}
d=(1,2,3,4,5,6,7,8,9,0)
print('f' in a )
print(1 not in b)
print('a' in c)
print(10 in d)
运算结果为：
True
False
True
False

 身份运算符

身份运算符比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 如果 id(x) 等于 id(y) , is 返回结果 True
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 True

a='dfs'
b='dfs'
c=['dfs',1,23,'gg']
d=c[0]
print(a is b)
print( c is d)
运算结果：
True
False

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
(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 所有运算符优先级的操作：

#!/usr/bin/python3
#coding=utf-8
a = 20
b = 10
c = 15
d = 5
e = 0

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

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

e = (a + b) * (c / d);    # (30) * (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 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0