常用运算符

一、进制转换【自学了解】

​ 计算机在内存中以二进制【0和1】的形式存储数据，在二进制的基础上，计算机还支持八进制和十六进制这两种进制

​ 一个二进制表示一个比特(bit)，也称为位，计算机处理数据的最小单位为字节【Byte】,1字节= 8位 ，比如：0010 1010

​ 但是，我们生活中习惯使用十进制，所以当人与计算机之间进行交互的时候就要涉及到进制之间的转换

​ 进制的表示有特定的符号集和进位制：

​ 二进制：0和1，逢二进一

​ 八进制：0~7

​ 十进制：0~9，逢十进一

​ 十六进制：0_9，af/A~F

单位：B,KB,MB,GB,TB,PB,EB…DB

换算关系：1KB = 1024B

1.进制转换原理

• 十进制 —》二进制

  转换原理：对十进制数进行除2运算，直到商为0为止，然后将各个步骤得到的余数倒着写出来

• 二进制—》十进制

  转换原理：把二进制数按权展开、相加即得十进制数（位权，十进制的位权是10，二进制的是2,位置表示法 ，如：345 930 803

  0000 1010----》1 x 2(3) + 1 x 2(1) = 10

  0010 1010----》42

  1001 0110-----》150

• 二进制—》八进制

  转换原理：三位二进制按权展开相加得到1位八进制数，从右向左开始分组，三位为一组，不足时补0

  1001 0110---->010 010 110---->2 2 6—>226

  1010001---->001 010 001---->1 2 1

• 二进制—》十六进制

  ​ 转换原理：与二进制转八进制方法相似，八进制是取三合一，十六进制是取四合一，同样，二进制转成十六进制是从右向左开始分组，四位为一组，不足时补0

  1001 0110---->9 6

  1010001—>0101 0001---->5 1

  1011 1110—>11 14—>b e

  0011 1011---->3 11 —>3b

• 十进制—》八进制或者十六进制

  方法一：把十进制转成二进制x，然后再由二进制转成八进制或者十六进制

  ​方法二：对十进制除以8或者16进行取余，直到商为0为止,类似十进制转二进制

• 八进制或者十六进制—》十进制

​ 转换原理：把八进制或者十六进制按权展开，相加即得十进制

2.原码反码补码

原码：一个数的二进制表示形式，高位表示符号位，0表示正数，1表示负数

反码：在原码的基础上，除了符号位之外，其他位取反

补码：在反码的基础上，加1

注意：正数的原码反码补码是同一个，如：6的二进制为0000 0110，则6的原码反码补码都是0000 0110

10 + （-10） = ？

10：原反补0000 1010

-10：原：1000 1010 反：1111 0101 补：1111 0110

原码：
0000 1010
1000 1010
---------
1001 0100

反码：
0000 1010
1111 0101
---------
1111 1111  

补码：
 0000 1010
 1111 0110
----------
 0000 0000

结论：计算机中存储数据采用的二进制的补码形式
人容易识别都是原码，计算机识别的是补码

-2 + （-3） = ？

3.整数表示

# 二进制，八进制，十进制和十六进制在Python中都可以表示

# 1.二进制
# 表示方式：用0b开头，b:bin
n1 = 0b1010
print(n1)

# 2.八进制
# 表示方式：用0o表示，o:oct
n2 = 0o226
print(n2)

# 3.十进制
n3 = 43
print(n3)

# 4.十六进制
# 表示方式：用0x表示，x:hex
n4 = 0x3b
print(n4)
n41 = 0xef
print(n41)

4.代码实现进制转换

函数	说明
bin(x)	将数字x转换为二进制
oct(x)	将数字x转换为八进制
hex(x)	将数字 x转换为十六进制

# 一、bin,oct,hex：将十进制转换为对应的二进制，八进制和十六进制
a = 10

x1 = bin(a)
x2 = oct(a)
x3 = hex(a)
print(x1,x2,x3)

# 二、int(value,base),base表示进制,也可以将二进制，八进制或者十六进制转换为十进制
print(int("234"))
print(int("234",base=10))
print(int("234",10))

