python3中所有的运算符

我们自己了解的运算符包含加、减、乘、除、大于、等于等等。但是python也有运算符吗？python的运算符是否包含上面几种运算，是否还有其他的运算。它们都是如何使用的，请继续往下看，所有的运算为您一一讲解。

运算符包含：算术运算符(上面的加减乘除)、比较(关系)运算符、赋值运算符、逻辑运算符、位运算符、成员运算符、身份运算符、运算优先级，下面先说说算术运算符。

算术运算符

我们在小学的时候都经历过加、减、乘、除，幂等，可能不了解幂是什么意思，这里简单说一下，幂是指乘方运算的结果。一般使用"^"(键盘数字6上的符合)表示,n^m表示m个n相乘，把n^m看作是相乘的结果，也叫n的m次幂，也叫n的m次方。

这里把所有算数运算符都整理了一下，并进行了简短的描述，先假设为变量：wulaoer=27,wolf=-27;

这里把所有算数运算符都整理了一下，并进行了简短的描述，先假设为变量：wulaoer=27,wolf=-27;

运算符	描述	实例
+	加 - 两个对象相加	wulaoer + wolf 输出结果是0
-	减 - 两个对象相减	wulaoer - wolf 输出结果是54
*	乘 - 两个对象相乘	wulaoer * wolf 输出结果是-729
/	除 - 相关对象相除	wulaoer / wolf 输出结果是-1.0
%	取模-返回除法的余数	wulaoer % wolf 输出结果是0
**	幂-返回x的y次方	wulaoer ** wolf 输出结果是2.255165233728459e-39
//	取整除-返回商的整数部分	wulaoer // wolf 输出结果是-1

下面看看整个算术运算的所有例子：

#!/usr/bin/python3
#coding:utf-8
#吴老二个人博客~~~www.wulaoer.or
wulaoer=21
wolf=-10
nums=wulaoer + wolf
print("相加得出的结果：",nums)
nums=wulaoer - wolf
print("相减得出的结果：",nums)
nums=wulaoer * wolf
print("相乘得出的结果：",nums)
nums=wulaoer / wolf
print("相除得出的结果：",nums)
nums=wulaoer % wolf
print("取模得出的结果：",nums)
nums=wulaoer ** wolf
print("幂次方得出的结果：",nums)
nums=wulaoer // wolf

输出结果：

相加得出的结果： 11
相减得出的结果： 31
相乘得出的结果： -210
相除得出的结果： -2.1
取模得出的结果： -9
幂次方得出的结果： 5.995246616608979e-14

这是使用python3的算术运算，这里需要注意，在python2中，相除得出的没有余数，如果想有余数可以把除数换成浮点数(float)或被除数换成浮点数(float)。

>>> 21/10
2
>>> 21.0/10
2.1
>>> 21/float(10)
2.1

我们使用列表合并的时候有用到算术运算，但是只能合并不能拆分或者其他的运算，下面就是相减报错的例子：

TypeError: unsupported operand type(s) for -: 'list' and 'list'

赋值运算符

在数据类型里简单说了一些变量，变量不属于任何数据类型，变量原本没有值，只有赋值之后，才会根据赋的值转变数据类型，如果赋的值是整数，变量就是整数类型，如果是浮点数那就是浮点数类型。前面多多少少都涉及到一些赋值运算，下面详细说一下赋值运算有哪些，以下变量假设w=27,f=-27,：

运算符	描述	实例
=	直接赋值给变量	c=w + f w和f相加结果赋给c，输出结果是0
+=	相加后赋值	w += f(w=w+f) 输出结果是0
-=	相减后赋值	w -= f(w=w-f) 输出结果是54
*=	相乘后赋值	w = f(w=wf) 输出结果是-729
/=	相除后赋值	w /= f(w=w/f) 输出结果是-1
%=	取模后赋值	w %= f(w=w%f) 相除后取余数,结果是:
**=	幂后赋值	w =f(w=wf) f不能是负数，结果是：
//=	取整除赋值	w //=f(w=w//f) 输出结果是-1

下面针对上面的所有赋值运算符做各举一个例子，因为比较多，所以把所有的结果都赋值给同一个变量，如果不这样会把上个赋值结果当作下个赋值的变量值，会影响结果。

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~
wulaoer=27
wolf=-27
w=wulaoer+wolf
print("使用=赋值，w加f的结果赋值给c: c=w+f",w)
w=wulaoer+wolf
print("使用+=赋值,w加f的结果赋值给w: w+=f",w)
w=wulaoer-wolf
print("使用-=赋值,w减f的结果赋值给w: w-=f",w)
w=wulaoer*wolf
print("使用*=赋值,w乘f的结果赋值给w: w*=f",w)
w=wulaoer/wolf
print("使用/=赋值,w除f的结果赋值给w: w/=f",w)
w=wulaoer%wolf
print("使用%=赋值,w除f的余数赋值给w: w%=f",w)

