Python基本的操作运算符

页面导航：

英文教程的下载地址
操作运算符的基本概念
算术运算符
比较运算符(关系运算符)
赋值运算符
位运算符
逻辑运算符
成员运算符
对象标识运算符
运算符的优先级

英文教程的下载地址：

    本篇文章是根据英文教程《Python Tutorial》来写的学习笔记。该英文教程的下载地址如下：

    百度盘地址：http://pan.baidu.com/s/1c0eXSQG

    DropBox地址：点此进入DropBox链接

    Google Drive：点此进入Google Drive链接

    这是学习笔记，不是翻译，因此，有些内容，作者会略过。以下记录主要是根据英文教程的第五章来写的。(文章中的部分链接，可能需要通过代理访问!)

操作运算符的基本概念：

    所谓操作运算符，其实就是加减乘除之类的，可以执行某种运算或者是某项操作的符号，例如：4 + 5这个式子中的4和5就是操作数，它们中间的"+"就是加法运算符，加法运算符可以将左右两个操作数相加，并得到相加的结果，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 4+5
9
[40594 refs]
>>> quit()
[18355 refs]
[email protected]:~/Pytest/ch5$

可以看到，4+5得到的结果就是9，另外，上面的[40594 refs]与[18355 refs]是python的调试输出信息，因为作者为了方便使用gdb调试python的C源代码，就编译了一个debug调试版的python，调试版的python就会输出一些额外的调试信息。

如果读者对python的C源代码感兴趣，也想进行调试的话，可以重新编译python(在之前"Python的安装与使用"那篇文章里，介绍过如何通过源代码来编译python)，只不过，重新编译时，configure还需要加入--with-pydebug参数，在python源代码的Misc目录下的SpecialBuilds.txt文件中，也对此进行了说明，可以按照下面的方式进行重新编译：

[email protected]:~/Downloads$ cd Python-2.7.8
[email protected]:~/Downloads/Python-2.7.8$ make clean
[email protected]:~/Downloads/Python-2.7.8$ ./configure --with-pydebug
[email protected]:~/Downloads/Python-2.7.8$ make
[email protected]:~/Downloads/Python-2.7.8$ sudo make install
[sudo] password for zengl: 
[email protected]:~/Downloads/Python-2.7.8$ cd /home/zengl/Pytest/ch5/
[email protected]:~/Pytest/ch5$ gdb python
.......................................
Reading symbols from /usr/local/bin/python...done.
(gdb) set args test.py
(gdb) show args
Argument list to give program being debugged when it is started is "test.py".
(gdb) b main
Breakpoint 1 at 0x8058e5d: file ./Modules/python.c, line 23.
(gdb) r
Starting program: /usr/local/bin/python test.py
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/i386-linux-gnu/libthread_db.so.1".

Breakpoint 1, main (argc=2, argv=0xbffff284) at ./Modules/python.c:23
23		return Py_Main(argc, argv);
(gdb) p argv[1]
$1 = 0xbffff445 "test.py"
(gdb) p argv[0]
$2 = 0xbffff42f "/usr/local/bin/python"
(gdb) c
Continuing.
Line 1 - Value of c is  12
Line 2 - Value of c is  61
Line 3 - Value of c is  49
Line 4 - Value of c is  -61
Line 5 - Value of c is  240
Line 6 - Value of c is  15
[18354 refs]
[Inferior 1 (process 2597) exited normally]
(gdb) q
[email protected]:~/Pytest/ch5$

    上面假设读者已经编译过python了，那么在重新编译之前，只需先make clean清理掉之前编译时所生成的中间文件，接着就可以用./configure --with-pydebug命令生成Makefile文件(由于有--with-pydebug参数，因此Makefile文件里的gcc在编译时会加入-g参数，也就是加入详细的调试信息)，然后，make和make install(需要root权限)就可以编译出调试版的python，并将调试版的python安装到系统中了，最后就可以通过gdb来调试python的C源代码了。

    上面的test.py是测试用的python文件，读者可以自己写些简单的python代码，并保存到test.py文件中，以方便调试python，通过gdb的set args命令，就可以向python传递test.py参数，这样python就会去解析执行test.py文件里的代码。通过一步步调试下去，就可以知道python内部的具体运作原理了。

    其实，非调试版的python也可以使用gdb进行调试，只不过非调试版的python里的机器指令是被优化过的，不利于调试。

    言归正传，除了前面提到过的加减乘除运算符外，python中还有很多其他的运算符，python所支持的操作运算符如下所示：

