运算
======================================
在python中，经常用到的运算符有算术运算、关系运算、赋值运算、逻辑运算、成员运算，除此之外还有位运算，但用到的并不多，就不再讲解了

算术运算
--------------------------------------
算术运算就是我们数学上的加(+)、减(-)、乘(*)、除(/)、取模(%)、幂(**)，加减乘比较简单就不再说了

**除**

这里的除比较特别，如果是两个整数相除，得到了是商的整数部分，如::

  In [1]: 5/3
  Out[1]: 1

  In [2]: 5/2
  Out[2]: 2

但是除数与被除数如果其中有一个为小数，得到的就是准确结果::

    In [3]: 5/3.0
    Out[3]: 1.6666666666666667

    In [4]: 5/2.0
    Out[4]: 2.5

    In [5]: 5.0/2.0
    Out[5]: 2.5

所以做运算时，如果需要准确结果，可以把其中一个转为小数::

    In [6]: 5 / float(2)
    Out[6]: 2.5

**取模**

取模就是获取余数部分，例如5除以2，商2余1，取模结果就是1::

    In [7]: 5 % 2
    Out[7]: 1

    In [8]: 5.0 % 2
    Out[8]: 1.0

**幂**

幂就是乘方，如果2的3次幂，即2的3次方，2*2*2::

    In [9]: 2**3
    Out[9]: 8

    In [10]: 10**3
    Out[10]: 1000

关系运算
--------------------------------------
即判断运算符两边的表达式的关系，如大于，小于，不等于，返回布尔类型， ``True`` 或 ``False`` ::

    In [12]: 1 > 2
    Out[12]: False

    In [13]: 1 == 2
    Out[13]: False

    In [14]: 1 < 2
    Out[14]: True

    In [15]: 1 != 2
    Out[15]: True

    In [16]: 1 <= 2
    Out[16]: True

    In [17]: 2 >= 1
    Out[17]: True

逻辑运算
--------------------------------------
逻辑运算就是我们高中数学里的与(and)、或(or)、非(not)，表达式即可以是布尔类型，也可以不是，在python中， **None** 、 **空字符串** 、**空字典** 、**数字0** 在进行逻辑运算时都会被当做 **False**

* 使用与的时候，从左向右运算，如果第一个为假，则返回第一个值，不再进行第二个运算，如果第一个为真，则返回第二个值::

    In [34]: 0 and 1
    Out[34]: 0

    In [35]: 1 and 2
    Out[35]: 2

    In [36]: [] and 1
    Out[36]: []

    In [37]: '' and 1
    Out[37]: ''

* 使用或的时候，第一个为真时，则返回第一个值，不再进行第二个值运算，第一个为假时，返回第二个值::

    In [44]: 1 or 0
    Out[44]: 1

    In [45]: 1 or a
    Out[45]: 1

    In [46]: 0 or 1
    Out[46]: 1

    In [47]: 0 or a
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-47-1585eb30ceed> in <module>()
    ----> 1 0 or a

    NameError: name 'a' is not defined

* 使用非的时候，返回表达式的相反的布尔值::

    In [51]: not True
    Out[51]: False

    In [52]: not False
    Out[52]: True

    In [53]: not 1
    Out[53]: False

    In [54]: not 0
    Out[54]: True

    In [55]: not []
    Out[55]: True

    In [56]: not ''
    Out[56]: True



成员运算
--------------------------------------
判断一个元素是不是在另外一个序列里，序列是指一系列元素，可以是列表、元组、字典以及类似对象，最后返回布尔类型， ``True`` 或 ``False`` ::

    In [26]: 1 in [1, 2]
    Out[26]: True

    In [27]: 3 in [1, 2]
    Out[27]: False

    In [28]: 3 not in [1, 2]
    Out[28]: True

    In [29]: 'a' in {'a': 1}
    Out[29]: True