这篇文章是我短时间内学习Python基础的总结，个人认为有其他语法基础的同学看了这篇文章可以做到快速上手py语法，不过我相信没有语法基础的同学看了这篇文章也会有所收获。

全文分为 15 个模块，每个知识点独立一段代码 + 运行结果，

 目录

• 1. 基础数据类型与变量
• 2. 运算符
• 3. 条件语句 if-elif-else
• 4. 循环语句 for/while
• 5. 容器类型（列表 / 字典 / 元组 / 集合）
• 6. 函数定义与调用
• 7. 异常处理
• 8. 类与对象（面向对象基础）
• 9. 切片
• 10. 推导式（Python 特色语法）
• 11. 迭代器与生成器
• 12. 模块导入与使用
• 13. 装饰器（进阶基础）
• 14. with 语句（上下文管理器）
• 15. 三元表达式
•  学习建议

---

1. 基础数据类型与变量

核心：Python 是动态类型语言，无需声明变量类型，直接赋值即可；掌握 3 种常用的格式化输出方式。

# ==================== 1. 基础数据类型与变量 ====================
# 1. 变量定义：Python自动识别类型，无需提前声明
name = "Python学习者"  # 字符串类型（str）：用单/双引号包裹文本
age = 20               # 整数类型（int）：无小数点的数字
height = 1.75          # 浮点数类型（float）：带小数点的数字
is_student = True      # 布尔类型（bool）：只有True/False两个值

# 2. 格式化输出（3种常用方式，重点掌握f-string）
print("===== 基础数据类型 =====")
# 方式1：f-string（Python3.6+推荐）：{}内直接写变量/表达式，简洁高效
print(f"姓名: {name}, 年龄: {age}")  
# 方式2：旧式%格式化：%.2f表示保留2位小数，适合老代码兼容
print("身高: %.2f 米" % height)     
# 方式3：format方法：{}作为占位符，适合多变量格式化
print("是否学生: {}".format(is_student))  

运行结果：

===== 基础数据类型 =====
姓名: Python学习者, 年龄: 20
身高: 1.75 米
是否学生: True

关键解释：

• f-string是日常开发最常用的方式，可读性最高；
• 布尔值首字母必须大写（True/False），不能写 true/false。

---

2. 运算符

核心：掌握算术、比较、逻辑三类运算符，是 Python 逻辑判断的基础。

# ==================== 2. 运算符 ====================
print("\n===== 运算符 =====")
a = 10
b = 3

# 1. 算术运算符（数学计算）
print(f"{a} + {b} = {a + b}")       # 加法：10+3=13
print(f"{a} / {b} = {a / b}")       # 除法：返回浮点数（即使能整除）
print(f"{a} // {b} = {a // b}")     # 整除：只取整数部分，舍弃小数
print(f"{a} % {b} = {a % b}")       # 取余（模运算）：10除以3余1
print(f"{a} ** {b} = {a ** b}")     # 幂运算：10的3次方=1000

# 2. 比较运算符（返回布尔值）
print(f"{a} > {b} ? {a > b}")       # 大于：True
print(f"{a} == {b} ? {a == b}")     # 等于：注意是==，不是=（=是赋值）

# 3. 逻辑运算符（多条件判断）
print(f"True and False ? {True and False}")  # 与：全为True才返回True
print(f"True or False ? {True or False}")    # 或：有一个True就返回True

运行结果：

===== 运算符 =====
10 + 3 = 13
10 / 3 = 3.3333333333333335
10 // 3 = 3
10 % 3 = 1
10 ** 3 = 1000
10 > 3 ? True
10 == 3 ? False
True and False ? False
True or False ? True

关键解释：

• ❗ 易错点：=是赋值，==是判断相等，新手容易混淆；
• 取余运算常用于判断奇偶（num % 2 == 0 表示偶数）。

---

3. 条件语句 if-elif-else

核心：根据条件执行不同代码块，Python 用缩进（4 个空格）区分代码块，无需大括号。

