04. Python语言的核心编程 · 第四章 运算符细解

1. Python3 运算符

1.1 运算符的概念

  运算符用于执行程序代码运算，会针对 一个以上操作数项目 来进行运算。例如：2+3，其操作数是 2 和 3，而运算符则是“+”

1.2 运算符的分类

  算术 运算符
  赋值 运算符
  比较 运算符（关系运算符）
  位  运算符
  身份 运算符
  成员 运算符
  逻辑 运算符
  条件 运算符（三元运算符）

 

2. Python 算术运算符

  加法 运算符 表现形式： +
  减法 运算符 表现形式： -
  乘法 运算符 表现形式： *
  除法 运算符 表现形式： /
  %  取模，求两个数相除的 余数 ；
  //    整除，只会保留计算后的整数位，总会返回一个整型；
  **  幂运算，求一个值的几次幂。
 
  假设：变量a为10，变量b为21。

  Python 所有算数运算符的操作：

a = 21
b = 10
c = 0
 
c = a + b
print ("c 的值为：", c)			# c 的值为： 31
 
c = a - b
print ("c 的值为：", c)			# c 的值为： 11
 
c = a * b
print ("c 的值为：", c)			# c 的值为： 210
 
c = a / b
print ("c 的值为：", c)			# c 的值为： 2.1
 
c = a % b
print ("c 的值为：", c)			# c 的值为： 1
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("c 的值为：", c)			# c 的值为： 8
 
a = 10
b = 5
c = a//b 
print ("c 的值为：", c)			# c 的值为： 2

  

3. Python 赋值运算符

  赋值运算符是算术表达式的 特殊写法。举例说明： x = x + 3 其实是和 x += 3 是一样的。
  赋值运算多运用在 循环函数（while、for） 运算。

    =  
    +=  （x+= 3 相当于 x = x + 3 ）
    -=  （x -= 3 相当于 x= x - 3 ）
    *=  （x *= 3 相当于 x = x* 3 ）
    **=  （x **= 3 相当于 x = x ** 3 ）
    /=  （x /= 3 相当于 x = x/ 3 ）
    //=  （x //= 3 相当于 x = x // 3 ）
    %=  （x %= 3 相当于 x= x % 3 ）
    :=  

  假设：变量a为10，变量b为20：

  Python 所有赋值运算符的操作：

a = 21
b = 10
c = 0
 
c = a + b
print ("c 的值为：", c)			# c 的值为： 31
 
c += a
print ("c 的值为：", c)			# c 的值为： 52
 
c *= a
print ("c 的值为：", c)			# c 的值为： 1092
 
c /= a 
print ("c 的值为：", c)			# c 的值为： 52.0
 
c = 2
c %= a
print ("c 的值为：", c)			# c 的值为： 2
 
c **= a
print ("c 的值为：", c)			# c 的值为： 2097152
 
c //= a
print ("c 的值为：", c)			# c 的值为： 99864

  

4. Python 比较运算符

  比较运算符用来比较两个值之间的关系，总会返回一个布尔值。如果关系成立返回 True，否则返回 False。

    ==  比较两个对象的值 是否相等；
    != 比较两个对象的值 是否不相等；
    >  比较左侧值是否大于右侧值；
    <  比较左侧值是否小于右侧值；
    >=  比较左侧的值是否大于或等于右侧的值；
    <=  比较左侧的值是否小于或等于右侧的值。

  假设：变量a为10，变量b为20：

  Python 所有比较运算符的操作：

a = 21
b = 10
c = 0
 
if ( a == b ):
   print ("a 等于 b")
else:
   print ("a 不等于 b")				# a 不等于 b
 
if ( a != b ):
   print ("a 不等于 b")
else:
   print ("a 等于 b")				# a 不等于 b
 
if ( a < b ):
   print ("a 小于 b")
else:
   print ("a 大于等于 b")			# a 大于等于 b
 
if ( a > b ):
   print ("a 大于 b")
else:
   print ("a 小于等于 b")			# a 大于 b
 
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
   print ("a 小于等于 b")
else:
   print ("a 大于  b")				# a 小于等于 b
 
if ( b >= a ):
   print ("b 大于等于 a")
