• 概念：运算符是用来执行程序代码的运算，它会针对一个以上的操作项进行运算。例如：3+4，这里面的操作数是3和4，而“+”是运算符。
  • 分类：算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、成员运算符、身份运算符、条件运算符（三目运算符）

    算术运算符

    | + | 加 | | —- | —- | | - | 减 | | | 乘 | | / | 除 | | % | 返回除法余数 | | * | 乘方 | | // | 返回商的整数部分 |
  1. +、-
    1. print(1 + 2)        #3
    2. print(3 + False)        #4 False对应的数值是0，True对应的数值是1
    3. print(‘hello,’ + ‘kugou’)        #hello,kugou 字符串的可以做加法，相当于把两个字符串拼接起来
    4. print(5 - 3)        #2
    5. print(5 - 3.0)    #2.0
    6. print(5 - True)        #4
    7. print(5.4 - 3)        #2.4000000000000004
  • 对于计算中出现浮点数时，那么返回的结果仍为浮点数；此外后面的除法运算中不管被除数与除数是否为浮点型，那么返回的结果必定是浮点型。
  • 有些计算出现的问题并不是Python中的bug，而是因为在计算的过程中计算机需要将数转换为二进制，在计算完成后，又会将结果转为十进制。(如5.4-3)。
  • 解决精度问题的方法，利用内置decimal模块，具体语法是：
    1. from decimal import Decimal        #从decimal模块中导入Decimal类
    区分import decimal，它是导入decimal的模块。利用上面的代码这样再次计算5.4-3，结果如下：
    image.png
    它的数据类别为
    1. print('xiaopang'-'jeans')
    字符串不支持减法，具体错误形式是 TypeError：unsupported operand type(s) for -: ‘str’ and ‘str’
  1. *、/
    1. print(3 * 5)        #15
    2. print('pangge' * 3)        #panggepanggepangge   相当于把字符串多复制了几遍，乘3就是复制三遍
    3. print('xiaopang' * 'pangge')        #报错，字符串间不能相互做乘法
    4. print(6 / 2)        #3.0，除法返回的数值类型是浮点型
    5. print(6 / 0)        #报错，典型的问题是除数不能为零
    6. print('a' / 'b')        #报错，字符串之间不能做除法
    7. print('a' / 2)        #报错，字符串不能和整数型数字相除
  • 第三行 具体的错误形式是 ZeroDivisionError: division by zero
  • 第五行 具体的错误形式是 TypeError：can’t multiply sequence by non-int of type ‘str’
  • 第六行和第七行均报错 错误的形式分别为 TypeError: unsupported operand type(s) for /: ‘str’ and ‘str’ TypeError: unsupported operand type(s) for /: ‘str’ and ‘int’

  1. %

    1. print(10 % 3)        #1
    2. print(-10 % 3)    #2

  2. **、//

    1. print(2 ** 4)        #16.0
    2. print(10 // 3)    #3
    3. print(-10 // 3)    #-4
  • 这里面的取整数是整除并向下取整，可见第2行、第3行程序

利用divmod()函数进行取证取余，它的代码为

  1. divmod(x,y)        #意思是divmod(x,y)-->(x//y,x%y)例如：
  2. print(divmod(10,3))        #(3,1)

赋值运算符

= 赋值运算符 相当于c=a+b（将等式右边的值幅值给变的变量）
+= 加法赋值运算符 c+=a等价于c=c+a
-= 减法赋值运算符 c-=a等价于c=c-a
*= 乘法赋值运算符 c=a等价于c=ca
/= 除法赋值运算符 c/=a等价于c=c/a
%= 取余数赋值运算符 c%=a等价于c=c%a
**= 幂赋值运算符 c=a等价于c=ca
—= 取整数赋值运算符 c/=a等价于c=c//a
  • python中不支持a—、a++的语法

    比较运算符

    | == | 比较两个对象（数据）是否相等 | | —- | —- | | != | 比较值是否不等 | | > | 比较值是否大于 | | < | 比较值是否小于 | | >= | 比较值是否大于等于 | | <= | 比较值是否小于等于 |
  1. print(True == 1)        #True
  2. print(False == 0)        #True
  3. print(3.0 == 3)        #True，比较的是数值大小，区分后面的身份运算符
  5. a = 1
  6. b = 2
  7. print(a != b)        #True
  9. print('2' = 2)        #False
  10. print(3 < 'a')        #报错
  11. print('abc' < 'xyz')        #True
  12. print('ax' < 'xa')        #True
  13. print(3 > 2 > 1)        #True，相当于3 > 2 and 2 > 1
  14. print((3 > 2) > 1)        #False，相当于3 > 2的结果是True，True和1的值是相同的
  • 第10行：整数类型与字符串类型不能相互比较。错误形式是TypeError: ‘<’ not supported between instances of ‘int’ and ‘str’
  • 第11、12行：字符串比较大小是比较其ASCII码值，如果第一个字符能比较出大小，则不看后面，否则接着看后面进行比较，直到比较出结果未为止。
  • python2中的不等于可用<>表示，但在python3被废除了。错误形式：syntaxError: invalid Syntax

    逻辑运算符

    | and | a and b | 逻辑与，两者均为True返回的是Ture，否则是False | | —- | —- | —- | | or | a or b | 逻辑或，两者均为False返回的是False，否则是True | | not | not a | 逻辑非，进行取反操作 |

逻辑与：只要有一个值False，那么返回的值就为False；逻辑或：只要有一个值为True,那么返回的值就为True；逻辑非：not可以对符号右侧的值进行非运算。对于布尔值，非运算会对其进行取反操作。True变False，False变True。具体可看下面的代码块：

  1. a = True
  2. b = True
  3. c = False
  4. d = False
  5. print(a and b)        #True
  6. print(a and c)        #False
  7. print(c and d)        #False
  8. print(a or b)        #True
  9. print(a or c)        #True
  10. print(c or d)        #False
  11. print(not a)        #False
  12. print(not c)        #False

image.png
看下下面的例子：

  1. print(True and '你好')    #‘你好’
  2. print(True or '你好')        #True
  • 与运算是找False 的，如果第一个值为 False，则不看第二个值，打印的结果为 False；否则打印的结果为 True。例如a=1,2,3…都是True
  • 或运算是找 True 的，如果如果第一个值为 True，则不看第二个值，打印的结果为 True；否则打印的结果为 False。例如a=0、””、None、[]及代表空性的值都是False

再例如：

  1. a = 10
  2. b = 20
  3. print(a and b)        #20
  4. print(a or b)        #10
  • 对于上面的非布尔值的与或运算，这种方式也称为懒惰（短路）机制，它不是比较大小，而是因为布尔值导致。

    位运算符(了解)

    | & | 按位与：两者都为1才为1，否则为0 | | —- | —- | | | | 按位或：只有一个为1则为1，否则为0 | | ^ | 按位异或：两者相等则为0，否则为1 |

它们的做法是对数取二进制值进行计算，然后对每一位进行与或非运算，将运算后的结果再转化成十进制。

成员运算符

in 判断某个值是否在指定序列中，在则返回True
not in 判断某个值是否在指定序列中，不在则返回True 
  1. name = 'xiaopang'
  2. lst = ['guan','gai','guo','piao']
  3. print(name in lst)        #False

身份运算符

is 比较的是两个对象是否是同一个对象
is not 比较的是两个对象是否不是同一个对象 
  1. a = [1,2,5]
  2. b = [1,2,5]
  3. print(a is b)        #False

这里面比较的是对象的id，即同一个对象的身份运算符可能不相等，具体可用id(a)与id(b)进行查看；在这里要还和==进行区别，==比较的是值，上面的例子中它返回的是True。

条件运算符

代码块如下：

  1. True_statements if expression else False_statements

上面的代码块意思是：会对if条件进行判断，如果符合条件则执行前面的语句，否则执行后面的语句。
例如比较a=300 b=40 c=100中的最大值
image.png

运算符的优先级

Python帮助文档中有，这里面简单列举

** 指数(最高优先级)
*/ % // 乘 除 取余 整除
+- 加 减
<= < > >= 比较运算符
== != 比较运算符
= %= /= //= -= += = *= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符

注意的是，上表中的优先级是从上到下优先级依次减弱， 同一行优先级相同则按照从左往右进行计算（赋值运算符除外，它是按照从右往左的顺序）。

小练习

  1. 判断 “amy” 是否在[“bob”,”tony”,”Lisa”,”Steven”] 里面，如果在则输出’amy 在逻辑大家庭’，否则输出’amy不在…好难过’。

image.png

  1. ‘ax’<’xa’ 为True 还是False? 为什么?

返回的结构式True，在字符串中第一位比较时发现’a’的ASCII码值要小于’x’的ASCII码值，所以返回的是True。

  1. 以下程序如果输入666执行那个语句?为什么?

    1. temp = input("请输入：")
    2. if temp == "Yes" or "yes":
    3.  print("if执行了！")
    4. else:
    5.  print("else执行了！")

    当输入666时执行的是’if执行了’语句，这里面666对应的布尔值是True，即非空类型，而’YES’ 和 ‘yes’同样是非空类型，布尔值相同，此外or只要有一个是True那么返回的就是True，故返回的是上面的语句。具体可见程序：
    image.png

  2. is 与==的区别?

is和==的区别在于，is比较的是两个变量的内存地址，即id值，可以说明同一个元素的id值可能不同；而==则比较的是两个变量的值是否相等，相等则为True，不等为False。

  1. 用户输入a,b。当a与b都不为0时则输出a与b做商;否则输出a与b 的乘积。
  2. 基于5,使用三目运算符输出a,b较大的数。

image.png