# ==================== 3. 条件语句（if-elif-else） ====================
print("\n===== 条件语句 =====")
score = 85  # 定义分数变量

# 条件判断：从上到下依次匹配，满足一个就停止
if score >= 90:          # 第一个条件：90分及以上
    print("优秀")
elif score >= 80:        # 第二个条件：80-89分（不满足上一个才会执行）
    print("良好")
elif score >= 60:        # 第三个条件：60-79分
    print("及格")
else:                    # 所有条件都不满足（<60分）
    print("不及格")

运行结果：

===== 条件语句 =====
良好

关键解释：

• Python 用缩进（建议 4 个空格）划分代码块，缩进错误会直接报错；
• elif可以写多个，else是可选的，且必须放在最后。

---

4. 循环语句 for/while

核心：重复执行代码块，for 适合遍历可迭代对象（列表 / 字符串），while 适合条件循环。

# ==================== 4. 循环语句（for/while） ====================
print("\n===== 循环语句 =====")
fruits = ["苹果", "香蕉", "橙子"]  # 定义列表

# 1. for循环：遍历列表中的每个元素
print("遍历列表:")
for fruit in fruits:
    print(f"水果: {fruit}")  # 依次输出每个水果

# 2. for循环+enumerate：同时获取索引和元素（常用）
for idx, fruit in enumerate(fruits):
    print(f"索引 {idx}: {fruit}")  # idx从0开始

# 3. while循环：满足条件时持续执行
print("while循环计数:")
count = 0  # 初始化计数器
while count < 3:          # 条件：count小于3时执行
    print(f"计数: {count}")
    count += 1            # 计数器自增（必须写，否则死循环）

运行结果：

===== 循环语句 =====
遍历列表:
水果: 苹果
水果: 香蕉
水果: 橙子
索引 0: 苹果
索引 1: 香蕉
索引 2: 橙子
while循环计数:
计数: 0
计数: 1
计数: 2

关键解释：

•  while 循环必须有 “退出条件”（如count += 1），否则会无限循环；
• enumerate默认从 0 开始计数，也可以指定起始值（如enumerate(fruits, 1)从 1 开始）。

---

5. 容器类型（列表 / 字典 / 元组 / 集合）

核心：Python 四大核心容器，分别适用于不同场景，是处理数据的基础。

# ==================== 5. 容器类型（列表/字典/元组/集合） ====================
print("\n===== 容器类型 =====")

# 1. 列表（list）：有序、可变、可重复
numbers = [1, 2, 3, 4, 5]
numbers.append(6)          # 末尾添加元素：[1,2,3,4,5,6]
numbers.remove(2)          # 删除指定元素：[1,3,4,5,6]
print("列表操作后:", numbers)

# 2. 字典（dict）：键值对、无序、键唯一
person = {"name": "小明", "age": 18}
person["gender"] = "男"    # 添加新的键值对
print("字典:", person)
print("字典取值:", person["name"])  # 通过键取值

# 3. 元组（tuple）：有序、不可变（不能修改）
point = (10, 20)
print("元组取值:", point[0])  # 取值和列表一样，但不能append/remove

# 4. 集合（set）：无序、无重复（自动去重）
s = {1, 2, 2, 3}  # 重复的2会被自动去除
print("集合（自动去重）:", s)

运行结果：

===== 容器类型 =====
列表操作后: [1, 3, 4, 5, 6]
字典: {'name': '小明', 'age': 18, 'gender': '男'}
字典取值: 小明
元组取值: 10
集合（自动去重）: {1, 2, 3}

关键解释

容器类型	特点	常用场景
列表	有序、可变	存储有序数据（如列表）
字典	键值对、无序	存储关联数据（如用户信息）
元组	有序、不可变	存储固定值（如坐标）
集合	无序、无重复	去重、交集 / 并集计算

---

6. 函数定义与调用

核心：封装重复逻辑，提高代码复用性，掌握参数、返回值、默认参数的使用。

