【Python】算术、赋值、比较（关系）、逻辑、三目（三元）运算符详解

怼烎@ 2022-10-09 12:08 240阅读 0赞

### 算术、赋值、比较（关系）、逻辑、三目（三元）运算符详解 ###

*  算数运算符概述
 *   *  加法运算符（+）
     *   *  拼接字符串
     *  减法运算符（-）
     *   *  求负
     *  乘法运算符（\*）
     *   *  重复字符串
     *  除法运算符（/ 和 //）
     *  求余运算符（%）
     *  次方（乘方）运算符（\*\*）
 *  赋值运算符概述
 *   *  基本赋值运算符
     *   *  连续赋值
     *  扩展后的赋值运算符
 *  比较（关系）运算符概述
 *   *  == 和 is 的区别
 *  逻辑运算符概述
 *   *  逻辑运算符的本质
 *  三目运算符（三元运算符）概述
 *   *  三元运算符的嵌套

# 算数运算符概述 #

算术运算符也即数学运算符，用来对数字进行数学运算，比如加减乘除。下表列出了 Python 支持所有基本算术运算符。

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>说明</th> 
   <th>实例</th> 
   <th>结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>加</td> 
   <td>12.45 + 15</td> 
   <td>27.45</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减</td> 
   <td>4.56 - 0.26</td> 
   <td>4.3</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘</td> 
   <td>5 * 3.6</td> 
   <td>18.0</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除法（和数学中的规则一样）</td> 
   <td>7 / 2</td> 
   <td>3.5</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>整除（只保留商的整数部分）</td> 
   <td>7 // 2</td> 
   <td>3</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取余，即返回除法的余数</td> 
   <td>7 % 2</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>幂运算/次方运算，即返回 x 的 y 次方</td> 
   <td>2 ** 4</td> 
   <td>16，即 <span><span><span> 2 4 2^4 </span><span><span><span style="height: 0.814108em; vertical-align: 0em;"></span><span><span>2</span><span><span><span><span style="height: 0.814108em;"><span style="top: -3.063em; margin-right: 0.05em;"><span style="height: 2.7em;"></span><span><span>4</span></span></span></span></span></span></span></span></span></span></span></span></td> 
  </tr> 
 </tbody> 
</table>

## 加法运算符（+） ##

加法运算符很简单，和数学中的规则一样，请看下面的代码：

m = 10
    n = 97
    sum1 = m + n
    
    x = 7.2
    y = 15.3
    sum2 = x + y
    
    print("sum1=%d, sum2=%.2f" % (sum1, sum2) )
    输出：sum1=107, sum2=22.50

### 拼接字符串 ###

当`+`用于数字时表示加法，但是当`+`用于字符串时，它还有拼接字符串（将两个字符串连接为一个）的作用，请看代码：

name = "小明"
    url = "http://c.biancheng.net/"
    age = 20
    info = name + "的网址是" + url + "，它已经" + str(age) + "岁了。"
    print(info)

## 减法运算符（-） ##

减法运算也和数学中的规则相同，请看代码：

n = 45
    m = -n
    
    x = -83.5
    y = -x
    
    print(m, ",", y)
    输出：-45 , 83.5

### 求负 ###

`-`除了可以用作减法运算之外，还可以用作求负运算（正数变负数，负数变正数），请看下面的代码：

n = 45
    n_neg = -n
    
    f = -83.5
    f_neg = -f
    
    print(n_neg, ",", f_neg)
    输出：-45 , 83.5

注意，单独使用`+`是无效的，不会改变数字的值，例如：

n = 45
    m = +n
    
    x = -83.5
    y = +x
    
    print(m, ",", y)
    45 , -83.5

## 乘法运算符（\*） ##

乘法运算也和数学中的规则相同，请看代码：

n = 4 * 25
    f = 34.5 * 2
    print(n, ",", f)
    输出：100 , 69.0

### 重复字符串 ###

`*`除了可以用作乘法运算，还可以用来重复字符串，也即将 n 个同样的字符串连接起来，请看代码：

str1 = "hello "
    print(str1 * 4)
    输出：hello hello hello hello

## 除法运算符（/ 和 //） ##

Python 支持`/`和`//`两个除法运算符，但它们之间是有区别的：

*  `/`表示普通除法，使用它计算出来的结果和数学中的计算结果相同。
 *  `//`表示`整除`，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入。

请看下面的例子：