w=5
f=2
w=w**wolf
print("使用**=赋值,w的f次方赋值给w: w **= f",w)
w=wulaoer//wolf
print("使用//=赋值,w整除f的整数赋值给w: w //= f",w)

输出结果：

使用-=赋值,w减f的结果赋值给w: w-=f 54
使用*=赋值,w乘f的结果赋值给w: w*=f -729
使用/=赋值,w除f的结果赋值给w: w/=f -1.0
使用%=赋值,w除f的余数赋值给w: w%=f 0
使用**=赋值,w的f次方赋值给w: w **= f 1.34217728e-19
使用//=赋值,w整除f的整数赋值给w: w //= f -1

如果单独使用可以直接使用a+=b这样的赋值方法，上面是为了不在重复的给变量赋值。

比较运算符

参与算术运算的值假设为变量：wulaoer=27,wolf=-27;

运算符	描述	实例
==	相等 - 两个对象是否相等	(wulaoer == wolf) 返回结果False
!=	不等于 - 两个对象是否不相等	(wulaoer != wolf) 返回结果True
<>	不等于 - 两个对象是否不相等,python3废弃	wulaoer <> wolf 返回结果True,和=！类似
>	大于 - 是否大于	(wulaoer > wolf) 返回结果True
<	小于 - 是否小于	(wulaoer < wolf) 返回结果False
>=	大于等于 - 是否大于等于	(wulaoer >= wolf) 返回结果True
<=	小于等于 - 是否小于等于	(wulaoer <= wolf) 返回结果False

针对比较运算，我们就需要用到判断了，虽然还没有学到判断，不过这里简短提示一些，判断就是要不成立，要不不成立，两种结果。看下面的例子：

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~
wulaoer = 27
if wulaoer == 27:
	print("wulaoer变量的值是:",27)
else:
	print("wulaoer变量的值不是:",27)

输出结果：

wulaoer变量的值是: 27

前面声明了一个变量，变量的值是27，我们判断值是否相等，有两种结果，一个是相等，一个是不相等，第一个条件是成立的，第二个是不成立的。所以上面的结果返回的是"是"。了解了if判断，看下面的比较运算的例子：

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~
wulaoer = 27
wolf = -27
#相等"=="
if wulaoer == wolf:#相等成立
	print("wulaoer变量%d和wolf的变量%d值是相等的" % (wulaoer,wolf))
else:
	print("wulaoer变量%d和wolf的变量%d值是不相等的" % (wulaoer,wolf))
#不相等"!="
if wulaoer != wolf:#不相等
	print("wulaoer变量%d和wolf的变量%d值是不相等的" % (wulaoer,wolf))
else:
	print("wulaoer变量%d和wolf的变量%d值是相等的" % (wulaoer,wolf))
#大于
if wulaoer > wolf:#大于
	print("wulaoer变量%d比wolf的变量%d值大" % (wulaoer,wolf))
else:
	print("wulaoer变量%d比wolf的变量%d值小" % (wulaoer,wolf))

#大于或等于
if wulaoer >= wolf:#大于
	print("wulaoer变量%d比wolf的变量%d值大或相等" % (wulaoer,wolf))
else:
	print("wulaoer变量%d比wolf的变量%d值小或相等" % (wulaoer,wolf))

#小于
if wulaoer < wolf:#小于
	print("wulaoer变量%d比wolf的变量%d值小" % (wulaoer,wolf))
else:
	print("wulaoer变量%d比wolf的变量%d值大" % (wulaoer,wolf))

#小于或等于
if wulaoer <= wolf:#小于
	print("wulaoer变量%d比wolf的变量%d值小或相等" % (wulaoer,wolf))
else:
	print("wulaoer变量%d比wolf的变量%d值大或相等" % (wulaoer,wolf))

输出结果：

wulaoer变量27和wolf的变量-27值是不相等的
wulaoer变量27和wolf的变量-27值是不相等的
wulaoer变量27比wolf的变量-27值大
wulaoer变量27比wolf的变量-27值大或相等
wulaoer变量27比wolf的变量-27值大
wulaoer变量27比wolf的变量-27值大或相等