print(int("110",base=10))
print(int("110",base=2))
print(int("110",base=8))
print(int("110",base=16))

#练习题【面试题】
print(int("0b110220",base=16))


# 注意：如果在int中要使用base关键字，则value一般为字符串
# print(int(234,base=10))  #TypeError: int() can't convert转换 non-string with explicit base

5.位运算符

运算符	说明
&	与
|	或
^	异或
~	取反
<<	左移
>>	右移

# 与
print(6 & 3)
print(8 & 3)

# 或
print(6 | 3)
print(8 | 3)

# 异或
print(6 ^ 3 ^ 3)
# 交换两个变量的值
# 方式四：异或
a = 10
b = 20
a = a ^ b   # a = 10 ^ 20
b = a ^ b   # b = 10 ^ 20  ^ 20   = 10
a = a ^ b   #  a = 10 ^ 20 ^ 10 = 20
print(a,b)

# 取反
print(~6)

# 左移与右移
print(6 << 2)
print(8 << 3)

print(6 >> 2)
print(-6 >> 2)

二、运算符和表达式【重点掌握】

1.算术运算符

运算符	说明
+	加
-	减
*	乘
/	除
//	取整
%	求余（取模）
**	求幂

# +  -  *乘  /除    //整除   %求余【取模】   **求幂【求次方】

x = 5
y = 3

# 1.+  -
print(x + y)
print(x - y)

# 2.*  /
print(x * y)
print(x / y)

print(0.4 * 5)  # 2.0
print(10.0 / 2)  # 5.0
print(10 / 2.0)
print(10 / 2)