#整数不能除尽
    print("23/5 =", 23/5)
    print("23//5 =", 23//5)
    print("23.0//5 =", 23.0//5)
    23/5 = 4.6
    23//5 = 4
    23.0//5 = 4.0
    
    #整数能除尽
    print("25/5 =", 25/5)
    print("25//5 =", 25//5)
    print("25.0//5 =", 25.0//5)
    25/5 = 5.0
    25//5 = 5
    25.0//5 = 5.0
    
    #小数除法
    print("12.4/3.5 =", 12.4/3.5)
    print("12.4//3.5 =", 12.4//3.5)
    12.4/3.5 = 3.542857142857143
    12.4//3.5 = 3.0

从运行结果可以发现：

*  `/` 的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。
 *  当有小数参与运算时，`//`结果才是小数，否则就是整数。

## 求余运算符（%） ##

`%` 运算符用来求得两个数相除的余数，包括整数和小数。

Python 使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数。

print("-----整数求余-----")
    print("15%6 =", 15%6)
    print("-15%6 =", -15%6)
    print("15%-6 =", 15%-6)
    print("-15%-6 =", -15%-6)
    15%6 = 3
    -15%6 = 3
    15%-6 = -3
    -15%-6 = -3
    
    print("-----小数求余-----")
    print("7.7%2.2 =", 7.7%2.2)
    print("-7.7%2.2 =", -7.7%2.2)
    print("7.7%-2.2 =", 7.7%-2.2)
    print("-7.7%-2.2 =", -7.7%-2.2)
    7.7%2.2 = 1.0999999999999996
    -7.7%2.2 = 1.1000000000000005
    7.7%-2.2 = -1.1000000000000005
    -7.7%-2.2 = -1.0999999999999996
    
    print("---整数和小数运算---")
    print("23.5%6 =", 23.5%6)
    print("23%6.5 =", 23%6.5)
    print("23.5%-6 =", 23.5%-6)
    print("-23%6.5 =", -23%6.5)
    print("-23%-6.5 =", -23%-6.5)
    23.5%6 = 5.5
    23%6.5 = 3.5
    23.5%-6 = -0.5
    -23%6.5 = 3.0
    -23%-6.5 = -3.5

从运行结果可以发现两点：

*  只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
 *  `%`两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。

## 次方（乘方）运算符（\*\*） ##

Python `**` 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符。

由于开方是次方的逆运算，所以也可以使用 `**` 运算符间接地实现开方运算。

print('----次方运算----')
    print('3**4 =', 3**4)
    print('2**5 =', 2**5)
    3**4 = 81
    2**5 = 32
    
    print('----开方运算----')
    print('81**(1/4) =', 81**(1/4))
    print('32**(1/5) =', 32**(1/5))
    81**(1/4) = 3.0
    32**(1/5) = 2.0

# 赋值运算符概述 #

赋值运算符用来把右侧的值传递给左侧的变量（或者常量）；

可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。

## 基本赋值运算符 ##

`=`是 Python 中最常见、最基本的赋值运算符，用来将一个表达式的值赋给另一个变量，请看下面的例子：

#将字面量（直接量）赋值给变量
    n1 = 100
    f1 = 47.5
    s1 = "http://www.qinjl.com/python/"
    
    #将一个变量的值赋给另一个变量
    n2 = n1
    f2 = f1
    
    #将某些运算的值赋给变量
    sum1 = 25 + 46 
    sum2 = n1 % 6
    s2 = str(1234)  #将数字转换成字符串
    s3 = str(100) + "abc"

### 连续赋值 ###

Python 中的赋值表达式也是有值的，它的值就是被赋的那个值，或者说是左侧变量的值；如果将赋值表达式的值再赋值给另外一个变量，这就构成了连续赋值。请看下面的例子：

a = b = c = 100

`=`具有右结合性，我们从右到左分析这个表达式：

*  `c = 100` 表示将 100 赋值给 c，所以 c 的值是 100；同时，`c = 100` 这个子表达式的值也是 100。
 *  `b = c = 100` 表示将 `c = 100` 的值赋给 b，因此 b 的值也是 100。
 *  以此类推，a 的值也是 100。

## 扩展后的赋值运算符 ##

`=`还可与其他运算符（包括算术运算符、位运算符和逻辑运算符）相结合，扩展成为功能更加强大的赋值运算符，如表 1 所示。

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>说明</th> 
   <th>用法举例</th> 
   <th>等价形式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>最基本的赋值运算</td> 
   <td>x = y</td> 
   <td>x = y</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加赋值</td> 
   <td>x += y</td> 
   <td>x = x + y</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减赋值</td> 
   <td>x -= y</td> 
   <td>x = x - y</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘赋值</td> 
   <td>x *= y</td> 
   <td>x = x * y</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除赋值</td> 
   <td>x /= y</td> 
   <td>x = x / y</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取余数赋值</td> 
   <td>x %= y</td> 
   <td>x = x % y</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值</td> 
   <td>x **= y</td> 
   <td>x = x ** y</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>取整数赋值</td> 
   <td>x //= y</td> 
   <td>x = x // y</td> 
  </tr> 
  <tr> 
   <td>&amp;=</td> 
   <td>按位与赋值</td> 
   <td>x &amp;= y</td> 
   <td>x = x &amp; y</td> 
  </tr> 
  <tr> 
   <td>|=</td> 
   <td>按位或赋值</td> 
   <td>x |= y</td> 
   <td>x = x | y</td> 
  </tr> 
  <tr> 
   <td>^=</td> 
   <td>按位异或赋值</td> 
   <td>x ^= y</td> 
   <td>x = x ^ y</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;=</td> 
   <td>左移赋值</td> 
   <td>x &lt;&lt;= y</td> 
   <td>x = x &lt;&lt; y，这里的 y 指的是左移的位数</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;=</td> 
   <td>右移赋值</td> 
   <td>x &gt;&gt;= y</td> 
   <td>x = x &gt;&gt; y，这里的 y 指的是右移的位数</td> 
  </tr> 
 </tbody> 
</table>

举个栗子：

n1 = 100
    f1 = 25.5
    n1 -= 80  #等价于 n1=n1-80
    f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 )
    
    print("n1=%d" % n1)
    print("f1=%.2f" % f1)
    n1=20
    f1=255.00

通常情况下，只要能使用扩展后的赋值运算符，都推荐使用这种赋值运算符。

注意，这种赋值运算符只能针对已经存在的变量，因为赋值过程中需要变量本身参与运算，如果变量没有提前定义，它的值就是未知的，无法参与运算。例如，下面的写法就是错误的：

n += 10

该表达式等价于 `n = n + 10`，`n` 没有提前定义，所以它不能参与加法运算。

# 比较（关系）运算符概述 #

比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 `True（真）`，反之则返回 `False（假）`。

<table> 
 <thead> 
  <tr> 
   <th>比较运算符</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&gt;</td> 
   <td>大于，如果<code>&gt;</code>前面的值大于后面的值，则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于，如果<code>&lt;</code>前面的值小于后面的值，则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>等于，如果<code>==</code>两边的值相等，则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于（等价于数学中的 ≥），如果<code>&gt;=</code>前面的值大于或者等于后面的值，则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于（等价于数学中的 ≤），如果<code>&lt;=</code>前面的值小于或者等于后面的值，则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于（等价于数学中的 ≠），如果<code>!=</code>两边的值不相等，则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>判断两个变量所引用的对象是否相同，如果相同则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>is not</td> 
   <td>判断两个变量所引用的对象是否不相同，如果不相同则返回 True，否则返回 False。</td> 
  </tr> 
 </tbody> 
</table>

Python 比较运算符的使用举例：

print("89是否大于100：", 89 > 100)
    print("24*5是否大于等于76：", 24*5 >= 76)
    print("86.5是否等于86.5：", 86.5 == 86.5)
    print("34是否等于34.0：", 34 == 34.0)
    print("False是否小于True：", False < True)
    print("True是否等于True：", True < True)
    
    89是否大于100： False
    24*5是否大于等于76： True
    86.5是否等于86.5： True
    34是否等于34.0： True
    False是否小于True： True
    True是否等于True： False

## == 和 is 的区别 ##

很多人会误将`is`和 `==` 的功能混为一谈，但其实 `is` 与 `==` 有本质上的区别，完全不是一码事儿。

`==` 用来比较两个变量的值是否相等，而 `is` 则用来比对两个变量引用的是否是同一个对象，例如：

import time  #引入time模块
    
    t1 = time.gmtime() # gmtime()用来获取当前时间
    t2 = time.gmtime()
    
    print(t1 == t2) #输出True
    print(t1 is t2) #输出False

time 模块的 `gmtime()` 方法用来获取当前的系统时间，精确到秒级，因为程序运行非常快，所以 `t1` 和 `t1` 得到的时间是一样的。`==` 用来判断 `t1` 和 `t2` 的值是否相等，所以返回 `True`。

虽然 `t1` 和 `t2` 的值相等，但它们是两个不同的对象（每次调用 `gmtime()` 都返回不同的对象），所以`t1 is t2`返回 `False`。这就好像两个双胞胎姐妹，虽然她们的外貌是一样的，但它们是两个人。

那么，如何判断两个对象是否相同呢？

答案是判断两个对象的内存地址。如果内存地址相同，说明两个对象使用的是同一块内存，当然就是同一个对象了；这就像两个名字使用了同一个身体，当然就是同一个人了。

# 逻辑运算符概述 #

高中数学中我们就学过逻辑运算，例如 p 为真命题，q 为假命题，那么“`p且q`”为假，“`p或q`”为真，“`非q`”为真。Python 也有类似的逻辑运算，请看下表：

<table> 
 <thead> 
  <tr> 
   <th>逻辑运算符</th> 
   <th>含义</th> 
   <th>基本格式</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>逻辑与运算，等价于数学中的“且”</td> 
   <td>a and b</td> 
   <td>当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>逻辑或运算，等价于数学中的“或”</td> 
   <td>a or b</td> 
   <td>当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>逻辑非运算，等价于数学中的“非”</td> 
   <td>not a</td> 
   <td>如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反。</td> 
  </tr> 
 </tbody> 
</table>

逻辑运算符一般和关系运算符结合使用，例如：

14>6 and 45.6 > 90

`14>6` 结果为 `True`，成立，`45.6>90` 结果为 `False`，不成立，所以整个表达式的结果为 `False`，也即不成立。

再看一个比较实用的例子：

age = int(input("请输入年龄："))
    height = int(input("请输入身高："))
    if age>=18 and age<=30 and height >=170 and height <= 185 :
        print("恭喜，你符合报考飞行员的条件")
    else:
        print("抱歉，你不符合报考飞行员的条件")
    
    输出：
    请输入年龄：23↙
    请输入身高：178↙
    恭喜，你符合报考飞行员的条件

## 逻辑运算符的本质 ##

在 Python 中，`and` 和 `or` 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。

另外，`and` 和 `or` 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。

以上两点极其重要，了解这两点不会让你在使用逻辑运算的过程中产生疑惑。

对于 `and` 运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以 Python 按照下面的规则执行 and 运算：

*  如果左边表达式的值为`假`，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时 `and` 会把左边表达式的值作为最终结果。
 *  如果左边表达式的值为`真`，那么最终值是不能确定的，and 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。

对于 `or` 运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个值为真，那么最终结果就是真，所以 Python 按照下面的规则执行 or 运算：

*  如果左边表达式的值为`真`，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时 `or` 会把左边表达式的值作为最终结果。
 *  如果左边表达式的值为`假`，那么最终值是不能确定的，or 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。

使用代码验证上面的结论：

url = "http://www.qinjl.com/"
    print("----False and xxx-----")
    print( False and print(url) )
    print("----True and xxx-----")
    print( True and print(url) )
    print("----False or xxx-----")
    print( False or print(url) )
    print("----True or xxx-----")
    print( True or print(url) )
    
    输出：
    ----False and xxx-----
    False
    ----True and xxx-----
    http://www.qinjl.com/
    None
    ----False or xxx-----
    http://www.qinjl.com/
    None
    ----True or xxx-----
    True

第 4 行代码中，and 左边的值为假，不需要再执行右边的表达式了，所以 print(url) 没有任何输出。

第 6 行代码中，and 左边的值为真，还需要执行右边的表达式才能得到最终的结果，所以 print(url) 输出了一个网址。

第 8、10 行代码也是类似的。

# 三目运算符（三元运算符）概述 #

我们从一个具体的例子切入。假设现在有两个数字，我们希望获得其中较大的一个，那么可以使用 `if else` 语句，例如：

if a>b:
        max = a;
    else:
        max = b;

但是 Python 提供了一种更加简洁的写法，如下所示：

max = a if a>b else b

这是一种类似于其它编程语言中三目运算符`? :`的写法。Python 是一种极简主义的编程语言，它没有引入`? :`这个新的运算符，而是使用已有的 if else 关键字来实现相同的功能。

使用 `if else` 实现三目运算符（条件运算符）的格式如下：

exp1 if contion else exp2

condition 是判断条件，`exp1` 和 `exp2` 是两个表达式。如果 condition 成立（结果为真），就执行 `exp1`，并把 `exp1` 的结果作为整个表达式的结果；

如果 condition 不成立（结果为假），就执行 `exp2`，并把 `exp2` 的结果作为整个表达式的结果。

前面的语句`max = a if a>b else b`的含义是：

*  如果 `a > b` 成立，就把 a 作为整个表达式的值，并赋给变量 max；
 *  如果 `a > b` 不成立，就把 b 作为整个表达式的值，并赋给变量 max。

## 三元运算符的嵌套 ##

Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：

a if a>b else c if c>d else d

理解为：

a if a>b else ( c if c>d else d )

【实例】使用 Python 三目运算符判断两个数字的关系：

a = int( input("Input a: ") )
    b = int( input("Input b: ") )
    print("a大于b") if a>b else ( print("a小于b") if a<b else print("a等于b") )
    输出：
    Input a: 45↙
    Input b: 100↙
    a小于b

该程序是一个嵌套的三目运算符。程序先对 a>b 求值，如果该表达式为 True，程序就返回执行第一个表达式 print(“a大于b”)，否则将继续执行 else 后面的内容，也就是：

( print("a小于b") if a<b else print("a等于b") )