说明：变量的赋值与计算都离不开表达式，表达式的运算依赖于变量、常量和运算符。那么我们先说一说什么是表达式。

1、表达式介绍

• Python表达式是变量、常量、运算符、方法调用的序列，它执行指定的计算并返回某个确定的值。
• 表达式不会对程序产生实质性的影响， 一般只是返回一个结果。
• 在Python中，如果在交互模式中只输入一个表达式，解释器会自动将表达式的结果输出。如果是在Python文件中只输入表达式，运行文件都不会有任何输出的。

示例1：交互模式中只写表达式。

在交互模式中只输入一个表达式，解释器会自动将表达式的结果输出，如下图所示：

示例2：Python文件中只写表达式的语句会没有任何输出。

如下图所示：

文件中的100+200和15+7这两个表达式都没有在控制台中输出结果。

2、运算符

运算符用于执行程序代码运算。

（1）运算符的分类

Python的常用运算符分为5类：

• 算数运算符
• 赋值运算符
• 复合赋值运算符
• 比较运算符
• 逻辑运算符

（2）算数运算符

Python中算数运算符如下：

运算符	描述	实例
+	加	1 + 1 输出结果为 2
-	减	1-1 输出结果为 0
*	乘	2 * 2 输出结果为 4
/	除	10 / 2 输出结果为 5
//	整除	9 // 4 输出结果为2
%	取余	9 % 4 输出结果为 1，也叫取模
**	指数	2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2
()	小括号	小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9

注意：混合运算优先级顺序：()高于 ** 高于 * / // % 高于 + -

示例：

# 1、运算符：加、减、乘

# 所有运算中，只要有浮点数参加的运算，一定会得到一个浮点数

a = 10.5 + 5

print(f'a = {a}') # a = 15.5

# 2、运算符：除

# 除法不管得到什么数，结果都是小数（浮点型），//（整除不会）

b = 4 / 2

print(f'b = {b}') # b = 2.0

# 3、运算符：//（整除），只会保留整数位

# 运算结果只会得到一个整型，结果只保留整数部分。

c = 4 // 2

print(f'c = {c}') # c = 2

# 如果除数或被除数是小数，则返回一个浮点数

c = 4.567 // 2

print(f'c = {c}') # c = 2.0

# 4、用变量d的值减去2，然后再赋值给d

d = 10

d = d - 2

print(f'd = {d}') # d = 8

"""

 5、如果将字符串和数字相乘，

    则会对字符串进行复制操作，

    将字符串重复指定次数

 6、如果对字符进行加法运算，

    就是字符串的拼接

"""

e = 'hello' + ' ' + 'world'

print(e) # hello world

f = ('hello' + ' ') * 2

print(f) # hello hello 

# 7、除0异常

g = 5 / 0

# 报出异常：ZeroDivisionError: division by zero

（3）赋值运算符

运算符	描述	实例
=	赋值	将=右侧的结果赋值给等号左侧的变量

（1）单个变量赋值

num = 1

print(num)

（2）多个变量赋值

num1, float1, str1 = 10, 0.5, 'hello world'

print(f"num1 = {num1}")

print(f"float1 = {float1}")

print(f"str1 = {str1}")

# 输出结果如下：

# num1 = 10

# float1 = 0.5

# str1 = hello world

（3）多变量赋相同值

a = b = 10

print(f"a = {a}")

print(f"b = {b}")

# 输出结果如下：

# a = 10

# b = 10

（4）复合赋值运算符

当解释器执行到复合赋值运算符时，先计算算数运算符的表达式，再将算数运算符执行后的结果赋值到等号左边的变量。

复合赋值运算符如下：

运算符	描述	实例
+=	加法赋值运算符	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

示例：

# 输出101  a = a + 1,最终a = 100 + 1

a = 100

a += 1

print(a) # 101

# 输出6  b = b * 3,最终b = 2 * 3

b = 2

b *= 3