# ==================== 6. 函数定义与调用 ====================
print("\n===== 函数 =====")

# 1. 基础函数：带参数+返回值
def calculate_sum(a, b):
    """计算两个数的和（函数文档字符串，可通过help查看）"""
    return a + b  # 返回计算结果

# 调用函数：传入参数，接收返回值
result = calculate_sum(5, 3)
print("5 + 3 =", result)

# 2. 带默认参数的函数：参数有默认值，调用时可省略
def greet(name, msg="你好"):  # msg默认值为"你好"
    return f"{msg}, {name}!"

# 调用方式1：使用默认参数
print(greet("Python"))       
# 调用方式2：覆盖默认参数
print(greet("Java", "哈喽"))  

运行结果：

===== 函数 =====
5 + 3 = 8
你好, Python!
哈喽, Java!

关键解释：

• 函数定义用def，结束加冒号:，代码块缩进；
• 默认参数必须放在非默认参数后面（如greet(name, msg="你好")正确，greet(msg="你好", name)错误）；
• 文档字符串（"""内容"""）用于说明函数功能，是良好的编程习惯。

---

7. 异常处理

核心：捕获程序运行时的错误，避免程序崩溃，掌握 try-except-finally 结构。

# ==================== 7. 异常处理 ====================
print("\n===== 异常处理 =====")
try:
    # 可能出错的代码块
    10 / 0  # 除零错误：Python会抛出ZeroDivisionError
except ZeroDivisionError as e:
    # 捕获指定异常，并处理
    print("捕获异常:", e)  # 输出异常信息
finally:
    # 无论是否出错，都会执行（常用于释放资源）
    print("无论是否异常，都会执行这行")

运行结果：

===== 异常处理 =====
捕获异常: division by zero
无论是否异常，都会执行这行

关键解释：

• try：包裹可能出错的代码；
• except：捕获指定异常（可写多个 except 处理不同异常）；
• finally：可选，无论是否出错都执行（如关闭文件、数据库连接）。

---

8. 类与对象（面向对象基础）

核心：Python 是面向对象语言，类是对象的模板，对象是类的实例。

# ==================== 8. 简单的类与对象（面向对象基础） ====================
print("\n===== 面向对象 =====")

# 定义类：用class关键字，类名首字母大写（规范）
class Student:
    # 构造方法：初始化对象属性，self代表实例本身
    def __init__(self, name, grade):
        self.name = name  # 实例属性：每个对象独立拥有
        self.grade = grade

    # 实例方法：必须带self参数，可访问实例属性
    def show_info(self):
        return f"学生: {self.name}, 年级: {self.grade}"

# 创建对象（实例化）：传入参数初始化属性
stu = Student("小红", "三年级")
# 调用对象方法
print(stu.show_info())

运行结果：

===== 面向对象 =====
学生: 小红, 年级: 三年级

关键解释：

• __init__是构造方法，创建对象时自动执行；
• self是必传参数，代表当前对象，不能省略；
• 实例属性（如self.name）属于单个对象，不同对象的属性值互不影响。

---

9. 切片

核心：快速截取序列（字符串 / 列表 / 元组）的部分内容，格式：[起始索引:结束索引:步长]（左闭右开）。

# ==================== 9. 切片（序列操作核心） ====================
print("\n===== 切片 =====")
str1 = "Python语法学习"
list1 = [10, 20, 30, 40, 50]

# 基础切片：[:6] 表示从0开始，到索引6（不包含）结束
print("字符串切片（取前6个）:", str1[:6])       
# [1:4] 表示从索引1开始，到索引4（不包含）结束
print("列表切片（取2-4位）:", list1[1:4])      

# 步长切片：[::2] 表示从头到尾，每隔1个取1个（步长2）
print("列表步长切片:", list1[::2])             
# 反向切片：[::-1] 步长为-1，反转序列
print("字符串反转:", str1[::-1])              

运行结果：

===== 切片 =====
字符串切片（取前6个）: Python
列表切片（取2-4位）: [20, 30, 40]
列表步长切片: [10, 30, 50]
字符串反转: 习学法语nohtyP

