07-operators-expressions.pd

# 操作符和表达式

你编写的大多数语句（逻辑行）都将包含*表达式*。一个表达式的简单例子是`2+3`。一个表达式可分解成操作符和操作对象。

*操作符* 的功能是做一些事，通过符号，如`+`或特别的关键字表现。操作符需要一些数据来操作，这些数据被你作*操作对象*。在这个例子中`2`和`3`是操作对象。

## 操作对象

我们将简单地看一下操作符和它的用法：

注意，您可以使用交互式解释器计算例子中给出的表达式。例如,为了测试表达式“2 + 3”,使用交互式Python解释器提示符:

~~~python
>>> 2 + 3
5
>>> 3 * 5
15
>>>
~~~

`+` (加号)

:   两个对象相加

    `3 + 5` 得 `8`. `'a' + 'b'` 得 `'ab'`.

`-` (减号)

:   给出一个数减去另一数的差；如果缺少第一个操作数，它默认为是0。

    `-5.2` 得到一个负数，`50 - 24` 得 `26`.

`*` (乘法)

:   给出两个数的乘积或返回重复多次的字符串。

    `2 * 3` 得 `6`. `'la' * 3` 得到 `'lalala'`.

`**` (幂)

:   返回x的y次幂

    `3 ** 4` 得 `81` (也就是`3*3*3*3`)

`/` (除法)

:   用y分x（x除以y）

    `4 / 3` 得`1.3333333333333333`.

`//` (整除)

:   得到除法的商

    `4 // 3` 得 `1`.

`%` (取模)

:   返回除法的余数

    `8 % 3` 得 `2`. `-25.5 % 2.25` 得 `1.5`.

`<<` (向左移位)