else:
   print ("b 小于 a")				# b 大于等于 a

  

5. Python 位运算符

  Python 位运算符是把数字看作二进制来进行计算的。Python 中的按位运算法则如下：

  下表中 变量 a 为 60，变量b 为 13 二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

  Python 位运算符：

  Python 所有位运算符的操作：

a = 60         		   # 60 = 0011 1100 
b = 13         		   # 13 = 0000 1101 
c = 0
 
c = a & b;     		   # 12 = 0000 1100
print ("1 - c 的值为：", c)
 
c = a | b;      	  # 61 = 0011 1101 
print ("2 - c 的值为：", c)
 
c = a ^ b;    	      # 49 = 0011 0001
print ("3 - c 的值为：", c)
 
c = ~a;         	  # -61 = 1100 0011
print ("4 - c 的值为：", c)
 
c = a << 2;    	      # 240 = 1111 0000
print ("5 - c 的值为：", c)
 
c = a >> 2;    	      # 15 = 0000 1111
print ("6 - c 的值为：", c)

  

6. Python 身份运算符

  身份运算符用于比较两个对象的存储单元。
  is  比较两个对象 是否是同一个对象，比较的是 对象的id ；
  is not  比较两个对象 是否不是同一个对象，比较的是 对象的id 。
  
  Python 身份运算符：

  注： id() 函数用于获取对象的内存地址。

  Python 所有身份运算符的操作：

a = 20
b = 20
 
if ( a is b ):
   print ("a 和 b 有相同的标识")
else:
   print ("a 和 b 没有相同的标识")		# a 和 b 有相同的标识
 
if ( id(a) == id(b) ):
   print ("a 和 b 有相同的标识")
else:
   print ("a 和 b 没有相同的标识")		# a 和 b 有相同的标识
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("a 和 b 有相同的标识")
else:
   print ("a 和 b 没有相同的标识")		# a 和 b 没有相同的标识
 
if ( a is not b ):
   print ("a 和 b 没有相同的标识")
else:
   print ("a 和 b 有相同的标识")			# a 和 b 没有相同的标识

  

7. Python 成员运算符

  除了以上的一些运算符之外，Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串、列表或元组。

  Python 所有成员运算符的操作：

a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print ("变量 a 在给定的列表中 list 中")
else:
   print ("变量 a 不在给定的列表中 list 中")		# 变量 a 不在给定的列表中 list 中
 
if ( b not in list ):
   print ("变量 b 不在给定的列表中 list 中")
else:
   print ("变量 b 在给定的列表中 list 中")		# 变量 b 不在给定的列表中 list 中
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("变量 a 在给定的列表中 list 中")
else:
   print ("变量 a 不在给定的列表中 list 中")		# 变量 a 在给定的列表中 list 中 

  

8. Python 逻辑运算符

 6.1 not 逻辑非
  not(逻辑非) 可以对符号 右侧 的值进行非运算。对于布尔值，非运算会对其进行取反操作；True 变 False，False 变 True。

 6.2 and 逻辑与
  and(逻辑与) 可以对符号 两侧 的值进行与运算。 只有在 符号两侧 的值 都为 True 时，才会返回 True，只要有一个 False 就返回 False ；
  与运算是 找 False 的，如果第一个值为 False ，则 不再看 第二个值。

 6.3 or 逻辑或
  或运算 两个值中 只要有一个True，就会返回True 。
  或运算 是找True的。

 6.4 非布尔值 的 与或运算
  当我们对非布尔值进行与或运算时，Python 会将其当做布尔值运算，最终会返回原值。

  非布尔值 与运算 的规则：
  与运算是找 False 的，如果第一个值是 False，则不看第二个值。如果第一个值是 False，则直接返回第一个值，否则返回第二个值；

  非布尔值 或运算 的规则：
  或运算是找 True 的，如果第一个值是 True，则不看第二个值。如果第一个值是 True，则直接返回第一个值，否则返回第二个值。

  假设变量 a 为 10，b为 20：

  Python 逻辑运算符的操作：

a = 10
b = 20
 
if ( a and b ):
   print ("变量 a 和 b 都为 True")
else:
   print ("变量 a 和 b 有一个不为 True")		# 变量 a 和 b 都为 True
 
