目录
上一篇：
一、Python的运算符
Python支持以下类型的运算符:
(1)、算术运算符：主要用于两个对象数值计算(加减乘除等)
(2)、比较(关系)运算符：用于两个对象比较(判断是否相等、大于等运算)
(3)、赋值运算符：用于对象的赋值，将运算符右边的值(或计算结果)赋给运算符左边
(3)、逻辑运算符：用于逻辑运算(与/或/非)
(4)、位运算符： bit操作
(5)、成员运算符：判断一个对象是否包含另一个对象
(6)、身份运算符：判断是不是引用自身一个对象
1. 算术运算符
| 运算符 |
描 述 |
| + |
加号运算符 支持两个对象相加(变量、列表等等) |
示例：
#!/usr/bin/python3
a=1
b=2
c=a+b
print("c=%d" % (c))
list1=[5,6,7,8]
list2=['a','b','c','d']
list3=list1+list2
print("list3的值:",list3)结果：
| c=3 列表3的值: [5, 6, 7, 8, 'a', 'b', 'c', 'd'] |
| 运算符 |
描 述 |
| - |
减号运算符 注意只能是数值之间的相减。 |
示例：跟加法类似
| 运算符 |
描 述 |
| * |
乘号运算符 字符串的乘法：视为重复运算 |
实例：
#!/usr/bin/python3
a=1
b=2
c=a*b
print("c=%d" % (c))
d='hello'
print("d:",d*3)结果：
| c=2 d: hellohellohello |
| 运算符 |
描 述 |
| / |
除运算符 |
实例：
| a=1 b=2 c=a/b print("c=%d" % (c)) |
结果：
| c=0 |
注意，这里是格式化输出。假如直接输出数值()，则结果如下：
| #!/usr/bin/python3 a=1 b=2 c=a/b print("c:", c) #0.5 #print("c=%f" % (c)) #0.5 |
Python2和python3的除法运算有区别：
(1) Python2的除法/运算，跟C语言类似，两个整数相除的结果是一个整数【忽略掉小数部分】，如果是两个浮点数相除，结果就是浮点数，当然要注意输出是否格式化。
(2) Python3的除法：两个整数相除的结果是一个浮点数。
因此在实际应用中要注意，有可能python会报错：数值类型不对、数值越界等问题。
对于有些项目报错的解法，就是把/改成//。--->tensorflow+keras
| 运算符 |
描 述 |
| % |
取余(取模)运算符 返回除法的余数 |
实例：
| #!/usr/bin/python3 a=3 b=2 c=a%b print("c:", c) #c的值为1 |
| 运算符 |
描 述 |
| ** |
幂运算符 返回x的y次方 |
| 运算符 |
描 述 |
| // |
取整除运算符 向下取接近除数的整数 |
实例：
| #!/usr/bin/python3 a=10 b=4 c=a//b print("c:", c) #c的值为2 |
2. 比较运算符
| 运算符 |
描 述 |
| == |
等于运算符。
字符串也是一个对象，因此可以使用==判断两个字符串是否相等。
|
实例：
| #!/usr/bin/python3 a=50 b=50 if(a==b): print("a==b") else: print("a!=b") list1="是123" list2="是123" if(list1==list2): print("list1==list2") else: print("list1!=list2") list3="是123" list4="是124" if(list3==list4): print("list3==list4") else: print("list3!=list4") |
结果：
| a==b list1==list2 list3!=list4 |
| 运算符 |
描 述 |
| != |
不等于运算符。 比较两个对象是否不相等。 不相等返回True 真 相等返回False 假 |
示例：类似==
| 运算符 |
描 述 |
| > |
大于运算符。 返回x是否大于y，大于返回True 真，小于返回False 假 一般用于两个数值之间的比较。 |
| 运算符 |
描 述 |
| < |
小于运算符。 返回x是否小于y，所有比较运算符返回1表示真，返回0表示假。 |
| 运算符 |
描 述 |
| >= |
大于等于运算符。 返回x是否大于等于y。 |
| 运算符 |
描 述 |
| <= |
小于等于运算符。 返回x是否小于等于y。 |
3. 赋值运算符
| 运算符 |
描 述 |
| = |
简单的赋值运算符 最常用的运算符 |
| 运算符 |
描 述 |
| += |
加法赋值运算符 |
| 运算符 |
描 述 |
| -= |
减法赋值运算符 |
| 运算符 |
描 述 |
| *= |
乘法赋值运算符 |
| 运算符 |
描 述 |
| /= |
除法赋值运算符 |
| 运算符 |
描 述 |
| %= |
取模赋值运算符 |
| 运算符 |
描 述 |
| **= |
幂赋值运算符 |
| 运算符 |
描 述 |
| //= |
取整除赋值运算符 |
| 运算符 |
描 述 |
| := |
海象运算符 可在表达式内部直接为变量赋值。 Python3.8 版本新增运算符。 |
实例：在这个示例中，赋值表达式可以避免调用 len() 两次。
| #!/usr/bin/python3 #使用海象运算符的代码写法 a="1234567890" if (n := len(a)) >= 10: print(f"\"{a}\"的长度={n},大于等于10") else: print(f"\"{a}\"的长度={n},小于10")
#不使用海象运算符的代码写法 a="1234567890" n== len(a) if n >= 10: print(f"\"{a}\"的长度={n},大于等于10") else: print(f"\"{a}\"的长度={n},小于10")
#不使用海象运算符的代码写法 a="1234567890" if len(a) >= 10: print(f"\"{a}\"的长度={len(a)},大于等于10") else: print(f"\"{a}\"的长度={len(a)},小于10") |
4. 位运算符
| 运算符 |
描 述 |
| & |
按位与运算符： 参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
| 运算符 |
描 述 |
| | |
按位或运算符： 只要对应的二个二进位有一个为1时，结果位就为1。 |
| 运算符 |
描 述 |
| ^ |
按位异或运算符： 只要对应的二个二进位相同结果为0，不同结果为1 |
| 运算符 |
描 述 |
| ~ |
按位取反运算符： 对数据的每个二进制位取反,即把1变为0,把0变为1。 在二进制码中,为了区分正负数,采用最高位是符号位的方法来区分。 正数的符号位为0、负数的符号位为1 剩下的就是这个数的绝对值部分,可以采用原码、反码、补码3种形式来表示绝对值部分。 原码: 用来转换对应进制. 反码: 二进制码0变1,1变0叫做反码,反码用于原码补码之间的转换.(符号位不变)。 补码: 用来做数据的存储运算. 补码提出的根源是让计算机底层的实现减法操作(可以表达出一个数的正负)。 原码 反码 补码之间的转换：符号位不要动 正数: 原码 = 反码 = 补码 负数: 原码 = 补码取反加1 负数: 补码 = 原码取反加1 |
实例：
| #!/usr/bin/python3 a=0x17 print("~a:%x"%(~a))#-18(0x)--->-0x18 |
| 结果：a:-18 17的二进制: 0001 0111 取反结果 : 1110 1000 //发现最高位为1，该数是负数。 -------------------------------------- 0001 0111+1 补码：取反+1 00011000 原码=-0x18 --------------------------------------- |
| 运算符 |
描 述 |
| << |
左移运算符： 运算数的各二进位全部左移若干位 左边溢出，右边补0 (左边为高位，右边为低位) |
| 运算符 |
描 述 |
| >> |
右移运算符： 运算数的各二进位全部右移若干位 右边溢出，左边补0 (左边为高位，右边为低位) |
5. 逻辑运算符
| 运算符 |
逻 辑 |
描 述 |
| and |
x and y |
逻辑"与" 如果 x 为 False，x and y 返回 False 否则它返回 y 的值。 |
| 运算符 |
逻 辑 |
描 述 |
| or |
x or y |
逻辑"或" 如果 x 是 True，它返回 x 的值 否则它返回 y 的值。 |
| 运算符 |
逻 辑 |
描 述 |
| not |
not x |
逻辑"非" 如果 x 为 True，返回 False 如果 x 为 False，它返回 True。 非0即为真。 负数、小数都为真。 |
6. 成员运算符
判断一个对象是否包含另一个对象。包括字符串，列表或元组。
| 运算符 |
描 述 |
| in |
如果在指定的序列中找到值返回 True 否则返回 False。 |
实例：如果x在y序列中返回 True
| #!/usr/bin/python3 x=10 y=[12,34,56,78,10] if(x in y): print("x在y列表中") else: print("x不在y列表中") x=100 y=[12,34,56,78,10] if(x in y): print("x在y列表中") else: print("x不在y列表中") x=10 y=(12,34,56,78,10) if(x in y): print("x在y元组中") else: print("x不在y元组中")
x="python" y="My name is python" if(x in y): print("x在y字符串中") else: print("x不在y字符串中") |
结果：
| x在y列表中 x不在y列表中 x在y元组中 x在y字符串中 |
| 运算符 |
描 述 |
| not in |
如果在指定的序列中没有找到值返回 True 否则返回 False。 |
实例：如果x不在 y序列中返回 True
| #!/usr/bin/python3 x=10 y=[12,34,56,78,10] if(x not in y): print("x不在y列表中") else: print("x在y列表中") x=100 y=[12,34,56,78,10] if(x not in y): print("x不在y列表中") else: print("x在y列表中") x=10 y=(12,34,56,78,10) if(x not in y): print("x不在y元组中") else: print("x在y元组中") x="python" y="My name is python" if(x not in y): print("x不在y字符串中") else: print("x在y字符串中") |
结果
| x在y列表中 x不在y列表中 x在y元组中 x在y字符串中 |
7. 身份运算符
身份运算符用于比较两个对象的存储单元。
| 运算符 |
描 述 |
| is |
is是判断两个标识符是不是引用同一个对象 is与==的区别就是，is是内存中的比较，而==是值的比较 |
实例：x is y , 如果引用的是同一个对象则返回 True，否则返回 False
is是使用 id() 函数查看对象地址是否相同。
| #!/usr/bin/python3 x=10 y=10 if(x is y): print("x,y引用相同") else: print("x,y引用不相同") x=10 y=20 if(x is y): print("x,y引用相同") else: print("x,y引用不相同") x=[10,24] y=[10,24] z=x if(x is y): print("x,y引用相同") else: print("x,y引用不相同")
if(x is z): print("x,z引用相同") else: print("x,z引用不相同") |
结果：
| x,y引用相同 x,y引用不相同 x,y引用不相同 x,z引用相同 |
| 运算符 |
描 述 |
| is not |
is not 是判断两个标识符是不是引用不同对象 |
实例：x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
| #!/usr/bin/python3 x=10 y=10 if(x is not y): print("x,y引用不相同") else: print("x,y引用相同") x=10 y=20 if(x is not y): print("x,y引用不相同") else: print("x,y引用相同") x=[10,24] y=[10,24] z=x if(x is not y): print("x,y引用不相同") else: print("x,y引用相同")
if(x is not z): print("x,z引用不相同") else: print("x,z引用相同") |
结果：
| x,y引用相同 x,y引用不相同 x,y引用不相同 x,z引用相同 |
8. 运算符的优先级
所谓运算符的优先级，指的是在含有多个逻辑运算符的式子中，到底应该先计算哪一个，后计算哪一个，这与数学中四则运算应遵循“先乘除后加减”是一个道理。
Python 中运算符的运算规则是，优先级高的运算符先执行，优先级低的运算符后执行，同一优先级的运算符按照从左到右的顺序进行。需要注意的是，Python 语言中大部分运算符都是从左向右执行的，只有单目运算符（例如 not 逻辑非运算符）、赋值运算符是从右向左执行的。注意python中没有三目运算符(true/false)?a:b
下面表格里按照优先级从高到底的顺序，列出了包括分隔符在内的所有运算符的优先级顺序：数字越大，优先级越高。
| 运算符说明 |
Python运算符 |
优先级 |
| 小括号 |
() |
20 |
| 索引运算符 |
x[index] 或 x[index:index2[:index3]] |
18、19 |
| 属性访问 |
x.attrbute |
17 |
| 乘方 |
** |
16 |
| 按位取反 |
~ |
15 |
| 符号运算符 |
+（正号）或 -（负号） |
14 |
| 乘、除 |
*、/、//、% |
13 |
| 加、减 |
+、- |
12 |
| 位移 |
>>、<< |
11 |
| 按位与 |
& |
10 |
| 按位异或 |
^ |
9 |
| 按位或 |
| |
8 |
| 比较运算符 |
==、!=、>、>=、<、<= |
7 |
| is 运算符 |
is、is not |
6 |
| in 运算符 |
in、not in |
5 |
| 逻辑非 |
not |
4 |
| 逻辑与 |
and |
3 |
| 逻辑或 |
or |
2 |
上面表格中运算符的优先级，我们分析 4+4<<2 语句的执行结果，程序会先执行 4+4 得到结果 8，再执行 8<<2 得到 32。如果使用“()”就可以改变程序的执行顺序，比如 4+(4<<2)，则先执行 4<<2 得到结果16，再执行 4+16 得到 20。
虽然 Python 运算符存在优先级的关系，但并不推荐过度依赖运算符的优先级，因为这会导致程序的可读性降低。因此，代码基本共识：
(1) 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。
(2) 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用“()”来控制表达式的执行顺序。
下一篇：