目录
一、运算符
1、了解定义
2、理解意义
2-1、基本数据处理
2-2、条件判断
2-3、逻辑操作
2-4、赋值和更新
2-5、位操作
2-6、提高代码可读性
2-7、解决实际问题
2-8、学习其他编程语言的基础
3、探索方法
3-1、理解概念
3-2、练习基本运算
3-3、掌握优先级
3-4、阅读文档和教程
3-5、编写实际程序
3-6、参加编程社区
3-7、练习编程题
3-8、反思和总结
4、梳理分类
4-1、算术运算符
4-1-1、定义
4-1-2、分类
4-1-2-1、加法运算符(+)
4-1-2-2、减法运算符(-)
4-1-2-3、乘法运算符(*)
4-1-2-4、除法运算符(/)
4-1-2-5、整除运算符(//)
4-1-2-6、取模运算符(%)
4-1-2-7、幂运算符(**或**=)
4-1-2-8、一元加号(+)
4-1-2-9、一元减号(-)
4-2、比较运算符
4-2-1、定义
4-2-2、分类
4-2-3、优先级
4-3、赋值运算符
4-3-1、定义
4-3-2、分类
4-3-3、示例
4-4、位运算符
4-4-1、定义
4-4-2、分类
4-4-2-1、位与(&)
4-4-2-2、位或(|)
4-4-2-3、位异或(^)
4-4-2-4、位取反(~)
4-4-2-5、左移(<<)
4-4-2-6、右移(>>)
4-4-3、优先级
4-5、逻辑运算符
4-5-1、定义
4-5-2、分类
4-5-2-1、逻辑与(and)
4-5-2-2、逻辑或(or)
4-5-2-3、逻辑非(not)
4-5-3、优先级
4-6、身份运算符
4-6-1、定义
4-6-2、分类
4-6-2-1、是(is)
4-6-2-2、不是(is not)
4-6-3、优先级
4-7、成员运算符
4-7-1、定义
4-7-2、分类
4-7-2-1、在...内(in)
4-7-2-2、不在...内(not in)
4-7-3、优先级
4-8、三元运算符
4-8-1、定义
4-8-2、语法
4-8-3、示例
5、明确优先级
二、推荐阅读
1、Python函数之旅
2、Python算法之旅
3、博客个人主页
一、运算符
1、了解定义
Python中的运算符是用于执行各种算术或逻辑运算的符号，它们允许你对一个或多个值(或变量)进行运算，并返回一个新的值。
2、理解意义
学习Python中的运算符是非常重要的，因为它们构成了编程语言的基石，使得我们能够对数据进行各种操作、比较和逻辑判断。
2-1、基本数据处理
运算符允许我们执行基本的数学运算，如加、减、乘、除等，这对于处理数字数据至关重要。
2-2、条件判断
比较运算符(如等于、不等于、大于、小于等)使我们能够比较两个值的大小或关系，从而进行条件判断，这对于编写条件语句(如if、elif、else)和循环结构(如for、while)非常重要。
2-3、逻辑操作
逻辑运算符(如and、or、not)允许我们组合多个条件判断，以实现更复杂的逻辑操作，这对于编写健壮、灵活的代码至关重要。
2-4、赋值和更新
赋值运算符(如=、+=、-=等)使我们能够将计算结果存储在变量中，以便后续使用或更新，这是编程中不可或缺的一部分。
2-5、位操作
位运算符(如&、|、^、<<、>>)允许我们直接操作数据的二进制表示，这在处理底层数据或优化性能时非常有用。
2-6、提高代码可读性
掌握运算符的优先级和用法有助于编写更易于阅读和理解的代码，当其他人(或未来的你)查看你的代码时，能够迅速理解每个表达式的作用和目的。
2-7、解决实际问题
通过运用各种运算符，我们可以编写能够解决实际问题的程序，无论是简单的数学计算、数据处理任务还是复杂的逻辑判断，运算符都是实现这些功能的关键。
2-8、学习其他编程语言的基础
虽然不同编程语言的语法和特性可能有所不同，但运算符的基本概念和用法通常是相似的，因此，学习Python中的运算符可以为学习其他编程语言打下坚实的基础。
总之，学习Python中的运算符是掌握编程语言基础的重要一步，通过深入了解各种运算符的特性和用法，我们可以编写出更高效、更可靠的代码，并解决各种实际问题。
3、探索方法
要学好Python中的运算符，你可以遵循以下几个步骤和策略：
3-1、理解概念
首先，你需要理解运算符的基本概念、种类和用途，这包括算术运算符、比较运算符、逻辑运算符、赋值运算符、位运算符等，了解它们的功能和用法是学好运算符的基础。
3-2、练习基本运算
通过编写简单的Python代码来练习各种运算符的使用。例如，你可以编写程序来执行加、减、乘、除等算术运算，或使用比较运算符来进行条件判断，这样的练习有助于你熟悉运算符的语法和用法。
3-3、掌握优先级
了解运算符的优先级规则对于编写正确的代码至关重要，你需要知道哪些运算符会先被计算，哪些运算符的优先级较低，通过练习包含多个运算符的表达式，你可以加深对优先级规则的理解。
3-4、阅读文档和教程
Python的官方文档和在线教程是宝贵的学习资源，阅读相关文档和教程可以深入了解运算符的详细用法、注意事项和最佳实践，这些资源通常包含示例代码和解释，有助于你更好地理解和应用运算符。
3-5、编写实际程序
将所学的运算符知识应用到实际编程项目中，通过编写具有实际功能的程序，你可以更深入地理解运算符的用途和重要性；同时，这也可以帮助你发现问题并加深对运算符的理解。
3-6、参加编程社区
加入Python编程社区，与其他编程爱好者交流和分享经验。在社区中，你可以提出问题、寻求帮助并分享你的解决方案，与其他人的互动可以帮助你更快地解决问题并提高编程能力。
3-7、练习编程题
通过解决编程练习题来巩固所学的运算符知识，这些题目可以来自在线编程平台、书籍或课程，通过解决不同难度和类型的题目，你可以提高你的编程技能和解决问题的能力。
3-8、反思和总结
在学习过程中，不断反思和总结自己的学习经验，思考你在学习运算符时遇到的困难、解决问题的方法以及你的收获，这样的反思和总结有助于你更好地理解学习内容并提高学习效率。
总之，学好Python中的运算符需要理解概念、练习基本运算、掌握优先级、阅读文档和教程、编写实际程序、参加编程社区、练习编程题以及反思和总结，通过不断努力和实践，你可以逐步掌握Python中的运算符并成为一名优秀的Python程序员。
4、梳理分类
4-1、算术运算符
4-1-1、定义
在Python中，算术运算符(Arithmetic Operators)是用于执行数学运算的符号。
4-1-2、分类
4-1-2-1、加法运算符(+)
# 1-1、加法运算符(+)
# 用于将两个或多个数相加
a = 5
b = 3
c = a + b
print(c) # 输出：8
4-1-2-2、减法运算符(-)
# 1-2、减法运算符(-)
# 用于从一个数中减去另一个数。
a = 5
b = 3
c = a - b
print(c) # 输出：24-1-2-3、乘法运算符(*)
# 1-3、乘法运算符(*)
# 用于将一个数与另一个数相乘
a = 5
b = 3
c = a * b
print(c) # 输出：154-1-2-4、除法运算符(/)
# 1-4、除法运算符(/)
# 用于将一个数除以另一个数，结果是一个浮点数(除非两个数都是整数并且结果也是整数，Python 3会返回浮点数)
a = 5
b = 3
c = a / b
print(c) # 输出：1.6666666666666667
print(type(c)) # 输出：<class 'float'>
d = 4
e = 2
f = d / e
print(f) # 输出：2.0
print(type(f)) # 输出：<class 'float'>4-1-2-5、整除运算符(//)
# 1-5、整除运算符(//)
# 也称为地板除法，用于将一个数除以另一个数并返回商的整数部分(向下取整)
a = 5
b = 3
c = a // b
print(c) # 输出：1
print(type(c)) # 输出：<class 'int'>4-1-2-6、取模运算符(%)
# 1-6、取模运算符(%)
# 用于计算两个数相除的余数
a = 5
b = 3
c = a % b
print(c) # 输出：24-1-2-7、幂运算符(**或**=)
# 1-7、幂运算符(**或**=)
# 用于计算一个数的幂(乘方)，**=是幂运算符的赋值版本，它直接改变左侧变量的值
a = 5
b = 2
c = a ** b
a **= 2
print(c) # 输出：25
print(a) # 输出：254-1-2-8、一元加号(+)
# 1-8、一元加号(+)
# 用于表示正数(尽管在大多数情况下是多余的)
a = +5
print(a > 0) # 输出：True4-1-2-9、一元减号(-)
# 1-9、一元减号(-)
# 用于表示负数或取反
a = 5
b = -a
print(b) # 输出：-5
c = a + b
print(c) # 输出：04-1-3、优先级
# 1-10、算术运算符的优先级
# 在Python中，算术运算符的优先级遵循数学中的常规规则。以下是从高到低的算术运算符优先级列表：
# 1、幂(**或**=): 幂运算的优先级是最高的
print(2 ** 3 + 4) # 输出 12，因为 2 ** 3 是 8，然后 8 + 4 是 12
# 2、正负号(+x, -x, +=, -=): 正负号(一元运算符)的优先级高于乘除
print(-3 * 2) # 输出 -6，因为先计算负号
# 3、乘法(*或*=)、除法(/或/=)、整除(//或//=)和取模(%或%=): 乘、(整)除和取模运算的优先级相同，从左到右进行
print(3 * 4 / 2) # 输出 6.0，因为先计算 3 * 4 得到 12，然后 12 / 2 得到 6.0
print(7 // 3) # 输出 2，因为整除的结果是整数部分
# 4、加法(+或+=)和减法(-或-=): 加法和减法的优先级相同，从左到右进行
print(3 + 4 - 2) # 输出 5，因为先计算 3 + 4 得到 7，然后 7 - 2 得到 5
# 如果在一个表达式中同时出现多个相同优先级的运算符，它们将按照从左到右的顺序进行计算(这称为左结合性)
# 可以使用括号来改变默认的优先级顺序，使得表达式按照你的意图进行计算。例如：
print(3 + 4 * 2) # 输出 11，因为先计算 4 * 2 得到 8，然后 3 + 8 得到 11
print((3 + 4) * 2) # 输出 14，因为括号改变了运算顺序| 左结合性 | 从左到右 | 说明 | ||||||||
| 由 高 到 低 | 1 | ** | **= | 幂 | ||||||
| 2 | +x | -x | += | -= | 正负号(一元运算符) | |||||
| 3 | * | *= | / | /= | % | %= | // | //= | 乘法/除法/取模/整除 | |
| 4 | + | += | - | -= | 加法/减法 | |||||
| 备注 | 可以使用括号来改变默认的优先级顺序，使得表达式按照你的意图进行计算 | |||||||||
4-2、比较运算符
4-2-1、定义
在Python中，比较运算符(Comparison Operators)是用于比较两个值之间关系的运算符。
4-2-2、分类
4-2-2-1、等于(==)
# 2-1、等于(==)
# 判断两个对象是否相等
a = 5
b = 5
print(a == b) # 输出: True4-2-2-2、不等于(!=)
# 2-2、不等于(!=)
# 判断两个对象是否不相等
a = 5
b = 3
print(a != b) # 输出: True4-2-2-3、大于(>)
# 2-3、大于(>)
# 判断左边的值是否大于右边的值
a = 5
b = 3
print(a > b) # 输出: True4-2-2-4、小于(<)
# 2-4、小于(<)
# 判断左边的值是否小于右边的值
a = 3
b = 5
print(a < b) # 输出: True4-2-2-5、大于等于(>=)
# 2-5、大于等于(>=)
# 判断左边的值是否大于或等于右边的值
a = 5
b = 5
print(a >= b) # 输出: True4-2-2-6、小于等于(<=)
# 2-6、小于等于(<=)
# 判断左边的值是否小于或等于右边的值
a = 3
b = 5
print(a <= b) # 输出: True4-2-3、优先级
在Python中，比较运算符(<, <=, >, >=, !=, ==)的优先级是相同的。
# 2-7、比较运算符的优先级
# 以下是一个示例，说明比较运算符的优先级和左结合性：
a = 5
b = 3
c = 2
# 由于比较运算符具有相同的优先级和左结合性
# 这个表达式将首先计算 a > b，然后再与 c == 2 进行比较
result = (a > b) == (c == 2)
# 因为 a > b 是 True，c == 2 也是 True
# 所以 (True) == (True) 的结果是 True
print(result) # 输出: True
# 如果我们改变括号的位置，比较的顺序会改变
# 但结果仍然相同，因为 a > b 和 c == 2 都是 True
result = a > (b == c)
# 但这里 b == c 是 False，所以 a > (False) 的结果是 True
print(result) # 输出: True
result = (a > b) != c
# a > b 是 True，所以 True != 2 的结果是 True
print(result) # 输出: True4-3、赋值运算符
4-3-1、定义
在Python中，赋值运算符(Assignment Operator)是用于将值或表达式的计算结果赋给变量的运算符。
4-3-2、分类
在大多数编程语言中，包括Python，赋值运算符就是=。
4-3-3、示例
# 3-1、示例
# 简单的赋值
x = 10
# 赋值一个表达式的计算结果
y = x + 5 # y 的值现在是 15
# 赋值一个字符串
name = "Myelsa"
# 赋值一个列表
my_list = [1, 2, 3, 4, 5]
# 赋值一个字典
my_dict = {"key1": "value1", "key2": "value2"}
# 赋值并改变变量类型(在Python中是允许的)
print(type(x)) # 输出：<class 'int'>
x = "ten" # 现在 x 是一个字符串
print(type(x)) # 输出：<class 'str'>4-4、位运算符
4-4-1、定义
在Python中，位运算符(Bitwise Operators)是对整数在二进制位级别上进行操作的运算符。
4-4-2、分类
4-4-2-1、位与(&)
# 4-1、位与(&)
# 对于每一对相应的二进制位，只有当两个二进制位都为1时，结果位才为1
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a & b # 12 = 0000 1100
print(bin(c)) # 输出：0b1100，其中0b表示二进制数的前缀4-4-2-2、位或(|)
# 4-2、位或(|)
# 对于每一对相应的二进制位，只要两个二进制位中有一个为1时，结果位就为1
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a | b # 61 = 0011 1101
print(bin(c)) # 输出：0b111101，其中0b表示二进制数的前缀4-4-2-3、位异或(^)
# 4-3、位异或(^)
# 对于每一对相应的二进制位，当两个二进制位相异时，结果位为1
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a ^ b # 49 = 0011 0001
print(bin(c)) # 输出：0b110001，其中0b表示二进制数的前缀4-4-2-4、位取反(~)
# 4-4、位取反(~)
# 对整数的二进制位取反。注意，位取反是相对于整数在计算机中表示的补码(two's complement)形式而言的。
# 对于非负数，最高位(符号位)是0；对于负数，最高位是1
a = 60 # 60 = 0011 1100
b = ~a # 结果是一个负数，具体值取决于你的系统和Python的位数(32位或64位)
print(bin(b)) # 输出：-0b111101，其中0b表示二进制数的前缀4-4-2-5、左移(<<)
# 4-5、左移(<<)
# 将数字的位向左移动指定的位数，右边空出的位用0填充
a = 60 # 60 = 0011 1100
b = a << 2 # 240 = 1111 0000
print(bin(b)) # 输出：0b11110000，其中0b表示二进制数的前缀4-4-2-6、右移(>>)
# 4-6、右移(>>)
# 将数字的位向右移动指定的位数
# 对于无符号整数，左边空出的位用0填充；对于有符号整数(如Python中的int)，最高位(符号位)将用于确定结果的正负
a = 60 # 60 = 0011 1100
b = a >> 2 # 15 = 0000 1111
c = -24 # -24 = -0001 1000
d = c >> 2 # 6 = -0000 0110
print(bin(d)) # 输出：-0b110，其中0b表示二进制数的前缀
print(bin(b)) # 输出：0b1111，其中0b表示二进制数的前缀4-4-3、优先级
| 左结合性 | 从左到右 | 说明 | ||
| 由 高 到 低 | 1 | ~ | 按位取反NOT(一元运算符) | |
| 2 | << | >> | 位移运算符 | |
| 3 | & | 按位与AND | ||
| 4 | ^ | 按位异或XOR | ||
| 5 | | | 按位或OR | ||
| 备注 | 用括号可以改变默认的优先级顺序 | |||
4-5、逻辑运算符
4-5-1、定义
在Python中，逻辑运算符(Logical Operators)是用于连接布尔值(True或False)或可以计算为布尔值的表达式，并根据这些值返回新的布尔值的运算符。
4-5-2、分类
4-5-2-1、逻辑与(and)
# 5-1、逻辑与(and)
# 当且仅当两个操作数都为True时，and运算符返回True
# 如果两个操作数中有一个为False，则结果为False
result = True and True # 结果为 True
result = True and False # 结果为 False4-5-2-2、逻辑或(or)
# 5-2、逻辑或(or)
# 当至少一个操作数为True时，or运算符返回True
# 如果两个操作数都为False，则结果为False
result = True or False # 结果为 True
result = False or False # 结果为 False4-5-2-3、逻辑非(not)
# 5-3、逻辑非(not)
# not运算符用于对一个布尔值取反。
# 如果操作数为True，则not返回False；如果操作数为False，则not返回True
result = not True # 结果为 False
result = not False # 结果为 True4-5-3、优先级
| 由 高 到 低 | 序号 | 运算符 | 说明 |
| 1 | not | 逻辑非 | |
| 2 | and | 逻辑与 | |
| 3 | or | 逻辑或 | |
| 备注 | 用括号可以改变默认的优先级顺序 | ||
4-6、身份运算符
4-6-1、定义
在Python中，身份运算符(identity operators)是用于比较两个对象的内存地址是否相同，即它们是否指向内存中的同一个对象的运算符。
4-6-2、分类
4-6-2-1、是(is)
# 6-1、是(is)
# 如果两个标识符引用的是同一个对象，则返回True
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is b) # 输出：True，因为b是a的引用
print(a is c) # 输出：False，虽然a和c的内容相同，但它们是不同的对象4-6-2-2、不是(is not)
# 6-2、不是(is not)
# 如果两个标识符引用的不是同一个对象，则返回True
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is not b) # 输出：False，因为b是a的引用，指向同一对象
print(a is not c) # 输出：True，虽然a和c的内容相同，但它们是不同的对象4-6-3、优先级
在Python中，身份运算符is和is not本身并没有内部的优先级之分，因为它们是单个的运算符，不是组合运算符。
4-7、成员运算符
4-7-1、定义
在Python中，成员运算符(Membership Operators)是用于测试一个对象(通常是序列类型，如字符串、列表、元组或集合)是否包含另一个对象作为其子元素的运算符。
4-7-2、分类
4-7-2-1、在...内(in)
# 7-1、在...内(in)
# 如果指定的对象存在于另一个对象(如列表、元组、字典、字符串或集合)中，则返回True
# 列表中的成员检查
my_list = [1, 2, 3, 4, 5]
print(3 in my_list) # 输出：True
# 字符串中的成员检查
my_string = "hello world"
print('world' in my_string) # 输出：True
# 字典中的成员检查(注意：这里检查的是键)
my_dict = {'name': 'Myelsa', 'age': 18}
print('name' in my_dict) # 输出：True
# 集合中的成员检查
my_set = {1, 2, 3}
print(2 in my_set) # 输出：True4-7-2-2、不在...内(not in)
# 7-2、不在...内(not in)
# 如果指定的对象不存在于另一个对象中，则返回True
# 列表中的成员检查
my_list = [1, 2, 3, 4, 5]
print(6 not in my_list) # 输出：True
# 字符串中的成员检查
my_string = "hello world"
print('world' not in my_string) # 输出：False
# 字典中的成员检查(注意：这里检查的是键)
my_dict = {'name': 'Myelsa', 'age': 18}
print('name' not in my_dict) # 输出：False
# 集合中的成员检查
my_set = {1, 2, 3}
print(2 not in my_set) # 输出：False4-7-3、优先级
在Python中，成员运算符in和not in本身并没有内部的优先级之分，因为它们是单个的运算符，不是组合运算符。
4-8、三元运算符
4-8-1、定义
在Python中，三元运算符(也称为条件表达式或条件运算符)是一种简洁的编写条件语句的方式，它允许你在一行代码中根据条件来返回两个值中的一个，由if...else...结构组成，但写法更加紧凑。
4-8-2、语法
# 8-1、语法：value_if_true if condition else value_if_false
# 8-2、说明：condition是一个表达式，其结果将被评估为True或False
# 如果condition为True，则整个表达式的结果将是value_if_true
# 如果condition为False，则结果将是value_if_false4-8-3、示例
# 8-3、示例：
x = 10
y = "positive" if x > 0 else "non-positive"
print(y) # 输出： "positive"
x = -5
y = "positive" if x > 0 else "non-positive"
print(y) # 输出： "non-positive"5、明确优先级
| 优先级 | 序号 | 中文说明 | 运算符 | 备注 |
| 由 高 到 低 | 01 | 括号 | () | |
| 02 | 一元运算符 | +X,-X,~X,+=,-= | +代表正号；-代表负号 | |
| 03 | 幂 | **,**= | ||
| 04 | 乘法/(整)除法/取模 | *,*=,/,/=,//,//=,%,%= | ||
| 05 | 加法/减法 | +,+=,-,-= | +代表加号；-代表减号 | |
| 06 | 位运算符 | <<,>> | ||
| 07 | 按位与运算符 | & | ||
| 08 | 按位异或运算符 | ^ | ||
| 09 | 按位或运算符 | | | ||
| 10 | 比较运算符 | <,<=,>,>=,!=,== | ||
| 11 | 身份运算符 | is,is not | ||
| 12 | 成员运算符 | in,not in | ||
| 13 | 逻辑运算符 | not,and,or | ||
| 14 | 赋值运算符 | = |
