第11章 Python3 运算符教程

你得不到的念想

于 2022-12-22 14:30:00 发布

阅读量865

点赞数 2

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/phlcsdn2023/article/details/128355869

版权

Python 专栏收录该内容

52 篇文章 3 订阅

订阅专栏

什么是运算符？

本章节主要说明 Python 的运算符。

举个简单的例子:


    4 + 5 = 9

例子中，4 和 5 被称为操作数，+ 称为运算符。

Python 语言支持以下类型的运算符:

算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级

接下来让咱们一个个来学习Python的运算符。

Python算术运算符

以下假设变量 a=10，变量 b=21：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是return 一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - return 除法的余数	b % a 输出结果 1
**	幂 - return x的y次幂	a**b 为10的21次方
//	取整除 - 向下取接近商的整数	```python >>> 9//2 4 >>> -9//2 -5 ```

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


    实例(Python 3.0+) 
     
    #!/usr/bin/python3
     
    a = 21
    b = 10
    c = 0
     
    c = a + b
    print ("1 - c 的值为：", c)
     
    c = a - b
    print ("2 - c 的值为：", c)
     
    c = a * b
    print ("3 - c 的值为：", c)
     
    c = a / b
    print ("4 - c 的值为：", c)
     
    c = a % b
    print ("5 - c 的值为：", c)
     
    # 修改变量 a 、b 、c
    a = 2
    b = 3
    c = a**b 
    print ("6 - c 的值为：", c)
     
    a = 10
    b = 5
    c = a//b 
    print ("7 - c 的值为：", c)

以上实例输出结果请在输出结果查看


    1 - c 的值为： 31
    2 - c 的值为： 11
    3 - c 的值为： 210
    4 - c 的值为： 2.1
    5 - c 的值为： 1
    6 - c 的值为： 8
    7 - c 的值为： 2

Python比较运算符

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

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) return False。
!=	不等于 - 比较两个对象是否不相等	(a != b) return True。
>	大于 - return x是否大于y	(a > b) return False。
<	小于 - return x是否小于y。所有比较运算符return 1表示真，return 0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) return True。
>=	大于等于 - return x是否大于等于y。	(a >= b) return False。
<=	小于等于 - return x是否小于等于y。	(a <= b) return True。

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


    实例(Python 3.0+) 
     
    
    
    #!/usr/bin/python3
     
    a = 21
    b = 10
    c = 0
     
    if ( a == b ):
       print ("1 - a 等于 b")
    else:
       print ("1 - a 不等于 b")
     
    if ( a != b ):
       print ("2 - a 不等于 b")
    else:
       print ("2 - a 等于 b")
     
    if ( a < b ):
       print ("3 - a 小于 b")
    else:
       print ("3 - a 大于等于 b")
     
    if ( a > b ):
       print ("4 - a 大于 b")
    else:
       print ("4 - a 小于等于 b")
     
    # 修改变量 a 和 b 的值
    a = 5
    b = 20
    if ( a <= b ):
       print ("5 - a 小于等于 b")
    else:
       print ("5 - a 大于  b")
     
    if ( b >= a ):
       print ("6 - b 大于等于 a")
    else:
       print ("6 - b 小于 a")

以上实例输出结果请在输出结果查看


    1 - a 不等于 b
    2 - a 不等于 b
    3 - a 大于等于 b
    4 - a 大于 b
    5 - a 小于等于 b
    6 - b 大于等于 a

Python赋值运算符

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

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。	在这个示例中，赋值表达式可以避免调用 len() 两次: ```python if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") ```

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


    实例(Python 3.0+) 
     
    
    
    #!/usr/bin/python3
     
    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

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

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

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


    实例(Python 3.0+) 
     
    
    
    #!/usr/bin/python3
     
    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)

以上实例输出结果请在输出结果查看


    1 - c 的值为： 12
    2 - c 的值为： 61
    3 - c 的值为： 49
    4 - c 的值为： -61
    5 - c 的值为： 240
    6 - c 的值为： 15

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y return x 的值，否则return y 的计算值。	(a and b) return 20。
or	x or y	布尔"或" - 如果 x 是 True，它return x 的值，否则它return y 的计算值。	(a or b) return 10。
not	not x	布尔"非" - 如果 x 为 True，return False 。如果 x 为 False，它return True。	not(a and b) return False