Arithmetic Operators 加减乘除之类的算术运算符
Comparison (i.e., Relational) Operators 比较运算符，也可以叫做关系运算符
Assignment Operators 赋值运算符
Bitwise Operators 位运算符
Logical Operators 逻辑运算符
Membership Operators 成员运算符
Identity Operators 对象标识运算符

我们下面就对这些运算符逐个进行介绍：

算术运算符：

Python中有如下几个算术运算符：

Operator 运算符	Description 描述
+	加法运算符，将左右两个操作数相加，并返回相加的结果。
-	减法运算符，用左侧操作数减去右侧操作数，并返回相减的结果。
*	乘法运算符，将左右两个操作数相乘，并返回乘法运算的结果。
/	除法运算符，用左侧的操作数除以右侧的操作数。需要注意的是：Python 2.x与Python 3.x中的除法运算的结果，在某些情况下是不一样的，尤其是当两个整数相除时，下面会进行介绍。
%	取余运算符，用左侧操作数除以右侧操作数，并返回除运算后的余数，例如：3%4 得到的结果就会是余数3 。
**	指数运算符，对操作数进行指数运算，例如：2**4 就是计算2的4次方，那么结果就是16 。
//	舍入式除法运算符，它与上面提到的除法运算符的区别在于：无论除运算的结果如何，它始终会将小数部分给舍去掉，只保留整数部分的值。例如5.0/2会得到2.5，但是5.0//2得到的就会是2.0，小数部分会被舍弃掉。

前面的加减运算与乘运算好理解，如下面的例子(为了方便显示，作者会将例子中的[40594 refs]之类的调试信息给去掉)：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+2
3
>>> 3-1
2
>>> 2*3
6
>>> quit()
[email protected]:~/Pytest/ch5$

和数学里的加减法及乘法是一致的，但是除法运算符则有些不同，并且，除法运算符在python 2.x与python 3.x的版本中，表现的也不太一样，先来看下python 2.x的版本中，除运算符的例子：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 5/2
2
>>> 5.0/2
2.5
>>> quit()
[email protected]:~/Pytest/ch5$

可以看到，当除法运算符的左右两个操作数都是整数时，得到的结果就会是整数，如上面的5/2，得到的结果就是整数2(因为是整数类型，因此小数部分就会被舍弃掉)，当有一个操作数是浮点数时，则得到的结果就会是浮点数，如上面的5.0/2，对应的结果为2.5(小数部分也得以保留)。

再来看下python 3.x版本中的例子：

[email protected]:~/Pytest/ch5$ python3.2
Python 3.2.3 (default, Apr 10 2013, 05:29:11) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 5/2
2.5
>>> 5.0/2
2.5
>>> 4/2
2.0
>>> quit()
[email protected]:~/Pytest/ch5$

    在作者的ubuntu系统里自带了一个3.2.3版本的python，可以看到，在python 3.x的版本中，无论除运算符左右两侧的操作数，是整数类型还是浮点数类型，得到的结果，始终是一个浮点数。

    由于除法运算符在python 2.x与python 3.x中的差异，就会在一定程度上造成两个版本的代码的不兼容。

    %(取余运算符)与**(指数运算符)也不难理解，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 5%2
1
>>> 6%7
6
>>> 2**3
8
>>> 2**4
16
>>> 3**2  
9
>>> quit()
[email protected]:~/Pytest/ch5$

5除以2的余数是1，因此上面 5%2 得到的结果就是1，6%7得到6也是同理，2的3次方是8，因此上面 2**3 得到的结果就是8，其他的2**4得到16，及3**2得到9，都是同理。

最后还有一个//(即舍入式除法运算符)，该运算符在python 2与python 3中的表现是一致的，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 5//2
2
>>> 5.0//2
2.0
>>> 4//2
2
>>> 4.0//2
2.0
>>> quit()
[email protected]:~/Pytest/ch5$ python3.2
Python 3.2.3 (default, Apr 10 2013, 05:29:11) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 5//2
2
>>> 5.0//2
2.0
>>> 4//2
2
>>> 4.0//2
2.0
>>> quit()
[email protected]:~/Pytest/ch5$

    可以看到，// 运算符在两个版本中，得到的是一样的结果。无论左右两个操作数是否能整除，得到的结果里都只会保留整数部分，小数部分会被舍弃掉，只不过，当左右两个操作数都是整数时，结果会是整数，当其中有一个操作数是浮点数时，得到的结果则会是浮点数。

