Python核心语法全套精讲（保姆级）

今天双栈小码哥 把全套Python核心知识点做完整梳理，讲解通俗易懂、包含推导式、匿名函数、高阶函数、迭代生成器、装饰器、面向对象、正则、文件操作等内容。

2026 Python3最新语法

• • 一、推导式（列表/字典/集合）
  • • 1. 列表推导式
    • 2. 字典推导式
    • 3. 集合推导式
    • 推导式小结
  • 二、lambda 匿名函数
  • • 基础语法
    • lambda使用限制与场景
  • 三、高阶函数 map / filter / reduce
  • • 1. map 映射函数
    • 2. filter 过滤函数
    • 3. reduce 累积计算函数
    • 三者核心区别
  • 四、迭代器 Iterator
  • • 核心概念区分
    • 自定义迭代器
  • 五、生成器 Generator
  • • 1. 生成器表达式
    • 2. yield生成器函数
    • 生成器优势
  • 六、装饰器
  • • 基础无参装饰器
    • 通用万能装饰器
    • 常用实战装饰器
  • 七、异常捕获 try-except
  • • 完整语法结构
    • 主动抛异常与自定义异常
  • 八、文件读写操作
  • • 常用打开模式
    • 基础读写案例
    • 文件指针操作
  • 九、os模块路径文件夹操作
  • 十、datetime时间处理模块
  • 十一、面向对象编程 OOP
  • • 类与对象基础定义
    • 三大特性实战
    • 三类方法区分
  • 十二、常用魔法方法
  • 十三、正则表达式 re模块
  • • 常用基础元字符
    • 核心方法实战
  • 十四、JSON数据处理
  • 十五、深浅拷贝
  • • 三者总结
  • 十六、日志与断点调试
  • • 1. 断点pdb调试
    • 2. logging标准日志模块
  • 全文总结

一、推导式（列表/字典/集合）

推导式是Python专属精简语法，一行代码替代多行循环判断，代码简洁且执行效率更高，快速批量生成、筛选、转换数据。

1. 列表推导式

基础语法：[表达式 for 变量 in 可迭代对象] 条件语法：[表达式 for 变量 in 可迭代对象 if 筛选条件] 嵌套语法：[表达式 for 外层变量 in 外层容器 for 内层变量 in 内层容器]

# 基础生成1~10数字列表
num_list = [i for i in range(1, 11)]
print(num_list)

# 条件筛选：只保留偶数
even_list = [i for i in range(1, 11) if i % 2 == 0]
print(even_list)

# 双层嵌套推导，二维列表转一维
two_list = [[1,2,3],[4,5,6]]
one_list = [j for i in two_list for j in i]
print(one_list)

2. 字典推导式

语法：{键表达式:值表达式 for 变量 in 可迭代对象 if 条件} 常用于快速建字典、筛选键值、键值互换

# 生成数字与平方对应字典
square_dict = {i:i**2 for i in range(1,6)}
print(square_dict)

# 筛选保留键为偶数的数据
filter_dict = {k:v for k,v in square_dict.items() if k%2==0}
print(filter_dict)

# 字典键值互换
swap_dict = {v:k for k,v in square_dict.items()}
print(swap_dict)

3. 集合推导式

语法：{表达式 for 变量 in 可迭代对象 if 条件} 集合自带自动去重特性，适合数据去重筛选

# 自动去除重复数值
old_data = [2,2,3,3,4,5]
set_data = {x for x in old_data}
print(set_data)

# 筛选大于10的平方数
big_set = {x**2 for x in range(1,7) if x**2 > 10}
print(big_set)

推导式小结

• 列表推导：有序可重复，日常数据存储首选
• 字典推导：键值映射结构，适合关联数据
• 集合推导：无序自动去重，清洗重复数据

二、lambda 匿名函数

无需定义函数名称的简易函数，适合简短逻辑一次性调用，搭配高阶函数使用大幅精简代码，仅支持单行表达式。

基础语法

lambda 参数列表 : 返回表达式

# 无参数匿名函数
func1 = lambda : 100
print(func1())

