Python基础语法系列6-运算符

运算符

Python支持的数据类型有: 算术运算符、关系运算符、逻辑运算符、成员运算符、身份运算符、位运算符和赋值运算符

1 算术运算符

算术运算符有: + - * / % // **

• + - 加；求两个对象的和

  >>> 10 + 20
  30
  >>> a = 100
  >>> b = 20
  >>> a + b
  120
  

• - - 减；得到负数或是一个数减去另一个数

  >>> 10 - 20
  -10
  >>> a = 100; b = 20
  >>> a - b
  80
  

• ***** - 乘；两个数相乘

  >>> 10 * 20
  >>> 200
  >>> a = 100; b = 20
  >>> a * b
  400
  

• / - 除；两个数相除，求商

  注意: 不管除数和被除数是整型还是浮点型，商都是浮点型

  >>> 10 / 20
  0.5
  >>> type(4/2)
  <class 'float'>
  >>> a = 5; b = 2
  >>> a / b
  2.5
  

• % - 取模；返回除法的余数

  a = 5 % 2
  print('a的值:', a)
  b = 10 % 4
  print('b的值:', b)
  

  结果:

  a的值: 1
  b的值: 2
  

  取模的应用1：根据判断对2取模的结果是否为0来判断整数的奇偶性

  num = 21
  if num % 2 == 0:
      print(num, '是偶数')
  else:
      print(num, '是奇数')
      
  # 上面的实例还可以根据数字转换成布尔时，0会转换成False,其他整数会转换成True,简写成:
  num = 22
  if num % 2:
      print(num, '是奇数')
  else:
      print(num, '是偶数')
  

  结果:

  21 是奇数
  22 是偶数
  

  取模应用2：通过判断一个数对另一个数取模的结果是否为0来判断一个数是否能够被另外一个数整除

  # 判断输入是数字是否能被3整除
  num = int(input('请输入一个整数:'))
  if num % 3 == 0:
      print(num, '能被3整除')
  else:
      print(num, '不能被3整除')
  

  结果:

  请输入一个整数:21
  21能被3整除
  

  取模应用3：取低位数

  # 输出输入的整数的个位数
  num = int(input('请输入一个整数:'))
  print(num, '的个位数是:', end='')
  print(num % 10)
  

  结果:

  请输入一个整数:782
  782 的个位数是:2
  

• // - 整除；向下取接近除数的整数

  >>> 5 // 2
  2
  >>> 3.9 // 3
  3.0
  >>> -5 // 2
  -3
  

• ****** - 幂；返回x的y次方

  print('2的3次方:', 2 ** 3)	
  print('16开平方:', 16 ** 0.5)   # 16的0.5次方就相当于16的二分之一次方，也就是开平方
  print('8开3次方:', 8 ** (1/3))
  

  结果:

  2的3次方: 8
  16开平方: 4.0 
  8开3次方: 2.0
  

2 关系运算符

关系运算符就是我们的比较运算符，有：> < == != >= <=

注意: 所有关系运算符的运算结果都是布尔值

• > - 大于；返回x是否大于y
• < - 小于；返回x是否小于y
• == - 等于；比较对象是否相等
• != - 不等于；比较两个对象是否不相等
• >= - 大于等于；返回x是否大于等于y
• <= - 小于等于；返回x是否小于等于y

>>>10 > 20
False
>>>10 < 20
True
>>>30 >= 20
True
>>> 30 <= 30
True
>>> 10 == 10
True
>>> 10 != 10
False

python可以像数学一样用比较运算符连写的方式表示范围(C/Java/JS等不可以):

# 判断age的值是否在18到30之间
age = 20
print(18 < age < 30)

结果:

True

3 逻辑运算符

Python中的逻辑运算符有: and or not。

