python运算符

Python支持以下类型的运算符：

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符

真值表

算术运算符

表格内假设变量a为10、变量b为3

运算符	描述	实例
+	加--两个对象相加	a+b输出结果为13
-	减--得到负数或一个数减去另一个数	a-b输出结果为7
*	乘--两个数相乘或返回一个被重复若干次的字符串	a*b输出结果为30
/	除--两个数相除	a/b输出结果为3.3333333333333335
%	取模--返回除法的余数	a%b输出结果为1
**	幂--返回a的y次幂	a**b输出结果为a的b次方=1000
//	整除--返回除法的商	a//b输出结果为3

实例：

#!/usr/bin/env python
# coding=utf-8

a = 10
b = 3
c = 0

c = a + b
print("1 - c 的值为：", c)

c = a - b
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 的值为： 13
2 - c 的值为： 7
3 - c 的值为： 30
4 - c 的值为： 3.3333333333333335
5 - c 的值为： 1
6 - c 的值为： 1000
7 - c 的值为： 3

比较运算符

下表中的变量a为30、变量b为26

运算符	描述	实例
==	等于--比较对象是否相等	（ a == b ）返回False
!=	不等于--比较两个对象是否不相等	（ a != b ）返回True
>	大于--比较一个对象是否大于另一个对象	（ a > b ）返回True
<	小于--比较一个对象是否小于另一个对象	（ a < b ）返回False
>=	大于等于--比较一个对象是否大于或等于另一个对象	（ a >= b ）返回True
<=	小于等于--比较一个对象是否小于或等于另一个对象	（ a <= b ）返回False

实例：

#!/usr/bin/env python
# coding=utf-8

a = 30
b = 26

if a == b:
    print("1 - a 等于 b")
else:
    print("1 - a 不等于 b")

if a != b:
    print("2 - a 不等于 b")
else:
    print("2 - a 等于 b")

if a < b:
    print("3 - a 小于 b")
else:
    print("3 - a 大于等于 b")

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

if a <= b:
    print("5 - a 小于等于 b")
else:
    print("5 - a 大于  b")

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

实例结果：

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

赋值运算符

下表中的变量a为10、变量b为3

运算符	描述	实例
=	赋值运算符	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 ** a
//=	取商赋值运算符	c //= a ：等效于c = c // a

实例：

#!/usr/bin/env python
# coding=utf-8

a = 3
b = 10

c = a + b
print("1 - c 的值为：", c)

c = 20

c += a
print("2 - c 的值为：", c)

c = 20

c *= a
print("3 - c 的值为：", c)

c = 20

c /= a
print("4 - c 的值为：", c)

c = 20

c %= a
print("5 - c 的值为：", c)

c = 20

c **= a
print("6 - c 的值为：", c)

c = 20

c //= a
print("7 - c 的值为：", c)

实例结果：

1 - c 的值为： 13
2 - c 的值为： 23
3 - c 的值为： 60
4 - c 的值为： 6.666666666666667
5 - c 的值为： 2
6 - c 的值为： 8000
7 - c 的值为： 6

位运算符

位运算符是把数字看做二进制来进行计算的

下表中的变量a为60、变量b为13

运算符	描述	实例
&	按位与运算符--参加运算的两个值，如果两个相应为都为1，则该位的结果为1，否则为0	（ a & b ）输出结果为12
|	按位或运算符--只要两个对应的二进制位有一个为1时，结果位就为1	（ a | b ）输出结果为61
^	按位异或运算符--当两个对应的二进制位相异时，结果位为1	（ a ^ b ）输出结果位49
~	按位取反运算符--将二进制数+1之后乘以-1	（ ~ a ）输出记过为-61、（ ~ b ）输出结果位-14
<<	按位左移运算符--运算数的各个二进制位向左移动若干位，由“<<”右边的数字指定移动的位数，高位丢弃，低位补0	（ a << 2 ）输出结果为240 （ b << 2 ）输出结果为52
>>	按位右移运算符--运算数的各个二进制位向右移动若干位，由“>>”右边的数字指定移动的位数，	（ a >> 2 ）输出结果为15 （ b >> 2 ）输出结果为3

实例：

#!/usr/bin/env python
# coding=utf-8

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