:   数字向左移动指定位数。(在内存中每个数字由比特或二进制数表示，例如：0和1）。
    `2 << 2` 得 `8`. `2` 用二进制表示为`10`。

    左移两位得到 `1000`，它表示数字`8`。

`>>` (向右移位)

:   数字向右移动指定位数。

    `11 >> 1` 得 `5`.

    `11` 用二进制表示为`1011`，向右移动1位后得到二进制`101`，表示数字`5`。

`&` (位与)

:   数字的位相与

    `5 & 3`得 `1`。

`|` (位或)

:   数字的位相或

    `5 | 3`得 `7`

`^` (位异或)

:   数字的位相异或

    `5 ^ 3` 得 `6`

`~` (位求反)

:   x的位求反结果为-(x+1)

    `~5` 得 `-6`.

`<` (小于)

:   返回x是否小于y。所有的比较运算符返回`True`或`False`。注意这些名字的大小写。

    `5 &lt; 3` 返回 `False` 而 `3 &lt; 5` 返回 `True`.

    比较运算符可以任意连接：`3 &lt; 5 &lt; 7` 返回 `True`.

`>` (大于)

:  返回x是否大于y

    `5 &gt; 3` 返回 `True`。如果操作对象都是数字，它们首先转换为普通型，否则，将返回`False`。

`<=` (小于等于)

:   返回x是否小于等于y

    `x = 3; y = 6; x &lt;= y` 返回 `True`.

`>=` (大于等于)

:   返回x是否大于等于y

    `x = 4; y = 3; x &gt;= 3` 返回 `True`。

`==` (等于)

:   比较操作对象是否相等

    `x = 2; y = 2; x == y` 返回 `True`.

    `x = 'str'; y = 'stR'; x == y` 返回 `False`.

    `x = 'str'; y = 'str'; x == y` 返回 `True`.

`!=` (不等于)

:   比较操作对象是否不相等

    `x = 2; y = 3; x != y` 返回 `True`.

`not` (逻辑非)

:   如果 x 是 `True`,它返回 `False`。如果 x 是 `False`，它返回 `True`。

    `x = True; not x` 返回 `False`.

`and` (逻辑与)

:   如果x是`False`, `x and y` 返回 `False`，否则它返回y的值。

    `x = False; y = True; x and y` 返回 `False`，因为 x 为假。在这种情况下，Python将不计算y，因为它知道and左边表达式是 `False` ，这意味着整个表达式将为 `False` ，而不论其它值为什么。这叫做求值捷径。

`or` (逻辑或)

:   如果 x 为 `True`, 它返回真，否则它返回y的值。

    `x = True; y = False; x or y` 返回 `True`。求值捷径这也适用。

### 数学操作和赋值的快捷方式

对一个变量进行数学操作是常见的。然后将操作的结果返回给变量，今后，对这样的表达式有一个快捷方式:

你可以把：

~~~python
a = 2
a = a * 3
~~~


写成：

~~~python
a = 2
a *= 3
~~~

注意：将 `var = var operation expression` 写成 `var operation= expression`。

## 运算顺序

如果你有一个表达式如 `2 + 3 * 4`, 是先做加法还是先做乘法呢？我们的高中数学告诉我们，应该先做乘法。这意味着乘法操作符比加法操作符具有更高的优先级。

下面的表给出了Python运算顺序的优先表，从最低（最小约束力）到最高(最高约束力)。 意思是说，在给定的表达式中，Python将在计算表上方列出的对象和表达式之前，首先运算表下方的。

下面的表取自Python参考手册](http://docs.python.org/py3k/reference/expressions.html#summary)，是为了提供完整性。为了显式地指定优先级，更好的做法是使用圆括号组织运算符和操作对象。这可使程序更加可读。详见下面[更改运算顺序](#改变运算顺序)。

`lambda`

:   Lambda表达式

`or`

:   逻辑或

`and`

:  逻辑与

`not x`

:   逻辑非

`in, not in`

:   成员检测

`is, is not`

:   鉴别检测

`<, <=, >, >=, !=, ==`

:  比较

`|`

:   位或

`^`

:   位异或

`&`

:   位与

`<<, >>`

:   移位

`+, -`

:   加和减

`*, /, //, %`

:   乘法，除法，浮点除和余数

`+x, -x`

:   正，负

`~x`

:   按位非

`**`

:   乘方

`x.attribute`

:   属性引用

`x[index]`

:   索引

`x[index1:index2]`

:   切片

`f(arguments ...)`

:   函数调用

`(expressions, ...)`

:  显示 Binding 或元组

`[expressions, ...]`

:   显示列表

`{key:datum, ...}`

:   显示字典

我们没有遇到的操作符将在后面的章节解释。

上表中在同一行列出的操作符具有*相同优先级*。例如，“+”和“-”具有相同的优先级。

## 改变运算顺序

为使表达式更具可读性，我们可以使用圆括号。例如`2 + (3 * 4)` 肯定比需要知道操作符运算优先级的 `2 + 3 * 4` 更容易理解。与其他方面一样，应该合理使用括号不应该冗余(不要过分使用),如`(2 + (3 * 4))`。

使用括号有一个额外的优势——它帮助我们更改运算顺序。例如，如果您想要在一个表达式中加法在乘法之前运算，那么你可以这样写 `(2 + 3) * 4`。

## 结合性

操作符通常从左到右。这意味着具有相同优先级的操作符从左到右的方式计算。例如`2 + 3 + 4`计算为 `(2 + 3) + 4`。一些操作符，像赋值操作符，有从右到左的结合性，即 `a = b = c` 被视为 `a = (b = c)`。

## 表达式

例子 (保存为`expression.py`):

~~~python
length = 5
breadth = 2

area = length * breadth
print('Area is', area)
print('Perimeter is', 2 * (length + breadth))
~~~

输出:

~~~
$ python3 expression.py
Area is 10
Perimeter is 14
~~~

它是如何工作的

矩形的长度和宽度以同样的名字存储在变量中，在表达式的帮助下，我们使用这些计算矩形的面积和周长。我们存储表达式`length * breadth` 的结果在变量area`中，然后使用 `print` 函数打印它。在第二种情况下,在打印函数中我们直接使用表达式 `2 * (length + breadth)` 的值。

同样要注意，Python'完美打印'是如何输出的。即使我们没有在`'Area is'` 和变量`area`,之间指定一个空间，Python为我们得到一个干净漂亮的输出，而且这种方式使用程序的可读性更强(因为我们不需要担心为输入我们在字符串中间使用的空格)。这只是让Python程序员的生活更方便的一个例子。


## 小结

我们已经看到了如何使用操作符，操作对象和表达式——这是任何程序的基石。接下来,我们将看到在使用语句的程序中如何利用这些。