1. and - 逻辑与运算

   运算规则: x and y - 如果 x 对应的布尔值是False，x and y 返回 False，否则它返回 y 的计算值。

   x = 10
   y = 20
   print(x and y)	# x不是False,所以结果是y的值20
   
   x = False
   y = 20
   print(x and y)	# x是False, 所以结果是y的值False
   
   x = 10
   y = True
   print(x and y)	# x不是False,所以结果是y的值True
   

   结果:

   20
   False
   True
   

   应用场景: 需要多个条件同时满足的时候，就用and; 相当于生活中的并且。

   # 获取奖学金的条件: 绩点不低于4并且操评分高于95
   gpa = 4.8
   score = 90
   print('是否能够获取奖学金:', gpa >= 4 and score > 95)
   
   gpa = 4.8
   score = 98
   print('是否能够获取奖学金:', gpa >= 4 and score > 95)
   

   结果:

   是否能够获取奖学金: False
   是否能够获取奖学金: True
   

2. or - 逻辑或运算

   运算规则：x or y - 如果 x 对应的布尔值是True，它返回 x 的值，否则它返回 y 的计算值。

   x = 10
   y = 20
   print(x or y)	# x对应的布尔是True(10转换成布尔是True),所以结果是x的值10
   
   x = False
   y = 20
   print(x or y)	# x对应的布尔是False,所以结果是y的值20
   
   x = 10
   y = True
   print(x or y)	# x对应的布尔是True,所以结果是x的值10
   

   结果:

   10
   20
   10
   

   应用场景: 需要多个条件中有一个条件满足就行，就使用or；相当于生活中的或者。

   # 获取奖学金的条件: 绩点不低于4或者操评分高于95
   gpa = 4.8
   score = 90
   print('是否能够获取奖学金:', gpa >= 4 or score > 95)
   
   gpa = 4.8
   score = 98
   print('是否能够获取奖学金:', gpa >= 4 or score > 95)
   

   结果:

   是否能够获取奖学金: True
   是否能够获取奖学金: True
   

3. not - 逻辑非运算

   运算规则：not x - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

   x = True
   print(not x)
   
   x = 10
   print(not x)
   
   x = 0
   print(not x)
   

   结果:

   False
   False
   True	
   

   应用场景: 对某一个条件进行否定。

   # 判断输入的数字是否能同时被3和7整除
   num = int(input('请输入一个整数:'))
   print(num, '是否能同时被3和7整除:', num % 3 == 0 and num % 7 == 0)
   
   
   # 判断输入的数字是否不能同时被3和7整除
   num = int(input('请输入一个整数:'))
   print(num, '是否不能同时被3和7整除:', not(num % 3 == 0 and num % 7 == 0))
   

   结果:

   请输入一个整数:9
   9 是否能同时被3和7整除: False
   
   请输入一个整数:9
   9 是否不能同时被3和7整除: True
   

4. 短路操作

   Python中的逻辑与运算和逻辑或运算都存在短路现象：

   • x and y - 当逻辑与运算的第一个表达式x的值为False的时候，第二个表达式y不会执行
   • x or y - 当逻辑或运算的第一个表达式x的值为True的时候，第二个表达式y不会执行

   def func():
       print('函数体被执行')
      
   # 逻辑与运算的短路操作
   print('不短路:', end='')
   True and func()		# 不短路的时候会调用函数
   
   print('短路:', end='')
   False and func()	# 短路的时候不会调用函数
   
   print()
   # 逻辑或运算的短路操作
   print('不短路:', end='')
   False or func()		# 不短路的时候会调用函数
   
   print('短路:', end='')
   True or func()		# 短路的时候不会调用函数
   

   结果:

   不短路:函数体被执行
   短路:
   不短路:函数体被执行
   短路:
   

4 成员运算符

Python中的成员运算符有两个：in 和 not in ，主要用于序列中元素的判断。