# 单个参数运算
func2 = lambda x : x * 3
print(func2(6))

# 多个参数求和
func3 = lambda x,y : x + y
print(func3(10,20))

# 条件判断写法
func4 = lambda x : "成年" if x >= 18 else "未成年"
print(func4(20))

lambda使用限制与场景

三、高阶函数 map / filter / reduce

接收函数作为参数，或是返回函数的函数，批量处理可迭代容器数据，简化遍历代码。

1. map 映射函数

作用：对容器每一个元素统一执行相同逻辑，返回迭代器 语法：map(处理函数, 可迭代对象)

# 列表所有元素统一翻倍
origin = [1,2,3,4,5]
res_map = list(map(lambda x:x*2, origin))
print(res_map)

# 两个序列并行运算
a = [10,20,30]
b = [1,2,3]
sum_map = list(map(lambda x,y:x+y, a, b))
print(sum_map)

2. filter 过滤函数

作用：根据布尔结果筛选元素，保留判定为True的数据 语法：filter(判定函数, 可迭代对象)

# 筛选列表中奇数
nums = [1,2,3,4,5,6,7,8]
odd_data = list(filter(lambda x:x%2!=0, nums))
print(odd_data)

3. reduce 累积计算函数

作用：依次叠加运算所有元素，最终返回单个结果 Python3需要手动从functools模块导入

from functools import reduce

# 列表累加求和
data = [2,4,6,8]
sum_total = reduce(lambda x,y:x+y, data)
print(sum_total)

# 列表累乘计算
mul_total = reduce(lambda x,y:x*y, data)
print(mul_total)

三者核心区别

• map：统一加工转换所有元素
• filter：按照规则过滤筛选元素
• reduce：聚合运算得出最终单一结果

四、迭代器 Iterator

可通过next()逐个取值、记录遍历位置的对象，具备惰性取值特性，节省内存空间。

核心概念区分

• 可迭代对象：列表、元组、字符串、字典，拥有__iter__方法
• 迭代器：拥有__iter__和__next__双方法，单向遍历、取完失效

# 可迭代对象转为迭代器
str_obj = "python"
iter_obj = iter(str_obj)

# 逐个取出数据
print(next(iter_obj))
print(next(iter_obj))

# for循环遍历剩余迭代器数据
for item in iter_obj:
print(item)

自定义迭代器

class MyIter:
def __init__(self, start, end):
self.start = start
self.end = end

def __iter__(self):
return self

def __next__(self):
if self.start < self.end:
temp = self.start
self.start += 1
return temp
else:
# 遍历完毕抛出终止异常
raise StopIteration

# 调用自定义迭代器
my_iter = MyIter(1,5)
for i in my_iter:
print(i)

五、生成器 Generator

特殊的迭代器，按需生成数据，海量数据场景大幅降低内存占用，两种创建方式。

1. 生成器表达式

将列表推导式中[]替换为()即可

# 生成器表达式创建
gen_expr = (i**2 for i in range(1,6))
print(next(gen_expr))
print(list(gen_expr))

2. yield生成器函数

函数内使用yield关键字，执行到yield暂停，下次调用继续执行，区别于return直接结束函数

def create_gen(max_num):
n = 0
while n < max_num:
yield n
n += 1

# 调用生成器
gen_func = create_gen(4)
print(next(gen_func))
print(next(gen_func))

# 循环遍历取值
for num in gen_func:
print(num)

生成器优势

惰性加载数据，不会一次性全部存入内存，处理百万级数据不会卡顿溢出

六、装饰器

不修改原有函数代码、不改变函数调用方式，动态给函数新增功能，遵循开闭设计原则，底层依托高阶函数与闭包实现。

基础无参装饰器

# 定义装饰器
def outer(func):
def inner():
# 函数执行前置操作
print("程序开始执行")
func()
# 函数执行后置操作
print("程序执行结束")
return inner

# 语法糖调用装饰器
@outer
def business():
print("核心业务逻辑运行")

business()

通用万能装饰器