比较运算符(关系运算符)：

    在介绍比较运算符之前，需要先介绍下python中Object即对象的概念，在 https://docs.python.org/2/reference/datamodel.html 链接中也可以看到有关对象的基本概念。

    在Python里，所有的数据都可以看作是对象，每个对象都有一个identity(标识值)，一个type(类型)，以及一个value(值)。例如：在程序中使用123这个整数时，python内部就会为它分配一个对象，我们可以通过id函数和type函数来查看到该对象的标识值与类型，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> id(123)
148881756
>>> type(123)
<type 'int'>
>>> quit()
[email protected]:~/Pytest/ch5$

可以看到，123所属对象的id标识值为148881756，这个值其实就是对象在python中的内存地址(至少目前的实现是这么做的)，还可以看到，该对象是int整数类型，value(值)就是数字123。

当我们将123之类的数据赋值给变量时，其实是将对象的引用(也可以看成是对象的内存地址)赋值给变量，从而让变量指向该对象，这样就可以通过变量来访问到对象了，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> id(123)
151097692
>>> a = b = 123
>>> id(a)
151097692
>>> id(b)
151097692
>>> a
123
>>> b
123
>>> quit()
[email protected]:~/Pytest/ch5$

可以看到，整数123所属对象的id值为151097692，在a = b = 123的赋值语句执行后，a与b变量就都指向了id为151097692的同一个对象，这样访问a与访问b时，都会去访问该对象，并将该对象的值123给读取出来。当将变量a设置为另一个数据时，其实只是将变量a指向了该数据所属的对象而已，当某个对象不再被使用时，python就会通过垃圾回收机制将其消除掉。

稍候要介绍的比较运算符，它们在执行比较操作后，会返回True或False的bool(布尔)类型的数据，它们与整数123一样，在python内部都是以对象的形式存在的，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> id(True)
136288896
>>> type(True)
<type 'bool'>
>>> id(False)
136288876
>>> type(False)
<type 'bool'>
>>> quit()
[email protected]:~/Pytest/ch5$

可以看到，True与False都有自己的对象id值，也都属于bool类型，一个对象的类型决定了该对象可以执行哪些操作，例如整数123的对象，其类型为int，那么该对象的值123就可以用于加减乘除的运算，同样，bool类型的对象，也有自己的用途，它们多用于条件判断：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> if(True):
...  print 'yes'
... else:
...  print 'no'
... 
yes
>>> if(False):
...  print 'yes'
... else:
...  print 'no'
... 
no
>>> quit()
[email protected]:~/Pytest/ch5$

当if接收到True的布尔对象时，就会执行if下面的代码块，如上面的print 'yes'语句，当if接收到False的布尔对象时，就不会执行if后面的代码块，转而去执行else后面的代码块了，有关if...else的用法，在以后的章节中会进行介绍。因此，True与False这类布尔类型的对象，可以起到流程控制的作用。

下面我们就来看下比较运算符，比较运算符在执行后，就会返回True或False的对象，python支持的比较运算符如下表所示：

Operator 运算符	Description 描述
==	等于运算符，用于判断左右两个操作数的值是否相等，当相等时返回True，当不相等时则返回False
!=	不等于运算符，用于判断左右两个操作数的值是否不相等，当不相等时则返回True，当相等时则返回False
<>	也是不相等运算符，当两操作数不相等时返回True，相等时返回False，类似于上面的 != 运算符
>	大于运算符，当左操作数的值大于右操作数的值时，则返回True，否则，返回False
<	小于运算符，当左操作数的值小于右操作数的值时，则返回True，否则，返回False
>=	大于等于运算符，当左操作数的值大于或等于右操作数的值时，则返回True，否则，返回False
<=	小于等于运算符，当左操作数的值小于或等于右操作数的值时，则返回True，否则，返回False

这些比较运算符都比较好理解，可以查看下面的例子：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 == 2
True
>>> 2 != 2
False
>>> 3 <> 2
True
>>> 10 > 5
True
>>> 5 < 10
True
>>> 5 >= 10
False
>>> 5 <= 10
True
>>> quit()
[email protected]:~/Pytest/ch5$

这些例子都容易理解，就不多说了。

赋值运算符：

赋值运算符就是将某些数据，或者将计算的结果赋值给变量，确切的说，应该是将这些数据所属对象的引用赋值给变量，Python支持的赋值运算符如下表所示：