1. in

   元素 in 序列 - 如果在指定序列中找到指定的元素返回True, 否则返回False

   # 1.判断一个字符串是否是另一个字符串的子串
   result1 = 'you' in 'how are you！'
   print('result1:', result1)
   
   result2 = 'wo' in 'how are you！'
   print('result2:', result2)
   
   # 2.判断指定的值是否列表中元素
   result3 = 100 in [10, 20, 30]
   print('result3:', result3)
   
   result4 = 10 in [10, 20, 30]
   print('result4:', result4)
   

   结果:

   result1: True
   result2: False
   result3: False
   result4: True
   
   

2. not in

   元素 not in 序列 - 如果指定序列中不包含指定元素返回True，否则返回False。

5 身份运算符

身份运算符用于比较两个对象的存储单元是否相同(也就是两个数据是否是保存在同一内存空间中的数据)，涉及到的运算符有两个：is 和 is not

• x is y - 判断两个标识符是不是引用自一个对象
• x is not y - 判断两个标识符是不是引用自不同对象

a = [1, 2]
b = [1, 2]
c = a

print('a == b:', a == b)
print('a is b:', a is b)
print('a is c:', a is c)

结果:

a == b: True
a is b: False
a is c: True

6 位运算符

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

下表中变量 a 为 60，b 为 13，其二进制分别是 00111100 和 00001101：

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b)输出结果 12，对应的二进制：00001100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1	(a | b)输出结果 61，对应的二进制：00111101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，对应的二进制： 00110001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，对应的二进制： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，对应的二进制： 11110000
>>	右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数	a >> 2 输出结果 15 ，对应的二进制： 0000 1111

实际开发中，可以通过使用位运算来提高程序的执行效率：

# 1. 判断数字的奇偶性：因为所有的偶数的最后一位都是0，奇数的最后一位都是1
num = int(input('请输入一个整数:'))
if num & 1 == 0:
    print(num, '是偶数')
else:
    print(num, '是奇数')
    
# 2.高效率的乘2和整除2：x >> n相当于x乘以2的n次方；x >> n相当于x整除2的n次方
print('4 // 2 = ', 4 >> 1)
print('4 * 2 =', 4 << 1)

结果:

请输入一个整数:10
10 是偶数

4 // 2 =  2
4 * 2 = 8

7 赋值运算符

赋值运算符的作用是给变量赋值，不管是那种赋值运算符都要求左边必须是变量，复合的赋值运算符左边除了是变量这个变量还必须已经赋值过。

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

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	b += a 等效于 b = b + a
-=	减法赋值运算符	b -= a 等效于 b = b - a
*=	乘法赋值运算符	b *= a 等效于 b = b * a
/=	除法赋值运算符	b /= a 等效于 b = b / a
%=	取模赋值运算符	b %= a 等效于 b = b % a
//=	取整除赋值运算符	b //= a 等效于 b = b // a
**=	幂赋值运算符	b ******= a 等效于 b = b ** a

以下实例演示了Python所有赋值运算符的操作：

a = 21
b = 10
c = 0
 
c = a + b
print ("1.c 的值为：", c)
 
c += a
print ("2.c 的值为：", c)
 
c *= a
print ("3.c 的值为：", c)
 
c /= a 
print ("4.c 的值为：", c)
 
c = 2
c %= a
print ("5.c 的值为：", c)
 
c **= a
print ("6.c 的值为：", c)
 
c //= a
print ("7.c 的值为：", c)

结果:

1.c 的值为： 31
2.c 的值为： 52
3.c 的值为： 1092
4.c 的值为： 52.0
5.c 的值为： 2
6.c 的值为： 2097152
7.c 的值为： 99864

8 运算符优先级和结合性

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

运算符	描述
**	幂运算(最高优先级)
~ + -	按位翻转, 一元加号和减号(正号、负号)
* / % //	乘，除，求余数和取整除
+ -	加法减法
>> <<	右移、左移运算
&	按位与运算
^ |	按位异或、按位或
<= < > >=	比较运算符
== !=	等于运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符
= %= /= //= -= += *= **=	赋值运算符

在综合运算的运算表达式中，我们还可以像数学一样通过加 () 来改变运算顺序。(有括号先算括号里面的)

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

结果:

(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0