逻辑运算符

逻辑运算就是针对真假的判断，在判断布尔值的时候True为1，False为0。我们下面会举几个例子看看。先定义两个变量w=27，f=22看下面的描述：

运算符	基本格式	描述	实例
and	w and f	逻辑与，相当于且。w为False,w and f返回False，否则返回f的值(找False的)	w and f ,返回True，22
or	w or f	逻辑或，相当于或，w为True，返回w的值。否则返回f的值	w or f ,返回False
not	not(a and b)	逻辑非，相当于非，有一个为True,not True为False,取反	not(w and f ),返回False

针对逻辑运算的例子：

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~
w=23
f=222
print("逻辑运算且",w and f)
if (w and f):
	print("逻辑运算且:True")
else:
	print("逻辑运算且:False")

print("逻辑运算或",w or f)
if (w or f):
	print("逻辑运算或:True")
else:
	print("逻辑运算或:False")
print("逻辑运算非",not(w and f))
if not(w and f):
	print("逻辑运算非:True")
else:
	print("逻辑运算非:False")

输出结果：

逻辑运算且 222
逻辑运算且:True
逻辑运算或 23
逻辑运算或:True
逻辑运算非 False
逻辑运算非:False

与运算是找False的，如果第一个值为False，则不看第二个值，如果第两个都为True，则返回第二个值。或运算符是找True的，如果第一个值是True，则不看第二个值，如果有一个值是True，则直接返回第一个值，否则返回第二个值。

位运算符

位运算是把整数换算成二进制，根据二进制进行计算。下面先看一下整数转二进制的方法，这里使用到了bin()函数和format()函数。看下面的例子：

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~

wulaoer = bin(123).replace('0b','')
print("整数123转换成二进制:",wulaoer)
wolf = "{0:b}".format(12345)
print("整数123456转换成二进制:",wolf)

输出结果：

整数123转换成二进制: 1111011
整数123456转换成二进制: 11000000111001

我们先了解一下如何使用整数转换成二进制，然后看一下位运算的运算符是如何使用的,申明变量w=27,f=12:

运算符	描述	实例
&	按位与运算符,参与运算的两个值，如果相应的都为1，则结果为1，否则为0	(w & f)输出结果:8，二进制为:1000
		按位或运算符,参与运算的两个值，如果相应的有一个为1时，结果为1
^	按位异或运算符,参与运算的两个值，如果相应的二进制相异时，结果位位1	(w ^ f)输出结果:
~	按位取反运算符,对数据的每个二进制取反，即把1变为0，0变为1，~w类似-w-1	(~w)输出结果：
<<	左移动位运算符,运算数的各二进制全部左移若干位，由"<<"右边的数指定移动位数，高位丢弃，低位补0	w<<2输出结果:
>>	右移动位运算符,把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	w>>2输出结果:

上面我们已经了解了按位运算，下面我们在代码里注释了运算方法，每一个运算都做了二进制转换说明，看下面的例子：

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~
w=27
f=12
print("变量w的二进制:",bin(w).replace('0b',''))
print("变量f的二进制:",bin(f).replace('0b',''))
#按位与运算
#w 11011
#f 01100 对应都为1则为1，否则为0 1000
wulaoer = (w & f)
print("按位与运算结果:", wulaoer)
print("按位与运算结果的二进制:",bin(wulaoer).replace('0b',''))
#按位或运算
#w 11011
#f 01100 对应有一个为1，则为1，否则为0 ,11111
print("变量w的二进制:",bin(w).replace('0b',''))
print("变量f的二进制:",bin(f).replace('0b',''))
wulaoer = (w | f)
print("按位或运算结果:", wulaoer)
print("按位或运算结果的二进制:",bin(wulaoer).replace('0b',''))
#按位异或运算
#w 11011
#f 01100 相同为0，相异为1 ,10111
print("变量w的二进制:",bin(w).replace('0b',''))
print("变量f的二进制:",bin(f).replace('0b',''))
wulaoer = (w ^ f)
print("按位异或运算结果:", wulaoer)
print("按位异或运算结果的二进制:",bin(wulaoer).replace('0b',''))
#按位取反运算
# 11011 高位补1 ,100100
print("变量w的二进制:",bin(w).replace('0b',''))
wulaoer = ( ~w )
print("按位取反运算结果:", wulaoer)
print("按位取反运算结果的二进制:",bin(wulaoer).replace('0b',''))
#按位左移动运算
#  11011
#1101100  高位丢弃，低位补0,1101100
print("变量w的二进制:",bin(w).replace('0b',''))
wulaoer = ( w<<2 )
print("按位左移动运算结果:", wulaoer)
print("按位左移动运算结果的二进制:",bin(wulaoer).replace('0b',''))
#按位右移动运算
#11011
#  110 低位丢弃，高位补0 110
print("变量w的二进制:",bin(w).replace('0b',''))
wulaoer = ( w>>2 )
print("按位右移动运算结果:", wulaoer)
print("按位右移动运算结果的二进制:",bin(wulaoer).replace('0b',''))

