5. 运算符

常用运算符
1。算术运算符
    1。标准算术运算符
        +加 -减 *乘 /除 //整除
    2。取余运算符
        %
    3。幂运算符
        **
2。赋值运算符
3。比较运算符
4。布尔运算符
5。位运算符

1. 算术运算符 

# 运算符

def calc_num():
    print(1 + 2)   # 3
    print(1 - 1)   # 0
    print(2 * 4)   # 8
    print(5 / 2)   # 2.5
    print(5 // 2)  # 整除 2 5除以2 = 2.5 取整 等于 2
    print(11 % 2)  # 余数 1
    print(2 ** 3)  # 2的3次方 次幂

    print('9//4:', 9 // 4)      # 2
    print('-9//-4:', -9 // -4)  # 2
    print('9%-4:', 9 // -4)     # -3 向下取整 一正一负运算 9除以-4 等于 -2.25 向下取整 等于 -3
    print('-9%4:', -9 // 4)     # -3
    # 无论9整除-4 还是-9整除4的商都是-3

    # 余数 = 被除数-除数*商  a % b = a - b(a//b)
    a = 9
    b = -4
    c = a % b
    d = a - b * (a // b)  # 9-(-4)*(-3) = 9-12 = -3
    print(c, d)           # -3， -3
    print(-9 % 4)         # -9-(4)*(-3) = -9-(-12) = -9+12 = 3


calc_num()

常用运算符表： 

 

2. 赋值运算符

赋值运算符（=）
    1. 执行顺序：从右到左
    2. 支持链式赋值：a = b = c = 20
    3. 支持参数赋值：+=、-=、*=、/=、//=、%=
    4. 支持系列解包赋值：a,b,c = 20,30,40

def calc():
    i = 3 + 4  # 先计算3+4 再赋值给i
    a = b = c = 20  # 内存开辟一块空间存了20。然后 abc都指向同一个id
    print(a, id(a))
    print(b, id(b))
    print(c, id(c))

    a = 20
    a += 30  # 相当于 a=a+30
    print(a, type(a))  # 50
    a -= 10
    print(a, type(a))  # 40
    a *= 2
    print(a, type(a))  # 80 int
    a /= 3
    print(a, type(a))  # 26.666666666666668 float
    a //= 2
    print(a, type(a))  # 13.0 float
    a %= 3
    print(a, type(a))  # 1.0 float
    a, b, c = 10, 20, 30  # 解包左右两边数量需一致
    # 交换变量值
    a, b = 10, 20
    print('before:', a, b)
    a, b = b, a
    print('after:', a, b)

3. 毕竟运算符

比较运算符
>, <, >=, <=, !=
== 对象都value比较
is, is not 对象都id比较

一个等号（=）成为赋值运算符，两个等号（==）比较运算符
一个变量由三部分组成：标识（id)，类型(type)，值(value)
两个等号（==）比较的是值
比较对象的标识使用 is

def compare():
    a, b = 10, 20
    print('a,b:', a, b)
    print('a>b:', a > b)
    print('a<b:', a < b)
    print('a<=b:', a <= b)
    print('a>=b:', a >= b)
    print('a==b:', a == b)
    print('a!=b:', a != b)
    list1 = [11, 22, 33]
    list2 = [11, 22, 33]
    print('list1==list2:', list1 == list2)  # 值相同，所以是True
    print('list1 is list2:', list1 is list2)  # 比较的是id。两个不同的id，所以是 False
    print('list1 is not list2:', list1 is not list2)

 4. 布尔运算符

布尔运算符
and, or, not, in, not in
1. and 两个都为True结果才为True
2。or 由一个为True，结果就是True
3。not 是and运算的结果，然后取反

def bool_test():
    print('---- and 与 同真则真，有假则假 -----')
    a, b = 1, 2
    print(a == 1 and b == 2)  # True   True and True --> True
    print(a == 1 and b < 2)  # False  True and False => False
    print(a != 1 and b == 2)  # False  False and True => False
    print(a != 1 and b != 2)  # False  False and False => False
    print('0 and 2', 0 and 1)  # 0 第一个如果是False 则返回第一个
    print('1 and 2', 1 and 2)  # 2 第一个如果是真，不管第二个是什么，都返回第二个
    print('1 and 0', 1 and 0)  # 1

    print('---- or 或 有真则真，全假则假 -------')
    print(True or True)  # True
    print(True or False)  # True
    print(False or True)  # True
    print(False or False)  # False
    print('0 or 1', 0 or 1)  # 1 第一个是假，不管第二个是什么，都返回第二个
    print('0 or False', 0 or False)  # False
    print('1 or 2', 1 or 2)  # 1 第一个是真，不管第二个是什么，都返回第一个
    print('1 or 0', 1 or 0)  # 1

    print('---- not 非 结果值取反 ---')
    f1 = True
    f2 = False
    print('not f1:', not f1)
    print('not f2:', not f2)

    print('----- in  not in -----')
    print('a' in 'abc')      # True
    print('b' not in 'abc')  # False

5. 位运算符

位运算符：将数据转成二进制进行计算

1. 位与 &：对应数位都是1，结果才为1，否则为0

2. 位或 ｜：对应位数都是0，结果才为0.，否则为1 

3. 左移位运算符 <<：高位溢出舍弃，低位补0

4. 右移位运算符 >>：低位溢出舍弃，高位补0

def bit_test():
    """
    4的二进制：100  8位为： 0 0 0 0 0 1 0 0
    8的二进制：1000 8位为： 0 0 0 0 1 0 0 0
                        ------------------
    4按位与8 结果为：0      0 0 0 0 0 0 0 0
    """
    print('4&8:', 4 & 8)  # 0
    """
    4的二进制：100  8位为： 0 0 0 0 0 1 0 0
    8的二进制：1000 8位为： 0 0 0 0 1 0 0 0
                        ------------------
    4按位或8 结果为：12     0 0 0 0 1 1 0 0
    """
    print('4|8:', 4 | 8)  # 12
    """
    4的二进制：100  8位为： 0 0 0 0 0 1 0 0
    4左移位1 结果为：8     0 0 0 0 1 0 0 0
    4左移位1 相当于4乘以2 移动2位相当于 4*2*2
    """
    print('4<<1:', 4 << 1)  # 8
    """
    4的二进制：100  8位为： 0 0 0 0 0 1 0 0
    4右移位1 结果为：2      0 0 0 0 0 0 1 0 
    4右移位1 相当于4除以2，向下取整 比如5右移1位值为2
    """
    print('5>>1:', 5 >> 1)  # 2

 6.运算符的优先级

 1. 括号优先

 2. 算术运算 

      先乘除再加减，有幂先算幂

 2. 位运算

 3. 比较运算

 4. 布尔运算

 5. 赋值运算