print(b)

# 输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3

c = 10

c += 1 + 2

print(c)

# 注意： 先算复合赋值运算符右面的表达式，再算复合赋值运算.

d = 100

d *= 3 + 4

print(d) # 700

# 3 + 4 = 7 * 100 = 700

在对浮点数做算术运算时，结果也会返回一个浮点数。

（5）比较运算符

比较运算符也叫关系运算符，来比较两个值之间的关系，总会返回一个布尔值， 如果关系成立，返回True，否则返回False，通常用来判断。

比较运算符如下：

运算符	描述	实例
==	判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True
!=	不等于 。如果两个操作数的结果不相等，则条件为真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True。如a=1,b=3，则(a != b) 为 True
>	运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7,b=3，则(a > b) 为 True
<	运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False
>=	运算符左侧操作数结果是否大于等于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False。如a=3,b=3，则(a >= b) 为 True
<=	运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假	如a=3,b=3，则(a <= b) 为 True

示例：

# 1、关系运算符基本使用

a = 7

b = 5

print(a == b)  # False

print(a != b)  # True

print(a < b)   # False

print(a > b)   # True

print(a <= b)  # False

print(a >= b)  # True

# 2、数字可以可布尔值比较，True=1，False=0

print(1 == True) # True

print(2 < True) # False

print(-1 < False) # True

# 3、数字和字符串之间不能进行比较

print(2 > '1')

# TypeError: '>' not supported between instances of 'int' and 'str'

"""

# 4、字符串和字符串之间可以进行比较

    在Python中可以对两个字符串进行大于（等于）或小于（等于）的运算时，

    实际上比较的是字符串对应的Unicode编码。

    比较两个字符串的Unicode编码时，是逐位比较的。

    利用该特性可以对字符串按照字母顺序进行排序，但是对于中文来说意义不是特别大。

    注意：如果不希望比较两个字符串的Unicode编码，

    	则需要通过数据类型转换

    	将字符串转换为数值型然后再比较。

"""

#  a(0061) 和 b(0062) 比较

print('a' > 'b') # False

# 比较两个字符串的Unicode编码时，是逐位比较的。

# 也就是第一位和第一位比，第二位和第二位比，

# 只有在第一位没有比出结果的时候（相等），才比第二位。

print('ab' > 'bc') # 实际上就是a和b比较，结果False

print('ab' > 'b') # 同上一句结果

print('af' > 'ac') # True

# 没有肯定小于有字符

print('a' > 'ac') # False

# 将字符串转换成数值型在比较

print(int('5') > int('7')) # False

print(float('5.115') > float('4.64')) # True

"""

 5、== 和 != 比较的是结果对象的值，而不是id。

    对象包括id(地址)、type(类型)、value(值)

    比较id用is 和 is not

    is 比较两个对象是否是同一个对象，比较的是对象的id。

    is not 比较两个对象是否不是同一个对象，比较的是对象的id。

    这里有个印象就可以，以后说完可变对象，再详细说明。

"""

print(1 == True) # True

print(id(1),id(True)) # 8791323868224 8791323365904

print(1 is True) # False

print(1 is not True) # True

3、逻辑运算符

逻辑运算符主要用来做一些逻辑判断。

逻辑运算符如下：

运算符	逻辑表达式	描述	实例
and	x and y	逻辑"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。（一假则假，都真才真）	True and False， 返回 False。
or	x or y	逻辑"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。（一真则真，都假才假）	False or True， 返回 True。
not	not x	逻辑"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。（就是结果取反）	not True 返回 False, not False 返回 True

"""

 1、and 逻辑与 （一假则假，都真才真）

    and可以对符号两侧的值进行与运算。

    只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False

    Python中的与运算是短路的与，也就是说与运算是找False的，

   	如果第一个值为False，则不再看第二个表达式的结果。

"""

print(True and True) # True

print(True and False) # False

print(False and True) # False

print(False and False) # False