以上实例输出结果请在输出结果查看


    实例(Python 3.0+) 
     
    
    
    #!/usr/bin/python3
     
    a = 10
    b = 20
     
    if ( a and b ):
       print ("1 - 变量 a 和 b 都为 true")
    else:
       print ("1 - 变量 a 和 b 有一个不为 true")
     
    if ( a or b ):
       print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
    else:
       print ("2 - 变量 a 和 b 都不为 true")
     
    # 修改变量 a 的值
    a = 0
    if ( a and b ):
       print ("3 - 变量 a 和 b 都为 true")
    else:
       print ("3 - 变量 a 和 b 有一个不为 true")
     
    if ( a or b ):
       print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
    else:
       print ("4 - 变量 a 和 b 都不为 true")
     
    if not( a and b ):
       print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
    else:
       print ("5 - 变量 a 和 b 都为 true")

以上实例输出结果请在输出结果查看


    1 - 变量 a 和 b 都为 true
    2 - 变量 a 和 b 都为 true，或其中一个变量为 true
    3 - 变量 a 和 b 有一个不为 true
    4 - 变量 a 和 b 都为 true，或其中一个变量为 true
    5 - 变量 a 和 b 都为 false，或其中一个变量为 false

Python成员运算符

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

运算符	描述	实例
in	如果在指定的序列中找到值return True，否则return False。	x 在 y 序列中 , 如果 x 在 y 序列中return True。
not in	如果在指定的序列中没有找到值return True，否则return False。	x 不在 y 序列中 , 如果 x 不在 y 序列中return True。

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


    实例(Python 3.0+) 
     
    
    
    #!/usr/bin/python3
     
    a = 10
    b = 20
    list = [1, 2, 3, 4, 5 ]
     
    if ( a in list ):
       print ("1 - 变量 a 在给定的列表中 list 中")
    else:
       print ("1 - 变量 a 不在给定的列表中 list 中")
     
    if ( b not in list ):
       print ("2 - 变量 b 不在给定的列表中 list 中")
    else:
       print ("2 - 变量 b 在给定的列表中 list 中")
     
    # 修改变量 a 的值
    a = 2
    if ( a in list ):
       print ("3 - 变量 a 在给定的列表中 list 中")
    else:
       print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果请在输出结果查看


    1 - 变量 a 不在给定的列表中 list 中
    2 - 变量 b 不在给定的列表中 list 中
    3 - 变量 a 在给定的列表中 list 中

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则return True，否则return False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ，类似 id(x) != id(y)。如果引用的不是同一个对象则return 结果 True，否则return False。

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

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


    实例(Python 3.0+) 
     
    
    
    #!/usr/bin/python3
     
    a = 20
    b = 20
     
    if ( a is b ):
       print ("1 - a 和 b 有相同的标识")
    else:
       print ("1 - a 和 b 没有相同的标识")
     
    if ( id(a) == id(b) ):
       print ("2 - a 和 b 有相同的标识")
    else:
       print ("2 - a 和 b 没有相同的标识")
     
    # 修改变量 b 的值
    b = 30
    if ( a is b ):
       print ("3 - a 和 b 有相同的标识")
    else:
       print ("3 - a 和 b 没有相同的标识")
     
    if ( a is not b ):
       print ("4 - a 和 b 没有相同的标识")
    else:
       print ("4 - a 和 b 有相同的标识")

以上实例输出结果请在输出结果查看


    1 - a 和 b 有相同的标识
    2 - a 和 b 有相同的标识
    3 - a 和 b 没有相同的标识
    4 - a 和 b 没有相同的标识

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。


    >>>a = [1, 2, 3]
    >>> b = a
    >>> b is a 
    True
    >>> b == a
    True
    >>> b = a[:]
    >>> b is a
    False
    >>> b == a
    True

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符，相同单元格内的运算符具有相同优先级。运算符均指二元运算，除非特别指出。相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

运算符	描述
`(expressions...)`, `[expressions...]`, `{key: value...}`, `{expressions...}`	圆括号的表达式
`x[index]`, `x[index:index]`, `x(arguments...)`, `x.attribute`	读取，切片，调用，属性引用
await x	await 表达式
`**`	乘方(指数)
`+x`, `-x`, `~x`	正，负，按位非 NOT
`*`, `@`, `/`, `//`, `%`	乘，矩阵乘，除，整除，取余
`+`, `-`	加和减
`<<`, `>>`	移位
`&`	按位与 AND
`^`	按位异或 XOR
`\|`	按位或 OR
`in,not in, is,is not, <, <=, >, >=, !=, ==`	比较运算，包括成员检测和标识号检测
`not x`	逻辑非 NOT
`and`	逻辑与 AND
`or`	逻辑或 OR
`if -- else`	条件表达式
`lambda`	lambda 表达式
`:=`	赋值表达式