适配任意参数、任意返回值的函数

def decorator(func):
def inner(*args, **kwargs):
print("前置日志记录")
res = func(*args, **kwargs)
print("后置数据统计")
return res
return inner

@decorator
def add_num(x,y):
return x + y

result = add_num(15,25)
print(result)

常用实战装饰器

日志记录、运行耗时统计、权限校验、接口缓存拦截均可通过装饰器快速实现

七、异常捕获 try-except

捕获程序运行报错，阻止程序直接崩溃，完善代码容错性，搭配else、finally实现完整异常逻辑。

完整语法结构

try：存放可能报错代码 except：捕获对应异常执行补救逻辑 else：无异常时执行代码 finally：无论是否报错必定执行，多用于资源关闭

try:
num = int(input("请输入数字："))
res = 100 / num
except ValueError:
print("输入格式错误，必须为整数")
except ZeroDivisionError:
print("除数不能为0，运算非法")
except Exception as e:
print("未知异常：",e)
else:
print("计算结果：",res)
finally:
print("本次运算流程结束")

主动抛异常与自定义异常

# 主动抛出异常
def check_age(age):
if age < 0:
raise ValueError("年龄数值不合法")

# 自定义异常类
class SelfError(Exception):
pass

八、文件读写操作

依托open函数实现文本、二进制文件读写，with上下文管理器自动关闭文件，避免资源占用泄露。

常用打开模式

• r：只读模式，文件不存在报错
• w：清空写入，不存在自动创建
• a：尾部追加写入
• r+：可读可写，不覆盖原文件
• b：二进制模式，处理图片、视频、压缩包

基础读写案例

# 文本写入文件
with open("test.txt","w",encoding="utf-8") as f:
f.write("Python文件读写实战\\n基础操作练习")

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

# 按行读取文件
with open("test.txt","r",encoding="utf-8") as f:
line1 = f.readline()
print(line1)

文件指针操作

seek调整读取位置，tell查看当前指针坐标

with open("test.txt","r",encoding="utf-8") as f:
f.seek(5)
print(f.tell())
print(f.read())

九、os模块路径文件夹操作

操作系统交互模块，实现路径判断、文件夹创建删除、目录遍历、工作路径切换等功能。

import os

# 获取当前程序运行目录
print(os.getcwd())

# 跨平台路径拼接
path = os.path.join("file","data","info.txt")
print(path)

# 判断文件/文件夹是否存在
print(os.path.exists("test.txt"))
print(os.path.isdir("folder"))

# 创建、删除文件夹
os.mkdir("new_folder")
os.rmdir("new_folder")

# 遍历当前目录所有文件
file_list = os.listdir("./")
print(file_list)

十、datetime时间处理模块

替代老旧不安全的time模块，实现时间获取、格式化、时间加减、时间戳转换，日常时间业务首选。

from datetime import datetime, timedelta

# 获取当前系统时间
now_time = datetime.now()
print(now_time)

# 时间对象转为格式化字符串
str_time = now_time.strftime("%Y-%m-%d %H:%M:%S")
print(str_time)

# 字符串转回时间对象
obj_time = datetime.strptime("2026-05-22","%Y-%m-%d")
print(obj_time)

# 时间推算加减
future_time = now_time + timedelta(days=7,hours=3)
print(future_time)

# 时间戳相互转换
timestamp = now_time.timestamp()
print(datetime.fromtimestamp(timestamp))

常用格式符：%Y年 %m月 %d日 %H时 %M分 %S秒

十一、面向对象编程 OOP

Python主流编程思想，封装、继承、多态三大核心特性，用类与对象描述实体，代码复用性更强。

类与对象基础定义

# 定义人类模板类
class Person:
# 构造方法，初始化实例属性
def __init__(self,name,age):
self.name = name
self.age = age

# 实例行为方法
def speak(self):
print(f"姓名：{self.name}，年龄：{self.age}")

# 实例化创建对象
p1 = Person("张三",22)
p1.speak()

三大特性实战

三类方法区分