Operator 运算符	Description 描述
=	最基本的赋值运算符，用于将右侧表达式的值赋值给左侧的变量。
+=	加赋值运算符，将左右两侧操作数相加，并将相加的结果赋值给左侧操作数。例如：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

需要注意的是，由于赋值运算符的优先级很低(优先级的概念在稍候会提到)，因此，当赋值运算符的右侧，是一个加减乘除之类的表达式的话，则会先计算表达式，再执行赋值运算，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 3
>>> a *= 1 + 2
>>> a
9
>>> quit()
[email protected]:~/Pytest/ch5$

可以看到，a *= 1 + 2这条语句在执行时，会先计算1+2的表达式，再和a执行*=运算，因此，得到的最终结果就是9 。

下面是有关赋值运算符的完整例子：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> c = 3
>>> c 
3
>>> c += 4
>>> c
7
>>> c -= 4
>>> c
3
>>> c *= 3
>>> c
9
>>> c /= 3
>>> c
3
>>> c %= 7
>>> c
3
>>> c **= 3
>>> c
27
>>> c //= 3
>>> c
9
>>> quit()
[email protected]:~/Pytest/ch5$

上面在将变量c赋值为3后，又依次对其他的赋值运算符进行了测试，计算结果与预期的一致。

位运算符：

在计算机中，整数是以二进制的形式进行存储的，要知道一个整数的二进制格式，在python中，可以使用字符串的format方法(当然，也可以使用bin函数将二进制格式以字符串的形式显示出来)：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> '{0:b}'.format(42)
'101010'
>>> bin(42)
'0b101010'
>>> quit()
[email protected]:~/Pytest/ch5$

从上面的输出，可以看到，整数42的二进制格式为：101010，有关format方法的详情，请参考 https://docs.python.org/2/library/string.html#format-examples 该链接，不过，负数的原始二进制格式，是无法直接用上面的方法来显示出来的。

位运算符就是用于对这些0101的二进制位进行操作的运算符，它会对整数的每个二进制位都逐一进行操作，python支持以下几个位运算符(下表中0b开头的表示二进制数，python中支持0b开头的二进制数的运算)：

Operator 运算符	Description 描述
&	按位与运算符，对左右两操作数的所有二进制位都进行按位与运算，即两操作数的相应二进制位上都为1时，结果才为1，但只要有一方为0时，结果就会是0 例如：0b111100 & 0b001101 得到的结果是：001100
\|	按位或运算符，对左右两操作数的所有二进制位都进行按位或运算，即两操作数的相应二进制位上只要有一方为1，那么结果就会是1，当双方都为0时，结果才会是0 例如：0b111100 \| 0b001101 得到的结果是：111101
^	按位异或运算符，对左右两操作数的所有二进制位都进行按位异或运算，即相应二进制位上相同则为0，不同则为1 例如：0b111100 ^ 0b001101 得到的结果是：110001
~	按位取反运算符，将操作数的所有二进制位都进行反转，即0变1，1变0 例如：~0b00111100 得到的结果就是：11000011 即 -61
<<	按位左移运算符，将左侧操作数的所有二进制位根据右操作数的值，进行左移，在左移后，低位用0填充例如：0b111100 << 2 即111100左移两位，得到的结果就会是：11110000
>>	按位右移运算符，将左侧操作数的所有二进制位根据右侧操作数的值，进行右移，在右移后，高位用符号位填充，即如果原来是正数，则用0填充，如果原来是负数，则用1填充，这样就可以保证右移后，整数的正负符号性质不变，因此，python的右移操作属于算术右移。例如：0b111100 >> 2 即111100右移两位，得到的结果就会是：001111

可以在python中，对上表中涉及到的例子一一进行测试：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> '{:06b}'.format(0b111100 & 0b001101) 
'001100'
>>> '{:06b}'.format(0b111100 | 0b001101)
'111101'
>>> '{:06b}'.format(0b111100 ^ 0b001101)
'110001'
>>> ~0b00111100     
-61
>>> '{:08b}'.format(0b111100 << 2)
'11110000'
>>> '{:06b}'.format(0b111100 >> 2)
'001111'
>>> quit()
[email protected]:~/Pytest/ch5$

上面运行的结果，与预期的一致。

