运算符和表达式

表达式就是由操作数和运算符组成的一句代码或语句，表达式可以求值，可以放在 = 的右边，用来给变量赋值

举个例子：1+2*3 就是一个表达式，+ 和 * 称为操作符，也叫做运算符，1、2、3 叫做操作数。1+2*3 经过计算后得到的结果是 7 。我们可以将计算结果赋值给变量，result = 1+2*3

算术运算符

Python 提供了完整的算术运算符集，包括用于基本四则数学运算的操作符 +、-、 *、/ 。在操作数都是整数时，+、-、* 等操作符可以分别按正常的加法、减法、乘法进行运算，其中 - 既可以作为单值操作符（否定)，也可以作为二元操作符（减法)。

>>> 5 + 6
11
>>> 3 - 7
-4
>>> 4 * 8
32
>>> -4 - 5
-9
>>> 2**3
8

在 Python 中，与一般程序语言不同的地方在于对除法的处理，除法操作符会产生一个浮点值，而不是一个整数值；很多其他程序设计语言都是产生一个整数值，并剥离掉小数部分。如果需要产生一个整数值结果，我们可以使用 int()进行转换（或使用剥离操作符//)。

>>> 12 / 3
4.0
>>> 5 / 2
2.5
>>> 5//2
2
>>> 5%2
1

可使用 () 来解决优先级的问题时

>>> 1 + 2 * 3
7
>>> ( 1 + 2 ) * 3
9

赋值运算符

除了基本的赋值运算符 = 之外，很多 Python 数据类型还可以使用一些增强的赋值运算符：

>>> num = 2    
>>> num += 1   # 等价于 num = num + 1
>>> num -= 1   # 等价于 num = num - 1
>>> num *= 1   # 等价于 num = num * 1
>>> num /= 1   # 等价于 num = num / 1
>>> num //= 1  # 等价于 num = num // 1
>>> num %= 1   # 等价于 num = num % 1
>>> num **= 2  # 等价于 num = num ** 2

比较运算符

Python 提供了二进制比较操作符的标准集合，这些操作符对对象的值进行比较

运算符	描述	实例
==	等于：比较对象是否相等	(a == b) 返回 False
!=	不等于：比较两个对象是否不相等	(a != b) 返回 True
<>	不等于：比较两个对象是否不相等	(a <> b) 返回 true 这个运算符类似 !=
>	大于：返回x是否大于y	(a > b) 返回 False
<	小于：返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。	(a < b) 返回 True
>=	大于等于：返回x是否大于等于y	(a >= b) 返回 False
<=	小于等于：返回x是否小于等于y	(a <= b) 返回 True

Python 比较操作符的一个特别好用的特性是可以进行结链比较，例如

1
2
3

>>> a = 9
>>> 0 <= a <= 10
True

Python 并不会猜测我们的真正意图，进行无意义的比较会导致异常，出现异常而又未得到处理时，Python 会输出该异常错误消息的回溯与追踪信息。正确的方法是进行明确的转换，使用可比较的类型。例如：

>>> '3' < 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> int('3') < 4
True

身份运算符

在 Python 中，变量实际上都是对象引用，有时我们需要知道两个或更多的对象引用是否都指向相同的对象

is ：如果其左端对象引用与右端的对象引用指向的是同一个对象，则会返回 True，否则返回 False
is not：如果其左端对象引用与右端的对象引用指向的不是同一个对象，则会返回 True，否则返回 False
利用 id() 函数可以取得对象的内存地址

示例
注意： 以下测试情况会在交互模式下出现，在脚本模式中 is 和 == 结果是一样的

>>> a = 2.0
>>> b = 2.0
>>> a is b
False
>>> a == b
True
>>> id(a)
47800288
>>> id(b)
47800224
>>> a = ["Retention", 3, None]
>>> b = ["Retention", 3, None]
>>> a is b
False
>>> a == b
True

Python 中会为每个出现的对象分配内存，哪怕他们的值完全相等，注意这里说的是 字面意义上的值相等，而不是说相同，相同指的是引用的对象是同一个 。上例中，a = 2.0，b = 2.0 这两个语句时会先后为 2.0 这个 float 类型对象分配内存，然后将 a 与 b 分别指向这两个对象。所以 a 与 b 指向的不是同一对象

但是为了提高内存利用效率，对于一些简单的对象，如一些数值较小的 int 对象，python 采取重用对象内存的办法，如 a = 2，b = 2 时，由于 2 作为简单的 int 类型且数值小，Python 不会两次为其分配内存而是只分配一次，然后将 a 与 b 同时指向已分配的对象：

>>> a = 2
>>> b = 2
>>> a is b
True
>>> a == b
True

如但果赋值的不是 2 而是大的数值，情况就跟前面的一样了：

>>> a = 3333
>>> b = 3333
>>> a is b
False
>>> a== b
True

在交互模式下，如果变量写在同一行，将会指向同一个对象

>>> a=3333; b=3333;   # 写在同一行
>>> a is b
True
>>> a == b
True

>>> c = 5555   # 写在不同一行
>>> d = 5555   # 写在不同一行
>>> c is d
False
>>> c == d
True

在 python 脚本中，不管是否是一行都指向同一个对象

# -*- coding: utf-8 -*-

a = 3333; b = 3333
print(a is b)          # true

c = 5555
d = 5555
print(c is d)          # true

总结：

对 int (整型)、str (字符串) 以及很多其他数据类型进行比较是没有意义的，因为几乎绝大多数情况下我们基本上是比较他们的值，而不是比较他们的引用的对象是不是同一个

身份比较的一个好处是速度非常快，这是因为 Python 并不必须对进行比较的对象本身进行检查，is 操作符只需要对对象所在的内存地址进行比较——同样的地址存储的是同样的对象
最常见的情况使用 is 将数据项与内置的空对象 None 进行比较，None 通常用作位置标记值，表示“未知”或“不存在”

>>> a="Something"
>>> b=None
>>> a is not None,b is None
(True, True)

成员运算符

对序列或集合这一类数据类型，比如字符串、列表或元组我们可以使用操作符 in 来测试成员关系，用 not in 来测试非成员关系。例如：

>>> p = (4, "frog", 9, -33, 9, 2)
>>> 2 in p           
True
>>> "dog" not in p
True

对列表与元组，in 操作符使用线性搜索，对非常大的组合类型（包含数万个或更多的数据项)，速度可能会较慢；而对字典或集合，in 操作可以非常快

对字符串数据类型，使用成员运算符可以很方便地测试任意长度的子字符串

>>> phrase = "Wild Swans by Jung Chang"
>>> "J" in phrase
True
>>> "han" in phrase
True

逻辑运算符

Python 提供了 3 个逻辑运算符：and 、or 、 not 。其中 and 与 or 都使用 short-circuit 短路逻辑，并返回决定结果的操作数——而不是返回布尔值（除非实际上就是布尔操作数)

>>> five = 5; two = 2; zero = 0
>>> five and two
2
>>> two and five
5
>>> five and zero
0

如果逻辑表达式本身（例如 if 语句）出现在布尔上下文中，那么结果也为布尔值。因此上面的内容使用了表达式后，返回的结果将变为 True True False

>>> nought = 0
>>> five or two
5
>>> two or five
2
>>> zero or five
5
>>> zero or nought
0

or 操作符是类似的，这里在布尔上下文中，上面的结果应该为 True True True 与 False

>>> not(zero or nought)
True
>>> not two
False

not 单一操作符在布尔上下文中评估其参数，并总是返回布尔型结果