目录
[一、Python 初体验：像用计算器一样写代码](#一、Python 初体验：像用计算器一样写代码)
[1.1 表达式与常量：编程世界的 "算术题"](#1.1 表达式与常量：编程世界的 “算术题”)
[1.2 实战案例：计算四个分数的平均值](#1.2 实战案例：计算四个分数的平均值)
[二、变量：编程世界的 "储物盒"](#二、变量：编程世界的 “储物盒”)
[2.1 变量是什么？](#2.1 变量是什么？)
[2.2 变量的语法规则：命名不能 "随心所欲"](#2.2 变量的语法规则：命名不能 “随心所欲”)
[2.3 变量的使用：读取与修改](#2.3 变量的使用：读取与修改)
[三、数据类型：给变量 "分类"，让操作更清晰](#三、数据类型：给变量 “分类”，让操作更清晰)
[3.1 常用数据类型详解](#3.1 常用数据类型详解)
[（1）整数（int）：没有大小限制的 "整数"](#（1）整数（int）：没有大小限制的 “整数”)
[（2）浮点数（float）：带小数点的 "小数"](#（2）浮点数（float）：带小数点的 “小数”)
[（3）字符串（str）：文本的 "载体"](#（3）字符串（str）：文本的 “载体”)
[（4）布尔值（bool）：只有 "真" 和 "假"](#（4）布尔值（bool）：只有 “真” 和 “假”)
[3.2 为什么需要数据类型？](#3.2 为什么需要数据类型？)
[3.3 Python 的动态类型特性](#3.3 Python 的动态类型特性)
[四、注释：给代码 "写说明"，让别人和自己都看懂](#四、注释：给代码 “写说明”，让别人和自己都看懂)
[4.1 为什么要写注释？](#4.1 为什么要写注释？)
[4.2 Python 注释的两种语法](#4.2 Python 注释的两种语法)
[4.3 注释的规范：写注释也要 "讲规矩"](#4.3 注释的规范：写注释也要 “讲规矩”)
[五、输入输出：程序与用户的 "对话"](#五、输入输出：程序与用户的 “对话”)
[5.1 输出：用print()函数展示结果](#5.1 输出：用print()函数展示结果)
[5.2 输入：用input()函数获取用户信息](#5.2 输入：用input()函数获取用户信息)
[六、运算符：Python 的 "计算工具库"](#六、运算符：Python 的 “计算工具库”)
[6.1 算术运算符：做数学运算](#6.1 算术运算符：做数学运算)
[6.2 关系运算符：比较大小与相等](#6.2 关系运算符：比较大小与相等)
[6.3 逻辑运算符：组合条件判断](#6.3 逻辑运算符：组合条件判断)
[（2）Python 特有：连续比较](#（2）Python 特有：连续比较)
[6.4 赋值运算符：简化赋值操作](#6.4 赋值运算符：简化赋值操作)
[（4）复合赋值运算符：简化运算 + 赋值](#（4）复合赋值运算符：简化运算 + 赋值)
[6.5 运算符优先级：谁先算，谁后算](#6.5 运算符优先级：谁先算，谁后算)
前言
很多新手刚接触编程时，会被复杂的语法规则、晦涩的专业术语吓退，但 Python 完全不同 ------ 它的语法贴近自然语言，代码可读性极强，就像在写伪代码一样。不过，"简单" 不代表 "不用学"，变量类型、运算符优先级、注释规范这些基础知识点，正是决定你能否写出高效、易维护代码的关键。
本文将基于 Python 核心语法体系，结合实战案例，从常量表达式到输入输出，从数据类型到运算符，全方位拆解 Python 基础语法。无论你是想入门编程，还是想巩固基础，这篇文章都能让你收获满满。话不多说，咱们直接开干！
一、Python 初体验：像用计算器一样写代码
刚接触 Python 时，我们可以把它当成一个高级计算器，先通过简单的算术运算感受编程的乐趣。这部分会带你认识表达式、常量和最基础的 print 函数。
1.1 表达式与常量：编程世界的 "算术题"
在 Python 中，像1 + 2 - 3、1 + 2 * 3这样的 "算术题" 被称为表达式 ，而1、2、3这种直接写出来的数值叫做字面值常量 ，+、-、*、/则是运算符（也叫操作符）。
表达式的计算结果叫做 "返回值"，我们可以用print函数将结果输出到控制台，就像按下计算器的 "等于" 键一样：
python
# 基本算术运算
print(1 + 2 - 3) # 输出：0
print(1 + 2 * 3) # 输出：7（先算乘除，后算加减，和数学规则一致）
print(1 + 2 / 3) # 输出：1.6666666666666665
print((1 + 2) * 3) # 输出：9（括号可以改变运算优先级）这里有几个实用小细节，新手一定要注意：
- 运算符和数字之间可以没有空格，也可以有多个空格，但建议只留一个空格（代码更美观，可读性更强）；
- 熟悉 C/Java 的同学要注意：Python 中2 / 3的结果是小数（1.666...），而不是截断后的 0，更符合日常计算直觉；
- print是 Python 内置函数，作用是 "打印输出"，后续会详细介绍它的高级用法。
1.2 实战案例：计算四个分数的平均值
光说不练假把式，我们来做个简单实战：给定四个分数 67.5、89.0、12.9、32.2，计算它们的平均值。
根据平均值公式 "总和 ÷ 个数"，我们可以直接写表达式：
python
# 计算四个分数的平均值
print((67.5 + 89.0 + 12.9 + 32.2) / 4)运行代码后，控制台会输出50.4，这就是四个数的平均值。是不是很简单？但如果我们要计算更复杂的指标（比如方差），只靠单次表达式就不够了 ------ 这时候需要用到 "变量" 来保存中间结果。
二、变量：编程世界的 "储物盒"
想象一下，如果你在计算方差时，每次用到平均值都要重新写一遍(67.5 + 89.0 + 12.9 + 32.2) / 4，不仅麻烦，还容易出错。这时候，变量就像一个 "储物盒"，可以把计算结果存起来，后续直接调用即可。这是与计算器中的M键功能类似的。
2.1 变量是什么？
变量是一块用于存储数据的内存空间，就像宿舍楼上的房间 ------ 每个房间都有编号（变量名），里面可以存放不同的数据（变量值）。我们可以通过变量名快速访问或修改里面的数据，而不用关心它在内存中的具体位置。
还是以计算方差为例，方差的计算步骤是：先求平均值→每个数减平均值的平方→求和→除以（个数 - 1）。用变量保存中间结果后，代码会清晰很多：
python
# 计算四个分数的方差
# 1. 计算平均值，用变量avg保存
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
# 2. 计算每个数与平均值差值的平方和，用变量total保存
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2
# 3. 计算方差，用变量result保存
result = total / 3
# 4. 输出结果
print(result)运行代码后，会输出方差结果945.9566666666667。这里的avg、total、result都是变量，**是 Python 中的乘方运算符（**2就是求平方）。
2.2 变量的语法规则：命名不能 "随心所欲"
定义变量的语法非常简单：变量名 = 变量值，其中=是赋值运算符，表示把右侧的数据 "放进" 左侧的变量中。但变量名的命名有严格规则，分为 "硬性规则"（必须遵守）和 "软性规则"（建议遵守）。
硬性规则（违反会报错）
- 变量名由数字、字母、下划线 构成，不能包含其他特殊字符（比如
!、@、#等）；- 数字不能开头 （比如
123num是非法的，num123是合法的）；- 变量名不能和 Python 的 "关键字" 重复（比如
if、for、- 变量名大小写敏感 （
num和Num是两个不同的变量，比如num=10和Num=20互不影响）。
软性规则（提升代码质量）
- 变量名要用有描述性的单词 ，让人一眼就知道变量的用途（比如用
avg表示平均值，total表示总和，而不是用x、y、z）；- 多个单词构成的变量名，建议用 "驼峰命名法"（首个单词首字母小写，后续单词首字母大写），比如
totalCount、personInfo；- 变量名尽量简洁，不要过长（比如用
name表示姓名，而不是personFullName）。
反例：a=10、x2=30、my_name123=50（虽然合法，但可读性差）；
正例：age=18、studentScore=95、averageHeight=175.5（清晰易懂）。
2.3 变量的使用：读取与修改
变量的使用非常灵活，既可以读取它的值，也可以修改它的值，还能把一个变量的值赋给另一个变量。
读取变量值
python
# 定义变量
name = "张三"
age = 20
# 读取并输出变量值
print(name) # 输出：张三
print(age) # 输出：20修改变量值
在 Python 中，修改变量不需要重新声明，直接用=赋值即可：
python
num = 10
print(num) # 输出：10
# 修改变量值
num = 20
print(num) # 输出：20变量之间赋值
可以把一个变量的值 "复制" 给另一个变量：
python
a = 10
b = 20
# 把b的值赋给a
a = b
print(a) # 输出：20
print(b) # 输出：20（b的值不会变）这里要注意：赋值是 "单向的"，a = b表示把b的值复制给a，而不是a和b相互绑定。后续修改a的值，不会影响b，反之亦然。
三、数据类型：给变量 "分类"，让操作更清晰
变量里能存的不只是数字，还能存文本、布尔值等不同类型的数据。Python 中的 "类型" 就像给变量贴标签，告诉我们这个变量能存什么数据，以及能对它做什么操作。
和 C++/Java 不同，Python 的变量不需要显式指定类型 ，而是在赋值时自动确定类型（比如a=10是整数类型，a="hello"是字符串类型）。我们可以用**type()**函数查看变量的类型。
3.1 常用数据类型详解
（1）整数（int）：没有大小限制的 "整数"
整数类型用于存储整数（正整数、负整数、0），比如10、-5、0。
python
a = 10
b = -20
c = 0
print(type(a)) # 输出：<class 'int'>
print(type(b)) # 输出：<class 'int'>Python 的int类型有个强大的特点：表示范围无上限。只要内存足够，就能存储无限大的整数，比如：
python
# 超大整数运算
big_num = 123456789012345678901234567890
print(big_num * 2) # 输出：246913578024691357802469135780这和 C++/Java 不同，后者的整数类型有固定范围（比如 Java 的int最大是 2147483647），超过就会溢出。
（2）浮点数（float）：带小数点的 "小数"
浮点数用于存储小数（比如0.5、3.14），也可以用科学计数法表示（比如1.23e5表示 123000）。
python
a = 0.5
b = 3.14159
c = 1.23e5 # 等价于123000.0
print(type(a)) # 输出：<class 'float'>
print(c) # 输出：123000.0注意事项：
- Python 中没有
double类型，float本质是双精度浮点数（和 C++/Java 的double一致），精度约为小数点后 15 位；- 浮点数在计算机中存储不精确，后续会详细说明如何正确比较浮点数。
（3）字符串（str）：文本的 "载体"
字符串用于存储文本信息（比如姓名、地址、一句话），用单引号' '或双引号" "包裹即可。
python
a = 'hello'
b = "Python"
c = '我是程序员'
print(type(a)) # 输出：<class 'str'>
print(a + b) # 输出：helloPython（字符串拼接）字符串的常用操作：
1. 获取长度 ：用**len()**函数，返回字符串中字符的个数；
python
s = 'hello world'
print(len(s)) # 输出：11（空格也算一个字符）2. 字符串拼接 ：用**+**运算符，只能拼接字符串和字符串（不能拼接字符串和数字）；
python
name = "张三"
age = 20
# 错误写法：print("姓名：" + name + "，年龄：" + age)（age是int类型，不能拼接）
# 正确写法：先把age转成字符串，或用f-string（后续会讲）
print("姓名：" + name + "，年龄：" + str(age)) # 输出：姓名：张三，年龄：203. 单引号和双引号等价 ：'hello'和"hello"完全一样，当字符串中包含引号时，可以交叉使用（比如He said "I love Python"）。
（4）布尔值（bool）：只有 "真" 和 "假"
布尔值是一种特殊类型，只有两个取值：True（真）和False（假），常用于逻辑判断（比如判断条件是否成立）。
python
a = True
b = False
print(type(a)) # 输出：<class 'bool'>
print(10 > 5) # 输出：True（关系表达式的结果是布尔值）
print(10 == 5) # 输出：False布尔值的命名规则：True和False的首字母必须大写，不能写成true或false（会报错）。
3.2 为什么需要数据类型？
很多新手会疑惑："为什么要分这么多类型？直接存数据不行吗？" 其实数据类型有两个核心作用：
- 确定内存占用大小 ：不同类型的数据在内存中占用的空间不同。比如
float类型占用 8 个字节（64 个二进制位），而int类型的占用空间会根据数值大小动态调整；- 规定可执行的操作 ：不同类型的变量支持的操作不同。比如
int和float可以做+、-、*、/运算，而str类型只能做拼接（+）和求长度（len()）等操作。
简单说，数据类型就是给变量 "分类"，让计算机知道该如何处理这些数据 ------ 就像苹果和香蕉都是水果，但苹果可以榨汁，香蕉可以做沙拉，分工不同，用法也不同。
3.3 Python 的动态类型特性
Python 的变量类型可以在程序运行过程中动态改变，这个特性叫做**"动态类型"**，是 Python 的一大特色。
python
a = 10
print(type(a)) # 输出：<class 'int'>（初始是整数类型）
a = 'hello'
print(type(a)) # 输出：<class 'str'>（后来变成字符串类型）
a = True
print(type(a)) # 输出：<class 'bool'>（再变成布尔类型）而 C++/Java 等语言是 "静态类型"，变量定义后类型就固定了（比如 Java 中int a=10，后续不能把a改成字符串）。
动态类型的优缺点：
- 优点：灵活，能减少代码量（比如一段代码可以支持多种类型）；
- 缺点：大型项目中容易出现类型错误，增加调试难度（比如不小心把整数类型改成了字符串，后续运算会报错）。
四、注释：给代码 "写说明"，让别人和自己都看懂
写代码就像写文章，光有内容不够，还需要 "注释" 来解释代码的用途、逻辑。注释是不会被 Python 执行的代码，只为了让开发者理解代码 ------ 毕竟三个月后，你可能也不记得自己写的代码是干嘛的了。
4.1 为什么要写注释？
举个例子，下面两段代码，你觉得哪个更容易看懂？
无注释代码：
python
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2
result = total / 3
print(result)有注释代码：
python
# 计算四个分数（67.5, 89.0, 12.9, 32.2）的方差
# 方差公式：(每个数-平均值)²的和 ÷ (个数-1)
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4 # 步骤1：计算平均值
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2 # 步骤2：计算平方和
result = total / 3 # 步骤3：计算方差
print(result) # 步骤4：输出结果显然，有注释的代码一目了然。记住：代码的第一目标是容易理解，第二目标才是执行正确。写注释不光是为了别人，更是为了未来的自己。
4.2 Python 注释的两种语法
Python 支持两种注释方式，分别适用于不同场景：
（1）单行注释：用#开头
**#**后面的内容都是注释，只作用于一行。可以单独占一行，也可以跟在代码后面：
python
# 这是单独一行的注释
num = 10 # 这是跟在代码后面的注释（说明变量的含义）
print(num) # 输出变量num的值（2）多行注释：用三引号包裹
用**"""或'''**包裹的内容是多行注释（也叫 "文档字符串"），可以跨越多行，常用于说明文件、函数或类的功能：
python
"""
这是多行注释（文档字符串）
作用：计算两个数的和并输出
参数：a - 第一个整数，b - 第二个整数
返回值：无
"""
a = 10
b = 20
print(a + b)注意：三引号本质是字符串，如果没有赋值给变量，就会被当作注释；如果赋值给变量，就是一个字符串对象（但通常不用这种方式定义字符串）。
4.3 注释的规范：写注释也要 "讲规矩"
好的注释能提升代码质量，差的注释反而会误导别人。写注释要遵守以下规范：
- 内容准确：注释必须和代码一致，代码修改后，注释也要及时更新（比如代码改成计算标准差，注释不能还写 "计算方差"）；
- 篇幅合理 ：不要太精简（比如
# 计算和可以，但# 求和也足够），也不要长篇大论（注释比代码还长就没必要了）；- 使用中文：国内开发场景中，建议用中文写注释（外企除外），避免英文注释表意不清；
- 积极向上：注释中不要包含负能量、辱骂性语言（比如 "这破代码谁写的""领导 SB"）。
反例：
python
# 计算x和y的和（但代码实际是计算乘积）
x = 5
y = 6
print(x * y)正例：
python
# 计算x和y的乘积（用于后续计算面积）
x = 5 # 宽
y = 6 # 长
print(x * y) # 输出面积：30五、输入输出：程序与用户的 "对话"
程序不是孤立的，需要和用户交互 ------ 用户向程序提供信息（输入），程序向用户展示结果（输出）。Python 中最基础的交互方式是通过控制台，用**print()函数实现输出，用input()**函数实现输入。
5.1 输出：用print()函数展示结果
**print()**是 Python 中最常用的输出函数，能输出字符串、变量、表达式结果等，还支持多种格式化方式。
（1）基本用法：输出单个内容
python
# 输出字符串
print("Hello, Python!") # 输出：Hello, Python!
# 输出变量
name = "李四"
print(name) # 输出：李四
# 输出表达式结果
print(10 + 20) # 输出：30
print(3.14 * 2) # 输出：6.28（2）进阶用法：格式化输出（重点）
实际开发中，我们常需要混合输出字符串和变量（比如 "你的年龄是 20 岁"），这时候需要用到格式化输出。Python 中最简洁的方式是f-string（格式化字符串）。
f-string 的用法：在字符串前加f，用{}包裹变量或表达式：
python
name = "王五"
age = 25
height = 180.5
# 输出混合内容
print(f"姓名：{name}，年龄：{age}岁，身高：{height}cm")
# 输出：姓名：王五，年龄：25岁，身高：180.5cm
# 表达式也可以直接放在{}中
print(f"明年年龄：{age + 1}岁") # 输出：明年年龄：26岁
print(f"身高的一半：{height / 2}cm") # 输出：身高的一半：90.25cmf-string 的优势：语法简洁、可读性强、运行效率高，是 Python3.6 及以上版本推荐的格式化方式。
除了 f-string，Python 还有%格式化、str.format()等方式，但 f-string 最直观，新手优先掌握这一种即可。
（3）其他用法：输出多个内容
**print()**函数可以同时输出多个内容，用逗号分隔，输出时会自动用空格连接：
python
a = 10
b = 20
print("a的值是", a, "b的值是", b) # 输出：a的值是 10 b的值是 205.2 输入：用input()函数获取用户信息
**input()**函数用于从控制台获取用户输入，用户输入的内容会作为字符串返回（无论输入的是数字还是文本）。
（1）基本用法：获取输入并保存
python
# 获取用户输入，提示信息为"请输入你的姓名："
name = input("请输入你的姓名：")
# 输出用户输入的内容
print(f"你好，{name}！")运行代码后，控制台会显示 "请输入你的姓名："，等待用户输入。用户输入后按回车，程序会继续执行，输出 "你好，XXX！"。
（2）关键注意：输入的是字符串类型
无论用户输入的是数字还是文本，input()的返回值都是字符串。如果需要进行算术运算，必须先把字符串转成对应的类型（int或float）。
反例（错误用法）：
python
# 想让用户输入两个整数，计算它们的和
a = input("请输入第一个整数：")
b = input("请输入第二个整数：")
print(f"它们的和是：{a + b}")如果用户输入10和20，程序会输出1020，而不是30------ 因为a和b都是字符串，+是字符串拼接，不是算术加法。
正例（正确用法）：
python
# 先转成int类型，再计算
a = input("请输入第一个整数：")
b = input("请输入第二个整数：")
a = int(a) # 把字符串转成整数
b = int(b)
print(f"它们的和是：{a + b}") # 输出：30如果用户输入的是小数，就用**float()**转成浮点数：
python
# 计算两个小数的和
x = float(input("请输入第一个小数："))
y = float(input("请输入第二个小数："))
print(f"它们的和是：{x + y}")（3）实战案例：输入四个小数，计算平均值
结合输入输出和变量知识，我们做一个实战：让用户输入四个小数，程序计算并输出平均值。
python
# 输入四个小数
a = float(input("请输入第一个小数："))
b = float(input("请输入第二个小数："))
c = float(input("请输入第三个小数："))
d = float(input("请输入第四个小数："))
# 计算平均值
avg = (a + b + c + d) / 4
# 格式化输出（保留2位小数）
print(f"四个数的平均值是：{avg:.2f}")运行示例：
请输入第一个小数：10.2
请输入第二个小数：20.3
请输入第三个小数：30.4
请输入第四个小数：40.5
四个数的平均值是：25.35其中**{avg:.2f}**表示把avg格式化为保留 2 位小数的浮点数，让输出更整洁。
六、运算符：Python 的 "计算工具库"
运算符是用于执行运算的符号，Python 提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符、赋值运算符等。掌握运算符的用法和优先级，能让你写出更高效的代码。
6.1 算术运算符：做数学运算
算术运算符用于执行基本的数学运算，包括+（加）、-（减）、*（乘）、/（除）、%（取余）、**（乘方）、//（取整除法）。
| 运算符 | 功能 | 示例 | 结果 |
|---|---|---|---|
| + | 加法 | 10 + 20 |
30 |
| - | 减法 | 20 - 10 |
10 |
| ***** | 乘法 | 10 * 20 |
200 |
| / | 除法（结果为小数） | 20 / 3 |
6.666... |
| % | 取余（求余数） | 20 % 3 |
2 |
| ****** | 乘方 | 2 ** 3（2 的 3 次方） |
8 |
| // | 取整除法（向下取整） | 20 // 3、-20 // 3 |
6、-7 |
关键注意点：
（1）除法不能除以 0 ：用0作为除数会抛出ZeroDivisionError异常（程序崩溃）；
python
print(10 / 0) # 报错：ZeroDivisionError: division by zero（2）取余运算的应用 ：取余常用于判断奇偶性（num % 2 == 0是偶数）、循环周期（比如每隔 n 次执行一次操作）；
python
# 判断奇偶性
num = 15
if num % 2 == 0:
print("偶数")
else:
print("奇数") # 输出：奇数（3）取整除法（//） ：舍弃小数部分，向下取整 （不是四舍五入）。比如7 // 2 = 3，-7 // 2 = -4（因为 - 4 比 - 3 小）；
（4）乘方运算支持小数次方 ：比如4 ** 0.5（4 的平方根）结果是2.0，8 ** (1/3)（8 的立方根）结果是2.0。
6.2 关系运算符：比较大小与相等
关系运算符用于比较两个值的关系，结果是布尔值（True或False）。包括<（小于）、<=（小于等于）、>（大于）、>=（大于等于）、==（等于）、!=（不等于）。
（1）基本用法：比较数字
python
a = 10
b = 20
print(a < b) # 输出：True
print(a <= b) # 输出：True
print(a > b) # 输出：False
print(a == b) # 输出：False（注意是==，不是=，=是赋值）
print(a != b) # 输出：True（2）扩展用法：比较字符串
关系运算符也能比较字符串，规则是 "字典序"（和英语词典的排序规则一致）：
- 先比较第一个字符的 ASCII 码值，谁小谁就 "小"；
- 第一个字符相同，再比较第二个，以此类推；
- 字符串长度不同但前缀相同，短的字符串更小（比如
"apple"<"apples"）。
python
s1 = "hello"
s2 = "world"
s3 = "apple"
print(s1 < s2) # 输出：True（'h'的ASCII码比'w'小）
print(s3 < s1) # 输出：True（'a'的ASCII码比'h'小）
print("apple" == "apple") # 输出：True（内容完全一致）注意：Python 中直接用==比较字符串内容是否相等，这和 C/Java 不同（后者需要用strcmp函数）。
（3）避坑指南：浮点数不能用==比较
由于浮点数在计算机中存储不精确，直接用==比较两个浮点数是否相等，很可能得到错误结果：
python
print(0.1 + 0.2 == 0.3) # 输出：False
print(0.1 + 0.2) # 输出：0.30000000000000004（不是精确的0.3）这不是 Python 的问题，而是 IEEE754 标准（浮点数存储标准）的固有缺陷。正确的比较方式是：判断两个浮点数的差值是否小于一个极小的误差范围（比如1e-6，即 0.000001）。
python
a = 0.1 + 0.2
b = 0.3
# 正确写法：差值的绝对值小于1e-6，就认为相等
if abs(a - b) < 1e-6:
print("相等") # 输出：相等
else:
print("不相等")6.3 逻辑运算符：组合条件判断
逻辑运算符用于组合多个条件，结果也是布尔值。包括and（并且）、or（或者）、not（非）。
（1）基本规则
- and：两侧条件都为
True，结果才是True（一假则假）；- or：两侧条件只要有一个为
True，结果就是True（一真则真）；- not：对条件取反（
True变False，False变True）。
python
# and示例
age = 25
score = 85
print(age >= 18 and score >= 80) # 输出：True（两个条件都满足）
print(age < 18 and score >= 80) # 输出：False（第一个条件不满足）
# or示例
print(age >= 30 or score >= 80) # 输出：True（第二个条件满足）
print(age < 18 or score < 60) # 输出：False（两个条件都不满足）
# not示例
print(not age >= 30) # 输出：True（age>=30是False，取反后是True）
print(not score < 60) # 输出：True（score<60是False，取反后是True）（2）Python 特有：连续比较
Python 支持连续关系表达式，等价于用and连接，语法更简洁：
python
x = 10
# 等价于：x > 5 and x < 15
print(5 < x < 15) # 输出：True
# 等价于：x >= 0 and x <= 20
print(0 <= x <= 20) # 输出：True这和大部分编程语言不同（比如 Java 中5 < x < 15会先计算5 < x得到True，再用True < 15，这是非法的）。
（3）短路求值：提高效率的小技巧
逻辑运算符存在 "短路求值" 特性，能避免不必要的计算，提高代码效率：
- and：如果左侧条件为
False，右侧条件不再执行（因为整体结果已经是False）；- or：如果左侧条件为
True，右侧条件不再执行（因为整体结果已经是True）。
python
# and短路：左侧10>20是False，右侧10/0不会执行（不会报错）
print(10 > 20 and 10 / 0 == 1) # 输出：False
# or短路：左侧10<20是True，右侧10/0不会执行（不会报错）
print(10 < 20 or 10 / 0 == 1) # 输出：True这个特性在实际开发中很有用，比如判断一个变量是否存在且满足某个条件时，可以避免空指针错误。
6.4 赋值运算符：简化赋值操作
赋值运算符用于给变量赋值，除了基本的=，还有复合赋值运算符（+=、-=、*=、/=、%=等）。
（1）基本赋值：=
python
a = 10 # 把10赋值给a
b = a # 把a的值赋值给b（2）链式赋值：同时给多个变量赋同一个值
python
x = y = z = 0 # x、y、z的值都是0
print(x, y, z) # 输出：0 0 0（3）多元赋值：同时给多个变量赋不同值
python
# 传统写法：需要临时变量
a = 10
b = 20
tmp = a
a = b
b = tmp
# 多元赋值写法：更简洁
a, b = 10, 20
a, b = b, a # 交换a和b的值
print(a, b) # 输出：20 10多元赋值在交换变量、函数返回多个值时非常方便。
（4）复合赋值运算符：简化运算 + 赋值
复合赋值运算符是运算符 + =的组合，等价于变量 = 变量 运算符 数值。
| 运算符 | 等价写法 | 示例 | 结果 |
|---|---|---|---|
| += | a = a + b |
a=10; a+=5 |
15 |
| -= | a = a - b |
a=10; a-=5 |
5 |
| *= | a = a * b |
a=10; a*=5 |
50 |
| /= | a = a / b |
a=10; a/=5 |
2.0 |
| %= | a = a % b |
a=10; a%=3 |
1 |
注意：Python 中没有++（自增）和--（自减）运算符，如果需要自增 1，用a += 1即可（比++a更直观，避免了前置和后置的混淆）。
6.5 运算符优先级：谁先算，谁后算
当一个表达式中有多个运算符时，Python 会按照 "运算符优先级" 决定计算顺序（和数学中的 "先乘除后加减" 一致）。
优先级从高到低（常用）：
- 括号（
()）：优先级最高，先算括号里的；- 算术运算符 ：
**（乘方）>*、/、%、//>+、-；- 关系运算符 ：
<、<=、>、>=、==、!=；- 逻辑运算符 ：
not>and>or；- 赋值运算符 ：
=、+=、-=等（优先级最低，最后算）。
示例：
python
# 计算顺序：先算10*2=20，再算5+20=25，最后算25>20→True
print(5 + 10 * 2 > 20) # 输出：True
# 计算顺序：先算a>5→True，再算b<10→False，最后算True and False→False
a = 10
b = 15
print(a > 5 and b < 10) # 输出：False如果不确定优先级，最简单的方法是加括号 ------ 括号能改变优先级，让代码更清晰。
总结
Python学习没有什么捷径，如果在学习过程中遇到问题，不妨回头看看这篇文章，或者查阅 Python 官方文档。编程是一个循序渐进的过程，只要坚持练习，你一定能从新手成长为 Python 高手！