# 3.//
# 注意：//的结果为/的结果的整数部分，不涉及四舍五入
print(x // y)   # 1


# 4.%
print(x % y)   # 2
print(10 % 3.0)  # 1.0

"""
注意： 
    a.//和%的本质还是进行除法运算
    b.整数和浮点型参与数学运算，结果是浮点型
"""

# 5.**
print(x ** y)
print(y ** x)

# 思考题：算术运算符的优先级问题
# **  >  *  /  // %  >  +  -
print(2 * 5 ** 3)   # 250

2.赋值运算符

运算符	说明
=	简单赋值运算符
+=、-=、*=、/=、%=、//=、**=等	复合赋值运算符

"""
简单赋值运算符：=,作用：主要用于定义变量或给变量赋值
复合赋值运算符：+=  -=  *=  /=  //=  %=  **=，作用：先给变量进行指定的运算，然后给该变量进行重新赋值
"""

# 1.
# 注意：不管=右边的表达式如何复杂，永远都是先计算=右边的表达式的结果，然后给=左边的变量进行赋值
num1 = 10    # 定义变量
num1 = 100   # 重新赋值


# 2.
m = 10
print(m)
# 等价于m = m + 5,先用m加5，然后将结果给m重新赋值
m += 5
print(m)

b = 3
b **= 2
print(b)

c = 10
c %= 2
print(c)

# 练习：
"""
下列哪个语句在Python中是非法的？（）

A. x = y = z = 1

B. x = (y = z + 1)

C. x, y = y, x

D. x = y
"""
x = 2
y = 7
z = 0

# A.同时定义多个变量
x = y = z = 1

# B
x = (y == z + 1)
print(x)

# C.交换两个变量的值
x, y = y, x

# D.给x重新赋值
x = y

3.关系运算符

运算符	说明
==	相等
!=	不相等
<>	不相等
>	大于
<	小于
>=	大于等于
<=	小于等于

# >    >=   <   <=   ==相等   !=不相等


# 关系运算符，也称为比较运算符，也被称为条件运算符
# 注意：关系运算符运算的结果是布尔类型，如果表达式成立则结果是True，如果不成立则结果是False
# 使用场景：一般结合if语句或while循环使用


# 1.
m = 5
n = 10
print(m > n)
print(m >= n)
print(m < n)
print(m <= n)
print(m == n)   # 注意区分=和==的区别
print(m != n)

# 2.支持关系运算符的数据类型
# a.数字
print(45 < 10)

# b.字符串
# 注意：字符串之间能够使用关系运算符进行比较，参照的是ASCII码表
# 在ASCII码表中，"0"---》48  "A"---->65   'a'---->97
print("abc" > "hgf")
print("abc" > "3455728751")

print("0" > "A")  # False

"""
常见ASCII码的大小规则：0~9<A~Z<a~z。
1）数字比字母要小。如 “7”<“F”；
2）数字0比数字9要小，并按0到9顺序递增。如 “3”<“8” ；
3）字母A比字母Z要小，并按A到Z顺序递增。如“A”<“Z” ；
4）同个字母的大写字母比小写字母要小32。如“A”<“a” 。
  几个常见字母的ASCII码大小： “A”为65；“a”为97；“0”为 48 
"""

# 注意：中文字符串之间也可以比较大小，但是没有意义
# print("计算机" < "语文")  # True
# print("计算机" < "大小")  # False

# 中文的编码格式：GBK和utf-8


# 3.扩展：chr()和ord()
# chr(num)获取指定数字在ASCII码表中对应的字符
print(chr(65))   # A
# ord(char)获取指定字符在ASCII码表中对应的数字
print(ord("A"))  # 65

# 练习：从控制台输入一个小写字母，转化为对应的大写字母，最后输出
ch = input("请输入一个小写字母：")
# n1 = ord(ch)
# n2 = n1 - 32
# ch1 = chr(n2)
# print(ch1)

print(chr(ord(ch) - 32))

4.逻辑运算符

逻辑运算符是用来做逻辑计算的，就像之前用到的比较运算符 ，每一次比较其实就是一次条件判断，都会得到一个相应的True或者False的值，而逻辑运算符的操作数就是一个用来做条件判断的表达式或者变量

运算符	说明
and	与
or	或
not	非

重点：短路原则

a.A and B,如果A为False，不需要计算B的值，整个表达式的结果为False

b.A or B,如果A为True，不需要计算B的值，整个表达式的结果为True

c.and和or混合使用

​ 1>表达式从左往右运算，如果or的左侧为True，则会短路or后面所有的表达式【不管是and还是or连接】，整个表达式的结果为True

​ 2>表达式从左往右运算,如果and的左侧为False,则短路后面所有的and，直到or出现，接着计算

​ 3>如果or的左侧为False，或者and的左侧为True，则不能使用短路逻辑判断

注意：所有被短路的表达式均不会被输出

# and  or   not
# 主要用于逻辑判断，结合if语句使用较多


# 1.and：与
"""
真  and 真 = 真
真  and 假 = 假
假  and 真 = 假
假  and 假 = 假

规律：一假为假，全真为真

假：0   0.0   ""   []  ()  {}   None   False等表示空或没有的数据
"""
print(True and False)
print(True and 0)   # 0
print(True and [])  # []

print(True and "abc")
print(True and 10)
print(True and True)

print("*" * 30)

print(False and True)
print(0.0 and True)
print([] and "abc")

print(False and 0)
print(0.0 and 0)
print([] and 0)

"""
总结：
    A   and   B
    
    如果A为真，则A  and B的结果是B
    如果A为假，则A  and B的结果是A，在这种情况下，B不参与运算，被称为短路原则
"""

print("*" * 50)


# 2.or
"""
真  or 真 = 真
真  or 假 = 真
假  or 真 = 真
假  or 假 = 假

规律：一真为真，全假为假
"""
print(True or False)
print(True or 0)
print(True or [])

print(True or "abc")
print(True or 10)
print(True or True)

print("*" * 30)

print(False or True)
print(0.0 or True)
print([] or "abc")

print(False or 0)
print(0.0 or 0)
print([] or 0)

"""
总结：
    A   or   B

    如果A为真，则A  or B的结果是A,在这种情况下，B不参与运算，被称为短路原则
    如果A为假，则A  or B的结果是B
"""


# 3.not
"""
not  真  = 假
not  假 = 真
"""
print(not "abc")
print(not 0.0)

"""
总结：
    a.and和or运算的结果不一定是布尔值
    b.not运算的结果肯定是布尔值
"""

print("*" * 30)


# 4.短路原则
"""
a.A and B,如果A为False，不需要计算B的值，整个表达式的结果为False
b.A or B,如果A为True，不需要计算B的值，整个表达式的结果为True
c.and和or混合使用
	1>表达式从左往右运算，如果第一个运算符是or，or的左侧为True，则会短路or后面所有的表达式【不管是and还是or连接】，整个表达式的结果为True

	2>表达式从左往右运算,如果第一个运算符是and,and的左侧为False,则短路后面所有的and，直到or出现，接着计算

	3>如果or的左侧为False，或者and的左侧为True，则不能使用短路逻辑判断
"""
# a.and
print(False and True and False and False and True and True)  # False

print(True and True and False and False and True and True)   # False
"""
True and True and False and False and True and True
True and False and False and True and True
False and False and True and True
"""

# b.or
print(True or False or False or True or True)      # True

print(False or False or False or True or True)     # True

# c.and和or
print(True or True and False or False or True and True and False or True)   # True

print(False and True and False and False or True and True and False or True)
"""
False and True and False and False or True and True and False or True
False or True and True and False or True
True and True and False or True
True and False or True
False or True ---->True
"""

5.成员运算符

in：如果在指定的序列中找到值，则返回True，否则返回False

not in:如果在指定的序列中没有找到值，则返回True，否则返回False

# in    not  in


# in:判断一个对象是否在某个可迭代对象中
# not  in：判断一个对象是否不在某个可迭代对象中

# 注意：成员运算符运算的结果都是布尔值

# 可迭代对象：字符串，列表，元组，字典，集合等

# 使用场景：一般结合if语句使用，用于条件

print("a" in "abc")
print("a" not in "abc")

print(10 in [3,5,67])
print(10 not in [3,5,67])

6.身份运算符

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

​ is:判断两个标识符是不是引用自一个对象

​ is not:判断两个标识符是不是引用自不同对象

# is      is not

# is:判断两个变量是否引用自同一个对象
# is not :判断两个变量是否引用自不同的对象

# 解释：is和is not 用于判断两个变量是否存储的是同一个数据的地址


# 1.不可变数据类型：int   float   str  tuple  bool
a = 10
b = 10
print(a is b)
print(id(a) == id(b))
print(a == b)

a = 10
b = 20
print(a is b)
print(id(a) == id(b))
print(a == b)

print("*" * 30)

# 2.可变数据类型:list   dict   set
a = [10]
b = [10]
print(a is b)
print(id(a) == id(b))
print(a == b)

a = [10]
b = [20]
print(a is b)
print(id(a) == id(b))
print(a == b)

"""
【面试题】is和==的区别和联系
    a.==比较的是变量的值是否相同
    b.is比较的是变量的地址是否相同
    c.如果两个变量的地址相同，则这两个变量的值一定相同，如果两个变量的值相同，则地址不一定相同  
"""

7.三元运算符

三元运算符也可以被称为三目运算符

Java或者js中都有三目运算符：变量 = 表达式 ? 值1 ：值2

但是，Python中实际没有三元运算符，只不过可以通过可以通过if-else语句或者逻辑运算符进行模拟

# 三元运算符：实现二选一

# 1.逻辑运算符:少用
# 语法：条件  and  a  or b
# 工作原理：假设a和b都为真，如果条件为真，则整个表达式的值为a，如果条件为假，则整个表达式的值为b

# 需求：从控制台输入一个数，判断该数是否是偶数
num = int(input("请输入一个数："))
r1 = num % 2 == 0 and "偶数" or "奇数"
print(r1)

r2 = num % 2 == 0 and True or False
print(r2)

r3 = num % 2 == 0 and 1 or 0
print(r3)

# r4 = num % 2 != 0 and 0 or 1
# print(r4)


# 2.if-else语句：常用

8.运算符优先级

​ 当出现一个复杂的表达式，有可能多种运算符会混合在一起运算，就会涉及到运算符的优先级。具体如下：

注意：在实际项目开发中，当多种运算符进行混合运算时，强烈建议使用小括号来手动控制运算符的优先级，并且尽量将复杂的问题简单化，尽量分步执行