Python 进阶极简教程（高阶核心+纯用法）

python基础版

说明：承接Python基础教程，全文无冗余描述，仅保留进阶核心知识点 + 作用 + 可运行代码，覆盖Python后端、脚本、工程化全部高阶刚需内容。

一、变量与深浅拷贝（进阶核心）

1. 引用机制原理

作用：弄懂赋值、浅拷贝、深拷贝区别，解决数据篡改问题

# 赋值：只是绑定同一内存地址（完全共享数据）
a = [1, 2, [3, 4]]
b = a
b[0] = 99
print(a) # a同步被修改

2. 浅拷贝 copy

作用：拷贝一层数据，内层嵌套对象依旧引用

import copy
a = [1, 2, [3, 4]]
b = copy.copy(a)
b[0] = 99       # 外层独立，不影响原数据
b[2][0] = 999   # 内层嵌套共享，原数据被修改
print(a)

3. 深拷贝 deepcopy

作用：递归拷贝所有层级，完全独立数据，互不影响

import copy
a = [1, 2, [3, 4]]
b = copy.deepcopy(a)
b[2][0] = 999
print(a) # 原数据完全不变

二、函数高阶特性

1. 闭包

作用：内层函数捕获外层局部变量，保存私有状态，数据常驻内存

def counter():
    num = 0
    def inner():
        nonlocal num # 声明使用外层变量
        num += 1
        return num
    return inner

# 多个实例状态独立
c1 = counter()
c2 = counter()
print(c1()) # 1
print(c1()) # 2
print(c2()) # 1

2. 装饰器（无参/有参）

作用：不修改原函数代码，动态扩展功能（日志、校验、计时）

# 无参装饰器
def wrapper(func):
    def inner(*args, **kwargs):
        print("执行前")
        res = func(*args, **kwargs)
        print("执行后")
        return res
    return inner

@wrapper
def test():
    print("核心逻辑")

test()

3. 递归优化与尾递归

作用：简化循环逻辑，处理层级嵌套数据

# 阶乘递归
def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)

print(fact(10))

4. 函数缓存 lru\_cache

作用：缓存函数返回值，解决递归重复计算，大幅提速

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n <= 2:
        return 1
    return fib(n-1) + fib(n-2)

print(fib(30))

三、高阶语法与推导式

1. 四大推导式

作用：极简代码快速生成容器数据，开发高频用法

# 列表推导式
lst = [x for x in range(10) if x % 2 == 0]

# 字典推导式
dic = {k:v for k,v in zip(["a","b"], [1,2])}

# 集合推导式
s = {x**2 for x in [1,2,2,3]}

# 生成器推导式（省内存）
gen = (x for x in range(10))
print(next(gen))

2. 高阶函数 map/filter/reduce

作用：批量处理、过滤、聚合数据

from functools import reduce
lst = [1,2,3,4]

# map 批量处理
res1 = list(map(lambda x:x*2, lst))

# filter 过滤数据
res2 = list(filter(lambda x:x>2, lst))

# reduce 累计聚合
res3 = reduce(lambda a,b:a+b, lst)

print(res1, res2, res3)

四、面向对象进阶

1. 类属性与实例属性

作用：区分全局类属性、私有实例属性，优化内存

class Demo:
    cls_val = 100 # 类属性（全局共享）
    def __init__(self, val):
        self.val = val # 实例属性（独立私有）

d1 = Demo(200)
d2 = Demo(300)
print(Demo.cls_val)
print(d1.val, d2.val)

2. 三大方法（实例/类/静态）

作用：适配不同场景的类调用逻辑

class Test:
    # 实例方法：必须实例调用，自带self
    def func1(self):
        pass

    # 类方法：类/实例均可调用，自带cls
    @classmethod
    def func2(cls):
        pass

    # 静态方法：无默认参数，纯工具方法
    @staticmethod
    def func3():
        pass

3. 继承、重写、多继承

作用：代码复用，实现多态特性

# 父类
class Father:
    def show(self):
        print("父类方法")

# 子类继承 + 方法重写
class Son(Father):
    def show(self):
        print("子类重写方法")

s = Son()
s.show()

4. 私有属性与属性装饰器

作用：数据封装，控制属性读写权限