以下实例演示了Python所有运算符优先级的操作：


    实例(Python 3.0+) 
     
    
    
    #!/usr/bin/python3
     
    a = 20
    b = 10
    c = 15
    d = 5
    e = 0
     
    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

and 拥有更高优先级:


    实例 x = True
    y = False
    z = False
     
    if x or y and z:
        print("yes")
    else:
        print("no")

以上实例先计算 y and z 并return False ，然后 x or False return True，输出结果请在输出结果查看

yes

**注意：**Python3 已不支持 <> 运算符，可以使用 != 代替，如果阁下您一定要使用这种比较运算符，可以使用以下的方式：
    >>> from __future__ import barry_as_FLUFL
    >>> 1 <> 2
    True


    x = True
    y = False
    z = False
    
    if x or y and z:
        print("yes")
    else:
        print("no")


    x = True
    y = False
    z = False
    
    if not x or y:
        print(1)
    elif not x or not y and z:
        print(2)
    elif not x or y or not y and x:
        print(3)
    else:
        print(4)

课后练习

本专栏所有文章

第1章 Python3 教程	第2章 Python3 简介教程
第3章 Python3 环境搭建教程	第4章 Python3 VScode教程
第5章 Python3 基础语法教程	第6章 Python3 基本数据类型教程
第7章 Python3 数据类型转换教程	第8章 Python3 推导式教程
第9章 Python3 解释器教程	第10章 Python3 注释教程
第11章 Python3 运算符教程	第12章 Python3 数字(Number)教程
第13章 Python3 字符串教程	第14章 Python3 列表教程
第15章 Python3 元组教程	第16章 Python3 字典教程
第17章 Python3 集合教程	第18章 Python3 编程第一步教程
第19章 Python3 条件控制教程	第20章 Python3 循环语句教程
第21章 Python3 迭代器与生成器教程	第22章 Python3 函数教程
第23章 Python3 数据结构教程	第24章 Python3 模块教程
第25章 Python3 输入和输出教程	第26章 Python3 File教程
第27章 Python3 OS教程	第28章 Python3 错误和异常教程
第29章 Python3 面向对象教程	第30章 Python3 命名空间/作用域教程
第31章 Python3 标准库概览教程	第32章 Python3 实例教程
第33章 Python 测验教程	第34章 Python3 正则表达式教程
第35章 Python3 CGI编程教程	第36章 Python3 MySQL(mysql-connector)教程
第37章 Python3 MySQL(PyMySQL)教程	第38章 Python3 网络编程教程
第39章 Python3 SMTP发送邮件教程	第40章 Python3 多线程教程
第41章 Python3 XML 解析教程	第42章 Python3 JSON教程
第43章 Python3 日期和时间教程	第44章 Python3 内置函数教程
第45章 Python3 MongoDB教程	第46章 Python3 urllib教程
第47章 Python uWSGI 安装配置教程	第48章 Python3 pip教程
第49章 Python3 operator教程	第50章 Python math教程
第51章 Python requests教程	第52章 Python random教程
第53章 Python3 os.replace() 方法教程

寄语

本文有phlcsdn2023原创，欢迎点赞、转载，博客地址：https://blog.csdn.net/phlcsdn2023

请把你的心给我，与我为伍，这个世界太残酷了，我有些害怕。
叔本华说过：“人的烦恼主要来源于把简单的问题繁琐化，累自我，也累别人”。的确如此，有些人思想曲曲折折，有些人被欲望所捆绑，简单实际是一种心境，就像佛家的崇尚心净自然清一样，只要你心明静了，你自然会把琐事看的简单，就不会在纷纷扰扰的繁华尘世里迷失自我，不至于成为生活的哀悼者，欲望的追随者。
成功有三步曲，第一敏锐的目光，第二果断的行动，第三持续的毅力。用敏锐的目光去发现机遇，用果断的行动去抓住机遇，用持续的毅力去把机遇变成成功。
我们现在活着，就要珍惜自己生命里的每一分每一秒。为什么要珍惜呢?因为我们会死很久很久。
你生病了，第一时间为你买药，带你去看医生的人。在乎的不是钱，看到你生病会很心疼。