另外，按位或运算符，按位与运算符还可以作用于set类型的数据，按位或可以得出两个set的并集，按位与则可以得出两个set的交集，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> {123, 'john'} | {456, 'hello'}
set([456, 'john', 123, 'hello'])
>>> {123, 'john'} & {123, 456}
set([123])
>>> quit()
[email protected]:~/Pytest/ch5$

    可以看到，按位或将两个set里的数据都合并到了一起，按位与则得出了两个set中公共的数据，也就是它们的交集部分。

逻辑运算符：

    之前介绍的比较运算符会产生True或False的布尔类型的对象，当我们需要对两个或者多个布尔对象进行综合判断时，就需要用到逻辑运算符，例如，下面要介绍的and运算符，当and两边的操作数都是True对象时，那么and就会返回True来作为综合判断的结果，当有一方操作数为False时，and就会返回False来作为综合判断的结果，因此，有了逻辑运算符后，条件判断就会变得更加灵活。

    Python中支持以下几个逻辑运算符：

Operator 运算符	Description 描述
and	逻辑与运算符，当左右两操作数都为True时，则返回True，只要有一个操作数为False，则返回False 例1：True and True 结果是：True 例2：True and False 结果是：False 例3：False and True 结果是：False 例4：False and False 结果是：False and的左右两操作数还可以是数字，当为数字时，0等效于False，非0的数则等效于True，只不过此时返回的将是一个数字(当操作数中有布尔对象时，也可能返回布尔对象)，具体例子在下面会给出。
or	逻辑或运算符，当左右两操作数中有一个为True时，结果就会是True，当两操作数都为False时，才返回False 例1：True or False 结果是：True 例2：False or False 结果是：False 与and类似的是，or的左右两操作数也都可以是数字，同样是0等效于False，非0的数等效于True，当为数字时，返回的将是一个数字(当操作数中有布尔对象时，也可能返回布尔对象)。
not	逻辑非运算符，反转布尔对象的值，即True变False，False变True 例1：not True 结果是：False 例2：not False 结果是：True 如果not后面接的是数字，那么0就等效于False，而非0的数则等效于True 例3：not 0 结果是：True 例4：not 123 结果是：False

先看下and运算符的例子：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and True
False
>>> False and False
False
>>> 123 and 0  
0
>>> 0 and 123
0
>>> 0 and 0
0
>>> 123 and 234
234
>>> 123 and True
True
>>> True and 123
123
>>> 123.0 and 123
123
>>> 123 and 123.0
123.0
>>> True and 123.0
123.0
>>> False and 123.0
False
>>> False and 0
False
>>> 0 and False
0
>>> quit()
[email protected]:~/Pytest/ch5$

从上面的输出可以看到，python的逻辑运算符属于懒惰匹配模式，即当and左侧的操作数为0或False时，它就会直接将左侧的操作数作为结果返回，而不会再去判断右侧的操作数了，当左侧的操作数不为0或者为True时，它只好再去判断右侧的操作数，并以右侧的操作数作为最终的结果来返回。这种懒惰模式在很多语言中都存在，例如，C语言的逻辑运算符也是懒惰匹配模式，zengl语言中也是用的懒惰模式，这种模式的好处就在于可以减少不必要的判断，从而在一定程度上加快了执行效率。

or运算符也是懒惰匹配模式，当or左侧的操作数为True或者是非0的数字时，就会直接将左侧的操作数作为结果返回，而不会再去判断右侧的操作数。当or左侧的操作数为0或False时，它只好再去判断右侧的操作数，并以右侧的操作数作为最终的结果来返回。如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> True or False
True
>>> 123 or True
123
>>> False or True
True
>>> 0 or 456
456
>>> 0 or False
False
>>> False or 0
0
>>> quit()
[email protected]:~/Pytest/ch5$

接着，再来看下not运算符的例子：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> not True
False
>>> not False
True
>>> not 0
True
>>> not 123
False
>>> not 123.5 
False
>>> not ''
True
>>> not 'a'
False
>>> quit()
[email protected]:~/Pytest/ch5$

从上面的输出可以看到，空字符串可以看作是False，而‘a’之类的非空字符串则可以看作是True 。

成员运算符：

除了前面介绍的几种运算符外，python中还有一种成员运算符，像list(列表)，tuple(元组)及string(字符串)之类的数据都是包含多个数据元素的集合，而成员运算符就是用于判断某个数据是否存在于这些集合中的。可用的成员运算符，如下表所示：