输出结果：

变量w的二进制: 11011
变量f的二进制: 1100
按位与运算结果: 8
按位与运算结果的二进制: 1000
变量w的二进制: 11011
变量f的二进制: 1100
按位或运算结果: 31
按位或运算结果的二进制: 11111
变量w的二进制: 11011
变量f的二进制: 1100
按位异或运算结果: 23
按位异或运算结果的二进制: 10111
变量w的二进制: 11011
按位取反运算结果: -28
按位取反运算结果的二进制: -11100
变量w的二进制: 11011
按位左移动运算结果: 108
按位左移动运算结果的二进制: 1101100
变量w的二进制: 11011
按位右移动运算结果: 6
按位右移动运算结果的二进制: 110

这里特别注意，不同位的两个二进制高位使用0进行不充，补充之后，换算起来比较简单。

成员运算符

在没说成员运算之前，我们回顾以下列表或者字符串的时候，我们有使用过for循环，循环时使用的变量'i' in。in就是成员运算，还有一个成员运算是not in。看下面的说明：

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

看下面的代码示例：

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~
wulaoer = ["golong","python3","运维开发","Ruby"]
wolf ="golong"
if (wolf in wulaoer):
	print("列表中有变量golong:",wolf)
else:
	print("列表中没有变量golong:",wolf)

wolf1="wulaoer"
if (wolf1 in wulaoer):
	print("列表中有变量golong:",wolf1)
else:
	print("列表中没有变量golong:",wolf1)

if (wolf1 not in wulaoer):
	print("列表中有变量golong:",wolf1)
else:
	print("列表中没有变量golong:",wolf1)

输出结果：

列表中有变量golong: golong
列表中没有变量golong: wulaoer
列表中有变量golong: wulaoer

成员运算需要结合使用if判断或者for循环，这里简单说一下，下个章节说for循环和if判断。

身份运算符

身份运算是比较两个对象的存储单元，变量只是存储单元的一个标识，主要是变量的值的对比。

运算符	描述	实例
is	is 是判断两个表示符是否引用同一个对象	w is f 类似id(w)=id(f),引用同一个对象返回True，不同的对象返回False
is not	is not是判断两个标识符是不是不引用同一个对象	w is not f，类似id(w) != id(f).如果引用的不是同一个对象返回True，否则返回False

#!/usr/bin/python3
#coding:utf-8
#~~~~~~~~~~~~www.wulaoer.org 吴老二个人博客~~~~~~~
wulaoer = 27
wolf = 27
print(id(wulaoer))
print(id(wolf))

if wulaoer is wolf:
	print("两个对象的Id相同")
else:
	print("两个对象的Id不同")

wulaoer = "www.wulaoer.org"

if wulaoer is not wolf:
	print("两个对象引用的不同的Id")
else:
	print("两个对象引用同一个Id")

输出结果：

1972072272
1972072272
两个对象的Id相同
两个对象引用的不同的Id

针对的是变量值的内存地址是否相同，如果我们把整数换成列表，同一个列表赋值给两个不同的变量名，测试一下会有不一样的结果。

运算优先级

在运算符中，同级的运算是从上到下或者从左到右的顺序。下列是从高到低的注解：

运算符	描述
lambda	Lambda表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in，not in	成员测试
is，is not	同一性测试
<，<=，>，>=，!=，==	比较
|	按位或
^	按位异或
&	按位与
<<，>>	移位
+，-	加法与减法
*，/，%	乘法、除法与取余
+x，-x	正负号
~x	按位翻转
**	指数
x.attribute	属性参考
x[index]	下标
x[index:index]	寻址段
f(arguments...)	函数调用
(experession,...)	绑定或元组显示
[expression,...]	列表显示
{key:datum,...}	字典显示
'expression,...'	字符串转换

这里没有使用括号，括号的有些结大于乘除加减，我们完全可以按照我们小学学的优先级进行计算。这里就不多举例子了，有兴趣的自己试一下。