Python 之路之 运算符 (三)

• 1.算数运算符
• 2.赋值运算符
• 3.比较运算符
• 4.逻辑运算符
• 5.逻辑运算的短路
• 6.位运算符

1.算数运算符

• + 加
• - 减
• * 乘
• / 除
• ** 幂
• // 整除
• % 取余

eg:

>>> print(1 + 1)    #2
2
>>> print(4 - 2)    #2
2
>>> print(2 * 2)    #4
4
>>> print(4 / 2)    #2.0
2.0
#在 Python3 里，两个整数相除会是一个浮点数
>>> print(2 ** 4)   #8
8
>>> print(2 ** 4)   #16 = 2^4 2 的 4 次方
16
>>> print(64 ** (1 / 2))    #8.0 = 64^0.5 有运算优先规则
8.0
>>> print(type(10 / 3))     #3.333····  float 浮点型
<class 'int'>
>>> print(type((10 // 3)))  #3 取整   int 整型
<class 'float'>
>>> print((11 % 3))     #取余数
2
>>> print(19 % 20)      #取余，只要前者小于后者，余数都是前者
19

在字符串里只有限度的支持 加法 和 乘法 运算符；数字不支持和字符串相加

eg:

#加法运算符：拼接二个字符串
>>> print('Jay' + 'Chou')
JayChou

#乘法运算符：将字符串重复 N 次
>>> print('Jay' * 3)
JayJayJay

2.赋值运算符

• = 赋值

等号赋值是将等号右边的值赋值给左边 (a = 1)，不能将左边的值赋值给右边。等号左边一定不能是 常量 (1 = a)或 表达式 (1 + 1 = a)

>>> a = 1
>>> a = a + 1       #会先将上一步的 a = 1 代入，第二步的 a + 1，再赋值给 a
>>> a += 2          #a = a + 1 ==> a += 1 结果一致，同理 a = a - 1 ==> a -= 1
>>> print(a)
2

#a = a + 1  #3      2+1
#a += 1     #3      2+1
#a -= 1     #1      2-1
#a *= 1     #2      2*1
#a /= 1     #2.0    2/1
#a **= 2    #1      1^2
#a %= 1     #0      1%1

特殊场景

#等号连接的赋值可以传递
>>> b = c = d = 'JayChou'
>>> print(b, c, d)
JayChou JayChou JayChou

#拆包赋值 (变量 和 值 数量需要相等哈，左边 2 个，右边就必须是 2 个)
>>> e, f = 'Jay', 'Chou'
>>> print(e, f)
Jay Chou        #e = Jay; f = Chou
#可变长度赋值
>>> *g, h, i = 1, 2, 3, 4, 5, 6     #g 是可变长度，多的值都会赋给 g
>>> print(g, h, i,)
[1, 2, 3, 4] 5 6
#h是可变的话，1 [2, 3, 4, 5] 6

3.比较运算符

• > 大于
• < 小于
• >= 大于等于
• <= 小于等于
• != 不等于 或 <> 但是 3.7+ 版本不再支持这个写法 <>

>>> print(3 > 2)
True
>>> print(2 > 3)
Fasle
>>> print(3 >= 2)
True
>>> print(2 <= 3 )
True
>>> print(2 != 3)
True

在字符串里的比较运算符运用，通过字符的编码值逐一进行比较 (ASCII) 码表

(ASCII) 码表

>>> print('a' > 'b')
#a:97 > b:98
False
>>> print('abc' > 'b')
#逐一比较， a > b 不成立，就直接返回 False
False
>>> print('a' == 96)
#数字和字符串之间的 == 运算结果都是 False
False
>>> print('a' != 97)
#数字和字符串之间的 != 运算结果都是 True
True

4.逻辑运算符

• and 和
• or 或
• not 非

and

>>> print(2 > 1 and 10 > 1)     #True and True -> True  全是 True 才是 True
True
>>> print(1 < 2 and 1 > 10)     #True and False -> False 只要有一个是 False 就都是 False
False

or

>>> print(2 > 1 or 1 > 2)   #True or False -> True 只要有一个是 True 就是 True
True
>>> print(1 > 2 or 2 > 3)   #False or False -> False 全是 False 才是 False
False

not

>>> print(not (2 > 1))      #将 True 变为 False，将 False 变为 True
False
>>> print(not (1 > 2))
True

5.逻辑运算的短路

>>> 2 > 1 and print('Jay Chou')     #and 全是 True，才是 True。第一个是 True 会继续走第二个，所以会打印
>>> 2 < 1 and print('周杰伦')      #and 全是 True，下一步就不会再走，理解为短路
Jay Chou

>>> 2 > 1 or print('Jay Chou')      #or 只要有一个是 True 就会返回 True，所以 or 后就不再执行
>>> 2 < 1 and print('周杰伦')      #or 全是 False 才是 False，第一个是 False 走完，继续走第二个，所以只会打印第二个
周杰伦

#逻辑 和 运算做取值为 and 时，取第一个为 False 的值，如果所有的运算数都是 True，取最后一个值
>>> print(1 and 2 and 0 and 'Jay')
0
#1 为 True， 2 为 True， 0 为 False，取 0 且不再继续走下去
>>> print(1 and 2 and 3 and 'Jay')
Jay

#逻辑 或 运算做取值为 or 时，取第一个为 True 的值，如果所有的运算数都是 False，取最后一个值
>>> print(0 or None or [] or '1' or {})
1
#0 为 False，None 为 False，[]空列表 为 False，1 为 True，取 1 且不再继续走下去
>>> print(0 or None or [] or {})
{}

6.位运算符

• & 按位与
• | 按位或
• ^ 按位异
• << 按位左移
• >> 按位右移
• ~ 按位取反

>>> j = 23
>>> k = 15
>>> print(j & k)
7
>>> print(bin(23))
0b10111
>>> print(bin(15))
0b1111
#按位与：同为 1 则为 1，否则为 0
#0001 0111
#0000 1111
#0000 0111
>>> print(0b00000111)
7

>>> print(j | k)
31
#按位或：只要有一个为 1，就为 1
#0001 0111
#0000 1111
#0001 1111
>>> print(0b00011111）
31

>>> print(j ^ k)
24
#按位异或：相同为 0，不同则为 1
#0001 0111
#0000 1111
#0001 1000
>>> print(0b00011000)
24

>>> l = 31
>>> print(l << 3)
248
#左移就是往左边移动 3 位; l << n ==> l * 2^n ==> 31 * 2^3 = 31 * 8 = 248
>>> print(0b00011111)
31
>>> print(0b00011111000)
248

>>> m = 31
>>> print(m << 2)
7
#右移就是往右边移动 3 位，且截掉超过的那一部分。m >> n ==> m / 2^n ==> 31 / 2^2 ==> 31 / 4 = 7
256 128 64 32 16 8 4 2 1 | (2^x次方)
      0  0  0  1 1 1 1 1 | 
            0  0 0 1 1 1 | 1 1
>>> print(0b00000111)
7

Over~

1261 0 2021-01-20

打赏一下，各位朋友请随意打赏！

×

如果觉得我的文章对你有用，请随意赞赏

取消