关键解释：

• 切片规则：左闭右开（包含起始索引，不包含结束索引）；
• 省略起始索引默认从 0 开始，省略结束索引默认到末尾；
• 步长为负数表示反向截取，是反转字符串 / 列表的常用技巧。

---

10. 推导式（Python 特色语法）

核心：一行代码快速生成列表 / 字典 / 集合，比循环更简洁高效。

# ==================== 10. 推导式（Python特色，简洁高效） ====================
print("\n===== 推导式 =====")

# 1. 列表推导式：[表达式 for 变量 in 可迭代对象 if 条件]
# 生成0-9的偶数列表
nums = [i for i in range(10) if i % 2 == 0]  
print("列表推导式（偶数）:", nums)           

# 2. 字典推导式：{键表达式: 值表达式 for 变量 in 可迭代对象}
# 生成键为0-2，值为键*2的字典
dict1 = {k: k*2 for k in range(3)}           
print("字典推导式:", dict1)                  

# 3. 集合推导式：{表达式 for 变量 in 可迭代对象}（自动去重）
set1 = {x for x in [1,1,2,3,3]}             
print("集合推导式:", set1)                  

运行结果：

===== 推导式 =====
列表推导式（偶数）: [0, 2, 4, 6, 8]
字典推导式: {0: 0, 1: 2, 2: 4}
集合推导式: {1, 2, 3}

关键解释：

• 推导式是 Python 的 “语法糖”，等价于循环但更简洁；
• 列表推导式最常用，可替代简单的 for 循环 + append；
• 推导式中if条件是可选的，用于过滤元素。

---

11. 迭代器与生成器

核心：惰性生成数据，节省内存，迭代器用iter()创建，生成器用yield定义。

# ==================== 11. 迭代器与生成器 ====================
print("\n===== 迭代器/生成器 =====")

# 1. 迭代器：可逐个取值，不一次性加载所有数据（节省内存）
iter_obj = iter([1,2,3])  # 将列表转为迭代器
print("迭代器取值:", next(iter_obj))          # 取第一个值：1
print("迭代器取值:", next(iter_obj))          # 取第二个值：2
# 继续next会取3，再next会抛出StopIteration异常

# 2. 生成器：带yield的函数，调用时返回生成器对象（惰性生成）
def gen_numbers():
    for i in range(3):
        yield i  # 暂停函数，返回值，下次调用从这里继续

gen = gen_numbers()  # 调用函数，不执行代码，返回生成器
print("生成器取值:", next(gen))              # 执行到yield，返回0
print("生成器取值:", next(gen))              # 继续执行，返回1

运行结果

===== 迭代器/生成器 =====
迭代器取值: 1
迭代器取值: 2
生成器取值: 0
生成器取值: 1

关键解释：

• 迭代器 / 生成器的核心优势：按需生成数据，适合处理大数据（如读取大文件）；
• yield是生成器的核心：遇到yield暂停，下次next()继续执行；
• 可直接用 for 循环遍历迭代器 / 生成器（自动处理 StopIteration）。

---

12. 模块导入与使用

核心：Python 的强大之处在于丰富的标准库 / 第三方库，掌握 3 种导入方式。

# ==================== 12. 模块导入与使用 ====================
print("\n===== 模块导入 =====")

# 方式1：导入整个模块，使用时加模块名
import math
print("π的值:", math.pi)                      # 访问模块中的属性
print("平方根(16):", math.sqrt(16))           # 调用模块中的函数

# 方式2：导入模块中的指定函数/属性（推荐，减少内存占用）
from random import randint
print("随机数(1-10):", randint(1, 10))       # 直接调用函数，无需加模块名

# 方式3：导入模块并指定别名（简化名称）
import datetime as dt
print("当前时间:", dt.datetime.now())         # 用别名访问

运行结果示例：