class User:
    def __init__(self, age):
        self.__age = age # 私有属性（外部无法直接访问）

    # 属性装饰器：将方法转为属性调用
    @property
    def age(self):
        return self.__age

u = User(18)
print(u.age)

五、迭代器与生成器（性能优化）

1. 迭代器原理

作用：统一遍历规则，节省内存

lst = [1,2,3]
it = iter(lst) # 获取迭代器
print(next(it))
print(next(it))

2. 生成器 yield

作用：边执行边返回，不一次性加载所有数据，处理超大数据集

def gen():
    yield 1
    yield 2
    yield 3

g = gen()
print(next(g))
print(next(g))

# 遍历生成器
for i in gen():
    print(i)

六、异常处理进阶

1. 完整异常捕获结构

作用：精准捕获异常，程序不崩溃

try:
    num = 1 / 0
except ZeroDivisionError as e:
    print("除零错误：", e)
except Exception as e:
    print("通用错误：", e)
else:
    print("无异常执行")
finally:
    print("必定执行")

2. 主动抛异常

作用：参数校验、逻辑拦截主动终止程序

def check_age(age):
    if age < 0:
        raise ValueError("年龄不能为负数")

check_age(-1)

七、文件与上下文管理器

1. with 上下文管理器

作用：自动关闭文件、释放资源，无需手动close

# 读写文件自动释放
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("进阶测试")

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

2. 自定义上下文管理器

作用：自定义资源开启、关闭逻辑

class MyCtx:
    def __enter__(self):
        print("开启资源")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("关闭资源")

with MyCtx():
    print("执行业务逻辑")

八、模块、包与导包进阶

1. \_\_init\_\_.py 作用

作用：标识文件夹为Python包，统一导出接口

# 在包目录 __init__.py 中定义
__all__ = ["func1", "Demo"] # 控制from xxx import * 导入内容

# 批量导出
from .test import func1, Demo

2. 动态导包

作用：程序运行中动态导入模块，灵活解耦

import importlib

# 动态导入指定模块
module = importlib.import_module("math")
print(module.pi)

九、多线程与多进程

1. 多线程（IO密集型）

作用：处理等待、文件、网络IO任务

import threading
import time

def task(name):
    print(f"线程{name}执行")
    time.sleep(1)

t = threading.Thread(target=task, args=("A",))
t.start()
t.join() # 等待线程结束

2. 多进程（CPU密集型）

作用：绕过GIL全局锁，多核并行计算

from multiprocessing import Process

def task():
    print("子进程执行")

if __name__ == "__main__":
    p = Process(target=task)
    p.start()
    p.join()

十、协程异步编程

作用：超高并发IO处理，性能远超多线程

import asyncio

# 异步函数
async def async_task(num):
    print(f"任务{num}开始")
    await asyncio.sleep(1)
    print(f"任务{num}结束")

# 并发执行
async def main():
    tasks = [async_task(1), async_task(2)]
    await asyncio.gather(*tasks)

asyncio.run(main())

十一、正则表达式进阶

作用：复杂文本匹配、提取、替换、校验

import re

s = "Python123Java456"

# 匹配所有数字
res1 = re.findall(r"\d+", s)
# 匹配所有字母
res2 = re.findall(r"\a+", s)
# 替换指定内容
res3 = re.sub(r"\d", "", s)

print(res1, res2, res3)

十二、GIL锁与性能优化

作用：理解Python单线程特性，针对性优化代码

• GIL全局解释器锁：同一时刻一个进程只有一个线程执行Python代码
• CPU密集：用多进程规避GIL
• IO密集：用多线程/协程提升效率

十三、常用工程化技巧

1. 枚举类

作用：固定常量状态，避免魔法值

from enum import Enum

class Status(Enum):
    SUCCESS = 200
    FAIL = 500

print(Status.SUCCESS.value)

2. 时间处理

作用：时间戳、格式化、时间差计算

from datetime import datetime

# 当前时间
now = datetime.now()
# 格式化时间
time_str = now.strftime("%Y-%m-%d %H:%M:%S")
print(time_str)

版权属于：Joyber

本文链接：https://blog.qqvbc.com/default/1534.html

转载时须注明出处及本声明