if ( a or b ):
   print ("变量 a 和 b 都为 True，或其中一个变量为 True")
else:
   print ("变量 a 和 b 都不为 True")			# 变量 a 和 b 都为 True，或其中一个变量为 True
 
# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("变量 a 和 b 都为 True")
else:
   print ("变量 a 和 b 有一个不为 True")		# 变量 a 和 b 有一个不为 True
 
if ( a or b ):
   print ("变量 a 和 b 都为 True，或其中一个变量为 True")
else:
   print ("变量 a 和 b 都不为 True")			# 变量 a 和 b 都为 True，或其中一个变量为 True
 
if not( a and b ):
   print ("变量 a 和 b 都为 False，或其中一个变量为 False")
else:
   print ("变量 a 和 b 都为 True")			# 变量 a 和 b 都为 False，或其中一个变量为 False

  

9. Python 条件运算符（三元运算符）

  Python 条件运算的执行模型：

  Python 条件运算的执行过程：

  条件运算符在执行时，会先对条件表达式进行 求值判断，
  如果判断结果为True，则执行 语句1，并返回执行结果；
  如果判断结果为False，则执行 语句2，并返回执行结果；
  语法： 语句1 if 条件表达式 else 语句2 。
  
  Python 中 if 语句的一般形式如下所示：

if condition_1:
    statement_block_1		# 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
elif condition_2:			# 如果 "condition_1" 为False，将判断 "condition_2"
    statement_block_2		# 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
else:
    statement_block_3		# 如果 "condition_2" 为False，将执行"statement_block_3"块语句

  Python 中用 elif 代替了 else if，所以 if 语句的关键字为：if – elif – else。

  注意：
  1、每个条件后面要使用冒号 : ，表示接下来是满足条件后要执行的语句块。
  2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
  3、在Python中没有switch – case语句。

  

10. Python 运算符的优先级

  以下表格列出了从最高到最低优先级的所有运算符：

  运算符优先级详细参照表

  Python 所有运算符优先级的操作：

a = 20
b = 10
c = 15
d = 5
e = 0
 
e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：",  e)			# (a + b) * c / d 运算结果为： 90.0
 
e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：",  e)			# ((a + b) * c) / d 运算结果为： 90.0
 
e = (a + b) * (c / d);    # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：",  e)			# (a + b) * (c / d) 运算结果为： 90.0
 
e = a + (b * c) / d;      #  20 + (150/5)
print ("a + (b * c) / d 运算结果为：",  e)			# a + (b * c) / d 运算结果为： 50.0

  and 拥有更高优先级：

x = True
y = False
z = False
 
if x or y and z:
    print("Yes")
else:
    print("No")				# Yes

  
  
  
  
  

课后作业：

  1. ‘ax’ < ‘xa’ 输出的值为 True 还是 False ？
  2. is 与 == 的区别?
  3. 现在有 a b c 三个变量，三个变量中分别保存有三个数值，请通过条件运算符获取三个值中的最大值。

  
  
  

参考答案：

# 第一题
TRUE				



# 第二题	答案细节详见文章的 4. Python 比较运算符 和 6. Python 身份运算符
比较运算符用来比较两个值之间的关系，总会返回一个布尔值。如果关系成立返回 True，否则返回 False。 

==	比较两个对象的值是否相等	比较的是对象的 value；	

is	比较两个对象的值是否是同一个对象	比较的是对象的 id；

对象被赋的值是可变的，不确定的；对象的id是唯一的，不可变更的。


	
# 第三题(方案一)
a,b,c = 1,2,3		

if a > b :
    if a > c :
        print(a)
    else:
        print(c)
else:
    if b > c :
        print(b)
    else:
        print(c)	# c



# 第三题(方案二)
a = int(input('输入a的值：'))
b = int(input('输入b的值：'))
c = int(input('输入c的值：'))

if a > b:
    if a > c:
        print('输入的 a,b,c 三个值中，最大的值是：a =',a)
    else:
        print('输入的 a,b,c 三个值中，最大的值是：c =',c)
elif b > c:
    print('输入的 a,b,c 三个值中，最大的值是：b =',b)
else:
    print('输入的 a,b,c 三个值中，最大的值是：c =',c)