c = a & b
# 60 = 0011 1100
# 13 = 0000 1101
# 按位与运算得到：0000 1100，换算为十进制：2**2 + 2**3=12
print("1 - c 的值为：", c)

c = a | b
# 60 = 0011 1100
# 13 = 0000 1101
# 按位或运算得到：0011 1101，换算为十进制：2**0 + 2**2 + 2**3 + 2**4 + 2**5 = 61
print("2 - c 的值为：", c)

c = a ^ b  # 49 = 0011 0001
# 60 = 0011 1100
# 13 = 0000 1101
# 按位异或运算得到：0011 0001，换算位为十进制：2**0 + 2**4 + 2**5 = 49
print("3 - c 的值为：", c)

c = ~a
# 60 = 0011 1100
# 按位取反运算得到：-0011 1101，换算为十进制：-（2**0 = 2**2 + 2**3 + 2**4 + 2**5）= -61
print("4 - c 的值为：", c)

c = a << 2
# 60 = 0011 1100
# 按位左移运算得到：1111 0000，换算为十进制：2**4 + 2**5 + 2**6 + 2**7 = 240
print("5 - c 的值为：", c)

c = a >> 2
# 60 = 0011 1100
# 按位左移运算得到：0000 1111，换算为十进制：2**0 + 2**1 + 2**2 + 2**3 = 15
print("6 - c 的值为：", c)

c = b>> 2
# 13 = 0000 1101
# 按位左移运算得到：0000 0011，换算为十进制：2**0 + 2**1 = 3
print("7 - c 的值为：", c)

实例结果：

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

逻辑运算符

运算符	逻辑表达式	描述
and	x and y	逻辑“与”运算符--如果x、y都为真，则返回True，否则返回False
or	x or y	逻辑“或”运算符—如果x、y有一个为真，则返回True，否则返回False
not	not x	逻辑“非”运算符--如果x为真，则返回False，否则返回True

实例：

#!/usr/bin/env python
# coding=utf-8

a = True
b = False


print(a and b)
print(a or b)
print(not a)
print(not b)

实例结果：

False
True
False
True

成员运算符

运算符	描述
in	判断在值是否在指定的序列中，是则返回True，否则返回False
not in	判断在值是否不在指定的序列中，是则返回True，否则返回False

实例：

#!/usr/bin/env python
# coding=utf-8

a = 10
b = 4
list1 = [1, 2, 3, 4, 5]

if a in list1:
    print("1 - 变量 a 在给定的列表中 list 中")
else:
    print("1 - 变量 a 不在给定的列表中 list 中")

if b not in list1:
    print("2 - 变量 b 不在给定的列表中 list 中")
else:
    print("2 - 变量 b 在给定的列表中 list 中")

# 修改变量 a 的值
a = 2
if a in list1:
    print("3 - 变量 a 在给定的列表中 list 中")
else:
    print("3 - 变量 a 不在给定的列表中 list 中")

实例结果：

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

身份运算符

运算符	描述
is	is--判断两个标识符是不是引用自同一个对象
is not	is not--判断两个标识符是不是引用自不同的对象

实例：

#!/usr/bin/env python
# coding=utf-8

a = 20
b = 20

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 没有相同的标识

运算符优先级

下表中从上到下的优先级为从高到低

运算符	描述
'string'	字符串转换
{key:value,…}	字典
[string1,string2,…]	列表
（string1,string2,…）	元组
function（string,…）	函数调用
x[index:index]	切片
x[index]	下表索引取值
x.attribute	属性引用
x**y	幂
~x	按位翻转
+x、-x	正、负
*、/、%、//	乘、除、取余、取商
+ 、-	加号、减号
>>、<<	按位右移、按位左移
&	按位与
^、|	按位异或、按位或
>、<、>=、<=、!=、==	大于、小于、大于等于、小于等于、不等于、等于
=、+=、-=、*=、**=、/=、%=、//=	赋值运算符
is、is not	身份运算符
in、not in	成员运算符
not、or、and	逻辑运算符
lambda	Lambda表达式

真值表

对象/常量	值
""	假
'string'	真
0	假
>=1	真
<=-1	真
()空元组	假
[]空列表	假
{}空字典	假
None	假