• 实例方法：绑定对象，使用self参数
• 类方法：绑定类，使用@classmethod、cls参数
• 静态方法：独立方法，使用@staticmethod修饰

十二、常用魔法方法

首尾双下划线内置方法，无需手动调用，特定场景自动触发，自定义类的运行行为。

class Student:
# 构造方法：创建对象自动触发
def __init__(self,name):
self.name = name

# 打印对象自动触发
def __str__(self):
return f"学生姓名：{self.name}"

# 对象销毁自动触发
def __del__(self):
print("对象资源已释放")

# 调用魔法方法
stu = Student("李四")
print(stu)
del stu

高频魔法方法：__init__、__str__、__del__、__len__、__getitem__

十三、正则表达式 re模块

文本匹配、提取、替换核心工具，处理爬虫数据、表单校验、文本清洗必备语法。

常用基础元字符

• \\d数字 \\w字母数字下划线 \\s空白字符
• .任意字符 *匹配任意次数 +至少一次 ?0次或1次
• ^开头匹配 $结尾匹配 {n}固定次数匹配

核心方法实战

import re

text = "手机号：13512345678，备用号：13887654321"

# findall匹配所有符合规则内容
phone_list = re.findall(r"1[3-9]\\d{9}",text)
print(phone_list)

# search匹配第一个符合数据
first_num = re.search(r"\\d+",text)
print(first_num.group())

# sub替换指定内容
new_text = re.sub(r"\\d{11}","********",text)
print(new_text)

十四、JSON数据处理

前后端接口、文件存储通用数据格式，实现Python字典列表与JSON字符串相互转换。

import json

# Python字典数据
user_data = {"name":"王五","age":25,"hobby":["打球","阅读"]}

# 字典转为JSON字符串
json_str = json.dumps(user_data,ensure_ascii=False,indent=2)
print(json_str)

# JSON字符串转回字典
dict_data = json.loads(json_str)
print(dict_data)

# 写入JSON文件
with open("user.json","w",encoding="utf-8") as f:
json.dump(user_data,f,ensure_ascii=False,indent=2)

# 读取JSON文件
with open("user.json","r",encoding="utf-8") as f:
read_data = json.load(f)
print(read_data)

十五、深浅拷贝

针对嵌套列表、字典等复合数据，解决赋值引用导致数据联动修改问题，分为赋值、浅拷贝、深拷贝。

import copy

# 嵌套多层列表
origin_list = [10,20,[30,40]]

# 直接赋值：共用同一内存地址
copy1 = origin_list
# 浅拷贝：仅拷贝顶层，内层依旧引用
copy2 = copy.copy(origin_list)
# 深拷贝：递归拷贝所有层级，完全独立
copy3 = copy.deepcopy(origin_list)

# 修改内层数据观察变化
origin_list[2][0] = 999
print(origin_list)
print(copy1)
print(copy2)
print(copy3)

三者总结

• 赋值：完全引用，数据互相影响
• 浅拷贝：顶层独立，嵌套数据同步变化
• 深拷贝：全程独立，修改互不干扰

十六、日志与断点调试

项目排错、程序运维必备技能，替代简易print打印，规范日志输出，精准定位代码BUG。

1. 断点pdb调试

import pdb

def calc(a,b):
pdb.set_trace() # 断点入口
res = a * b
return res

calc(6,8)

常用指令：n下一步、c继续运行、p查看变量、q退出调试

2. logging标准日志模块

分级记录日志，可输出控制台与本地文件，规范项目日志格式

import logging

# 初始化日志配置
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s – %(levelname)s – %(message)s",
datefmt="%Y-%m-%d %H:%M:%S"
)

# 五级日志输出
logging.debug("调试级别信息")
logging.info("正常业务信息")
logging.warning("程序警告提示")
logging.error("代码运行错误")
logging.critical("严重致命故障")

全文总结

以上内容覆盖入门到进阶核心，日常开发、面试笔试均高频使用，多敲代码实操即可熟练掌握。

我是双栈小码哥，深耕Java+Python双栈开发，持续更新实战教程、面试干货、项目案例！