Operator 运算符	Description 描述
in	如果左侧操作数存在于右侧操作数中，那么就返回True，否则返回False 例如：2 in [1,2,3] 得到的结果就是：True，因为可以在[1,2,3]的列表中找到2，因此2是该列表的成员
not in	如果左侧操作数不存在于右侧操作数中，就返回True，否则返回False 例如：4 not in [1,2,3] 得到的结果就是：True，因为在[1,2,3]列表中找不到4这个数，因此4不是该列表的成员

下面是成员运算符的完整例子：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 in [1,2,3]
True
>>> 4 not in [1,2,3]
True
>>> 'a' in 'abcd'
True
>>> 'e' not in 'abcd'
True
>>> 'e' in 'abcd'
False
>>> (1,3) in [(1,3),123]
True
>>> quit()
[email protected]:~/Pytest/ch5$

对象标识运算符：

在前面介绍比较运算符时，我们提到过：python中的所有数据都是对象，每个对象都有自己的identity(标识值)，这里要介绍的对象标识运算符，就是用来判断两对象的标识值是否相等的，有如下两个标识运算符：

Operator 运算符	Description 描述
is	当左右两操作数所属对象的标识值相等时，即它们属于同一个对象时，就返回True，否则，返回False
is not	当左右两操作数所属对象的标识值不相等时，返回True，否则，返回False

有关标识运算符的例子，如下所示：

[email protected]:~/Pytest/ch5$ python
Python 2.7.8 (default, Dec 10 2014, 22:05:07) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = b = 123
>>> a is b
True
>>> id(a) == id(b)
True
>>> a is not 123.5
True
>>> id(a) != id(123.5)
True
>>> a is 123.5
False
>>> id(a) == id(123.5)
False
>>> quit()
[email protected]:~/Pytest/ch5$

    从上面的例子中，可以看到，a is b相当于id(a) == id(b)，而a is not 123.5则相当于id(a) != id(123.5)，因此，is和is not其实就是判断对象的id值是否相等的简写形式。

运算符的优先级：

    所谓优先级就是指：当多个运算符放在一个表达式中时，哪些运算符先执行，哪些运算符后执行的一个先后顺序，例如：a = 7 + 3 * 2 执行时，会先执行3 * 2的乘法运算，再执行加法运算，最后执行赋值运算，就是因为乘法运算符的优先级高于加法运算符的优先级，而加法运算符的优先级又高于赋值运算符。

    此外，还可以在表达式中使用小括号来改变优先级，小括号中的运算符会优先执行，例如：a = (7 + 3) * 2 执行时，会先执行小括号里的加法运算，再执行括号外的乘法运算，最后执行赋值运算，因此，当记不清运算符的优先级时，可以使用小括号将你需要优先执行的运算给括起来。

    Python中的运算符的优先级，如下表所示(根据从高到低的顺序，即表格顶部的第一项拥有最高优先级，表格底部的最后一项则为优先级最低的运算符)：

Operator 运算符	Description 描述
**	指数运算符
~ + -	取反运算符，正号与负号运算符，这里的+和-表示正号或负号，而不是加减运算符
* / % //	乘、除、取余、舍入除运算符
+ -	加、减运算符
>> <<	按位右移和按位左移运算符
&	按位与运算符
^ \|	按位异或、按位或运算符
<= < > >=	小于等于、小于、大于、大于等于运算符
<> == !=	等于、不等于运算符
= %= /= //= -= += = *=	加赋值，减赋值之类的赋值运算符
is is not	is和is not的对象标识运算符
in not in	in和not in的成员运算符
not or and	逻辑取反、逻辑或、逻辑与运算符

下面是英文教程中，用于测试运算符优先级的简单的例子：

#test.py
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print "Value of (a + b) * c / d is ", e
e = ((a + b) * c) / d # (30 * 15 ) / 5
print "Value of ((a + b) * c) / d is ", e
e = (a + b) * (c / d); # (30) * (15/5)
print "Value of (a + b) * (c / d) is ", e
e = a + (b * c) / d; # 20 + (150/5)
print "Value of a + (b * c) / d is ", e

我们将代码保存到test.py文件中，运行结果如下：

[email protected]:~/Pytest/ch5$ python test.py
Value of (a + b) * c / d is  90
Value of ((a + b) * c) / d is  90
Value of (a + b) * (c / d) is  90
Value of a + (b * c) / d is  50
[email protected]:~/Pytest/ch5$

以上就是python运算符的相关内容。

OK，休息，休息一下 o(∩_∩)o~~

上下篇

下一篇： Python的流程控制语句

上一篇： Python的变量类型

Python基本的操作运算符

zenglong 2014-12-12 09:16:04