===== 模块导入 =====
π的值: 3.141592653589793
平方根(16): 4.0
随机数(1-10): 7
当前时间: 2026-03-21 15:30:25.123456

关键解释：

• 标准库模块（如 math/random/datetime）无需安装，直接导入；
• 第三方模块（如 pandas/numpy）需要先pip install安装，再导入；
• 别名通常用简短且易记的字符（如import pandas as pd）。

---

13. 装饰器（进阶基础）

核心：不修改原函数代码，为函数添加额外功能（如日志、计时），是 Python 的高级语法糖。

# ==================== 13. 装饰器（Python进阶基础） ====================
print("\n===== 装饰器 =====")

# 定义装饰器函数：接收被装饰的函数作为参数
def time_decorator(func):
    # 包装函数：接收任意参数（*args：位置参数，**kwargs：关键字参数）
    def wrapper(*args, **kwargs):
        print(f"开始执行函数: {func.__name__}")  # 额外功能：打印执行信息
        result = func(*args, **kwargs)           # 调用原函数
        print(f"函数 {func.__name__} 执行完成")  # 额外功能：打印完成信息
        return result                            # 返回原函数结果
    return wrapper  # 返回包装函数

# 使用装饰器：@+装饰器名，放在函数定义上方
@time_decorator
def add(a, b):
    return a + b

# 调用函数：自动触发装饰器的包装函数
print("add(2,3) =", add(2, 3))              

运行结果：

===== 装饰器 =====
开始执行函数: add
函数 add 执行完成
add(2,3) = 5

关键解释：

• 装饰器的本质是高阶函数 + 闭包；
• *args接收任意数量的位置参数，**kwargs接收任意数量的关键字参数；
• 装饰器常用于日志记录、性能计时、权限校验等场景。

---

14. with 语句（上下文管理器）

核心：自动管理资源（如文件、网络连接），无需手动关闭，避免资源泄漏。

# ==================== 14. with语句（上下文管理器，文件/资源操作） ====================
print("\n===== with语句 =====")

# 1. 写入文件：with自动关闭文件，即使出错也会关闭
# "w"表示写入模式，encoding="utf-8"避免中文乱码
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("学习Python语法")  # 无输出，仅写入内容到文件

# 2. 读取文件："r"表示读取模式
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()  # 读取文件全部内容
    print("文件内容:", content)              

运行结果：

===== with语句 =====
文件内容: 学习Python语法

关键解释：

• 替代传统的f = open() + f.close()，避免忘记 close 导致资源泄漏；
• 常用模式：w（写入，覆盖原有内容）、r（读取）、a（追加）、rb/wb（二进制模式）；
• 除了文件，with 还可用于数据库连接、网络请求等场景。

---

15. 三元表达式

核心：一行代码实现简单的 if-else 判断，简化代码。

# ==================== 15. 三元表达式（简洁的条件赋值） ====================
print("\n===== 三元表达式 =====")
num = 99
# 格式：结果1 if 条件 else 结果2
# 条件成立返回结果1，否则返回结果2
result = "及格" if num >= 60 else "不及格"
print(f"{num}分: {result}")                  

运行结果：

===== 三元表达式 =====
99分: 及格

关键解释：

• 三元表达式是简化版的 if-else，仅适用于简单条件判断；
• 不要嵌套三元表达式（可读性差）；
• 等价于：

  if num >= 60:
      result = "及格"
  else:
      result = "不及格"
  

---

 学习建议

1. 不要死记语法：把上面的代码逐行敲一遍，修改参数（如把num=99改成59），观察结果变化，理解比记忆更重要；
2. 优先级学习：先掌握前 8 个基础语法（数据类型、运算符、循环、函数等），再学进阶语法；
3. 实战巩固：用学会的语法写小项目（如计算器、待办清单、简单爬虫），快速提升熟练度；
4. 查文档：遇到问题优先查 Python 官方文档（https://docs.python.org/3/），培养独立解决问题的能力。

如果你觉得这篇文章有帮助，欢迎点赞 + 收藏 + 关注！