# 验证and为短路与，找False结束

# 第一个值是True，会执行print()

True and print('1你猜我出来吗？')

# 第一个值是False，不会执行print()

False and print('2你猜我出来吗？')

"""

 2、or 逻辑或 (一真则真，都假才假)

    or 可以对符号两侧的值进行或运算。

    或运算两个值中只要有一个True，就会返回True。

    Python中的或运算是短路的或， 或运算是找True的，

    如果第一个值为True，则不再看第二个值。

"""

print(True or True) # True

print(True or False) # True

print(False or True) # True

print(False or False) # False

# 验证or为短路或，找True结束

# 第一个值是True，不会执行print()

True or print('1你猜我出来吗？')

# 第一个值是False，会执行print()

False or print('2你猜我出来吗？')

"""

 3、not 逻辑非(取反)

    not可以对符号右侧的值进行非运算

    对于布尔值，非运算会对其进行取反操作，True变False，False变True

    对于非布尔值，非运算会先将其转换为布尔值，然后再取反：

        空性值为False，其他为True。

"""

a = True

# 如果表达式不赋值。不会对变量a有任何影响，

# 只是创建了一个新对象存储了结果，

# 同数据类型转换所讲的

not a

# 对变量a赋值之后，表达是结果才影响变量a。

a = not a

print(f"a = {a}") # a = False

# 4、逻辑运算符左右的表达式加上()，并不会影响运算的结果。

# 为什么要加上(),避免歧义，增加可读性。

a = 1

b = 2

c = 3

print((a < b) and (b < c))  # True

print((a > b) and (b < c))  # False

print((a > b) or (b < c))   # True

print(not (a > b))          # True

拓展1：数字之间的逻辑运算

# 也就是非布尔值的与或运算

#   当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值。

#

#   1、与运算的规则

#       与运算是找False的，

#       如果第一个值是False，则不看第二个值，则直接返回第一个值。（返回0）

#       如果第一个值是True，否则返回第二个值。（看第二个值：False返回0，True返回原值）

#   2、或运算的规则

#       或运算是找True的，

#       如果第一个值是True，则不看第二个值，则直接返回第一个值（原值）。

#       如果第一个值是False，否则返回第二个值。（看第二个值：False返回0，True返回原值） 

a = 0

b = 1

c = 2

# and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字

print(a and b)  # 0

print(b and a)  # 0

print(a and c)  # 0

print(c and a)  # 0

print(b and c)  # 2

print(c and b)  # 1

# or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字

print(a or b)  # 1

print(a or c)  # 2

print(b or c)  # 1

"""

总结：

两种描述都正确，我确认过。

看自己适合哪种理解思路，就用哪种。

"""

拓展2：Python中逻辑运算符可以连续使用

# 逻辑运算符（补充）

# 逻辑运算符可以连着使用

"""

 1 < 2 < 3 的意思不是1小于2同时小于3，

 相当于 1 < 2 and 2 < 3，

 是以中间数值进行比较的

"""

result = 1 < 2 < 3

print(result) # True

# 相当于 10 < 20 and 15 < 20

result = 10 < 20 > 15

print(result) # True

4、Python运算符优先级

• 运算符的优先级可以根据Python官方提供的优先级的表格来查询，
• 在表格中位置越靠下的运算符优先级越高，优先级越高的越优先计算。
• 如果优先级一样则自左向右计算。

Python官方提供的优先级的表格，我们安装好Python的解释器就在本地有一份官方文档了。

官方文档位置：[开始] —> [所有程序] —> [ Python 3.7] —> [Python 3.7 Manuals (64-bit)]。

打开文档：[The Pthon Language Reference] —> [Expressions] —> [ Operator precedence] 即可查看。

如下图所示：

提示：

关于优先级的表格，你知道有这么一个东西就够了，千万不要去记。

在开发中如果遇到优先级不清楚的，主要通过小括号来改变运算顺序。