ython 高级语法

第 1 天：推导式（列表 / 字典 / 集合推导式）

推导式是 Python 特有的简写语法，用一行代码快速生成列表、字典、集合，替代传统for循环拼接数据，代码更简洁、执行效率更高。

分为三类：列表推导式、字典推导式、集合推导式

二、语法通用格式

1.基础版：【表达式 for 变量 in 可迭代对象】

2.带条件版：【表达式 for 变量 in 可迭代对象 if 对象】

1. 列表推导式（最常用）

含义

快速创建 / 转换列表，替代多行 for 循环。

Demo1：基础用法（生成 0~9 数字列表）

#列表推导式写法

list2 = [i for i in range(10)]

print("列表推导式:",list2)

Demo2：带条件筛选（只保留偶数）

#筛选0-1的偶数

even_lst= [ i for i in range(10) if i % 2==0]

print("筛选偶数:",even_lst)

说明：if i % 2 == 0过滤条件，只把满足条件的元素加入列表。

Demo3：表达式加工（元素做运算）

#每个数字乘以2

double_lt = [i *2 for i in rang(5)]

print("元素乘2：", double_lst)

2.字典推导式

含义

快速生成、转化字典，格式用{键：值 for ...}

Demo：列表转字典 + 条件筛选

#基础 ：下表+元素组成字典

data = ["a","b","c"]

dict1 = { index: val for index, val in enumerate(data)}

#enumerate 同时去出元素的下标和元素值

print("下标+元素组成字典:",dict1)

条件筛选：只保留大于1的项

dict2 = { k,v for k,v in {1:10,2:20,3:30}.items() if k>1} #字典的item遍历字段，逐个去除每一组的key和value

3. 集合推导式

生成集合（自动去重），格式{元素 for ...} 用发和列表推导式几乎一致

Dmeo列表去重

old_lst = [1,2,2,3,3,3]

new_set = {x for x in old_lst}

print("去重后的集合:",new_set)

今日小结

核心：一行代码替代 for 循环，优先掌握列表推导式（工作用得最多）

格式记忆：[元素 for 变量 in 遍历对象 if 条件]

生成器 Generstor

一、含义讲解

1、列表推导式会一次性把所有数据存入内存，数据量大时占用内存极高

2、生成器是惰性迭代器，用一个取一个，不会一次性加载全部数据，极大节省内存

3、两种创建方式：生成器表达式、生成器函数（带 yield）

生成器表达式（和列表推导式仅符号不同）

把列表推导式的[]改成()，就是生成器表达式。

#列表推导式

lst = [ i for i in range(10000)]

print("列表推导式:",type(lst))

#生成器表达式 :惰性加载

gen = (i for i in range(10000))

print("生成器类型：", type(gen))

#取值方式1：next（）逐个取

print(next(gen))

print(next(gen))

#取值方式2：for循环遍历（推荐）

for num in gen:

if num > 5 :

break

print(num, end=" ")

关键说明

生成器只能向前遍历，不会回退，取完就空了

大数据场景（百万 / 千万条数据）优先用生成器。

2.生成器函数（yield关键词，）

含义

普通函数用return返回结果，执行结束

生成器函数用yield返回数据，暂停执行，下次取值继续往下走

Demo1：基础 yield 用法

def my_generator():

print("生成器函数开始")

yield 1 #暂停 返回1

print("生成器函数继续")

yield 2 #暂停 返回2

print("生成器函数结束")

return 3 #返回值

调用函数，得到生成器对象

my_gen = my_generator()

#第一次next:执行到第一个yield暂停

next(my_gen)

print("第一次next:",next(my_gen))

#第二次next:执行到第二个yield暂停

next(my_gen)

print("第二次next:",next(my_gen))

#第三次next:执行到return语句，结束生成器函数

print("第三次next:",next(my_gen))

#第四次next:抛出StopIteration异常

next(my_gen)

Demo2：实战 - 无限数列（生成器经典场景）

def infinite_num():

n = 0

while True:

yield n

n += 1

g = infinite_num()

#循环取值，不会内存溢出

for _ in range(5):

print(next(g))

今日小结

列表：一次性加载，占内存；生成器：惰性取值，省内存。

标识：()生成器表达式 / 函数内写yield就是生成器。

取值：next()或for循环。

第 3 天：迭代器 Iterator & 可迭代对象 Iterable

1、含义讲解

1.可迭代对象（iterable）

凡是能用for循环遍历的对象（列表、字典、字符串、元组、集合、生成器等），内部实现了__iter__方法。

2.迭代器（iterator）:是可迭代对象的取值器，内部实现__item__和__next_,可以用next（）逐个取值

3.关系：可得带对象 - 通过item（）转化未迭代器

lst = [1,2,3]

print(isinstance(lst, iterable)) #True 可迭代

print(isinstance(lst, Iterator)) #False 不是迭代器

#2.iter()把可迭代对象转为迭代器

it = iter(lst)

print(isinstance(it, Iterator)) #True 是迭代器

#3.next()取值

print(next(it))

print(next(it))

Demo2：自定义迭代器（手写迭代器类）

通过类实现__iter__和__next__，打造自己的迭代器。

class MyIterator:

def __init__(self, start, end):

self.start = start

self.end = end

#必需实现:返回迭代器资深

def __iter__(self):

return self

#必须实现 ，每次next执行，返回下一个元素

def __next__(self):

if self.start>self.end:

#遍历完成，抛出停止迭代异常

raise StopIteration

res = self.start

self.start += 1

return res

#使用自适应迭代器

obj = MyIterator(1, 5)

for i in obj:

print(i)

今日小结

可迭代对象；能for遍历 ，迭代器能next（）取值

生成器本事就是一个特殊的迭代器

装饰器 Decorator

h含义

1.装饰器本职 ：闭包+函数参数 是一个包装函数

2.作用：在不修改原函数代码、不改变原函数调用方式的前提下，给函数新增功能（日志、计时、权限校验、缓存等）。

3.语法糖：@装饰器名，简化调用。

1. 基础装饰器（无参数）

Demo1：手写计时装饰器（统计函数执行时间）

import time

#定义装饰器

def timer(func):

#内层函数：包装原有功能

def wrapper():

start = time.time()

#执行原函数

func()

end = time.time()

rpint(f"函数执行耗时：{end - start}秒")

#返回内层函数（不调用）

return wrapper

#使用装饰器 ：@timer 等价于 test = timer(test)

def test():

print("测试函数")

time.sleep(1)

print("原函数执行完毕")

#timer(func)：接收被装饰的函数作为参数

wrapper：增强后的函数，先执行新增逻辑，再执行原函数

@timer：Python 语法糖，一行绑定装饰器

Demo2：被装饰函数带参数

def logger(func):

def wrapper(*args,**kwargs):

print("日志：函数开始执行")

#把参数传给原数据

res = func(*args,**kwargs)

print(f"函数执行完毕：{func.__name__}")

return wrapper

@logger

def add(a,b):

return a+b

print(add(1,2))

print(add(3,4))

说明：*args **kwargs接收任意位置参数、关键字参数，通用写法。

2. 带参数的装饰器

#外层函数：接受装饰器参数

def out(flag):

def decorator(func):

def wrapper():

if flag:

print("开启权限校验")

func()

return wrapper

return decorator

#传参給装饰器

@outer(flag=True)

def hello():

print("hello world")

hello()

hello()

今日小结

核心原则：开闭原则，不改原函数，扩展功能。

三层结构：无参装饰器（外层接收函数→内层包装）；有参装饰器多一层外层接收参数。

常用场景：日志、计时、接口鉴权、缓存。

第 5 天：闭包 & nonlocal 关键字

一、含义讲解

闭包：定义在函数内部的内层函数，引用了外层函数的变量，且外层函数返回内层函数，着中国组合就是闭包

2特点：内层函数会保留外层函数的变量环境，外层函数执行完毕后，变量不会被销毁。

3、nonlcal修改外层函数局部变量

Demo1：基础闭包

python

def out():

num =10 外层局部变量

#内层函数 引用外层变量

def inner():

print(num)

#返回内层函数 （闭包）

return inner

#接受闭包函数

func = out()

func() #输出10，外层函数已执行完，变量任保存

Demo2：nonlocal 修改变量

def outer():

count= 0

def inner():

#声明：count不是本地变量，是外层函数变量

nonlocal count

count += 1

print(count)

return inner

f1 = outer()

f1()

f1()

f1()

Demo3：对比 global（拓展）

num =100

def test():

global num

num += 100

print(num)

test()

区分

global :修改全局变量

nnlocal :修改外层函数 局部变量（仅嵌套函数）

今日小结

闭包三要素：嵌套函数 ，内层引用外层变量，外层返回内层

nonlocal专门处理嵌套函数种外层变量的修改

第 6 天：匿名函数 lambda & 高阶函数（map/filter/sorted）

一、含义讲解

1.lambda 匿名函数：一行简单函数 无函数名，合适临时，简单逻辑，语法：lambda 参数：表达式

2.高阶函数：接受参数作为参数的函数，常用：map、filter、sorted

1. lambda 匿名函数

Demo

def add(a,b):

return a+b

#等价lambda匿名函数

f = lambda a,b : a+b

print(f(1,2))

#无参数lambda

f2 = lambda: "hello"

print(f2())

限制：lambda 只能写一条表达式，不能写魂环，if语句快

2. 高阶函数组合使用

Demo1：map () 映射（对每个元素执行函数）

#列表每个元素乘2

lst = [1,2,3,4]

map(处理逻辑, 要遍历的数据)

#lambda x: x*2：匿名函数

res = map(lambda x: x*2,lst)

print(list(res))

Demo2：filter () 过滤（保留条件为 True 的元素）

#筛选偶数

lst = [1,2,3,4,5]

res = filter(lambda x: x%2==0,lst)

print(list(res))

#sotrted()自定义排序

#按字典value排序

data = [{"name":"a", "age":20}, {"name":"b", "age":15}]

#按key指定排序依据

new = sorted(data,key= lambda x: x["age"])

print(new)

今日小结

lambda：简短逻辑临时函数，一行表达式

map:批量处理元素，filter：过滤元素，sorted自定义排序

第 7 天：上下文管理器 with & 魔术方法enter/exit

1、含义讲解

with上下文管理器：自动资源管理，代码块结束后自动关闭资源（文件、数据库连接、网络请求等），无需手动写close()，就算代码报错也能正常释放资源。

底层依赖两个魔法方法：

_enter_:进入winf代码块时，自动执行

_exit_:离开代码块时自动执行，

1. 内置 with 用法（文件操作，最常用）

Demo

#传统写法：需要手动close，异常可能导致资源不释放

f = open("test.txt","w",encoding="utf-8")

f.write("hello world")

f.close()

#with写法：自动关闭文件

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

f.write("hello world")

print("文件写入完成")

#出了代码快，文件自动关闭

2. 自定义上下文管理器（手写类实现）

class MyResource:

#进入with快执行

def __enter__(self):

print("资源获取成功")

return self #对应as后变量

#离家with快执行（异常也会触发）

def __exit__(self,exc_type,exc_val,exc_tb):

print("关闭资源")

#返回True：压制异常。False：不压制异常

return True

def do_something(self):

print("做些什么"

)

#使用自定义上下文管理

with MyResource() as res:

res.do_something()

# 主动报错，测试异常场景

1 / 0

今日小结

with 核心：自动释放资源，替代手动 close。

自定义管理器靠__enter__和__exit__两个魔术方法。

作场景：文件、MySQL 连接、Redis 连接、网络请求。

什么是高阶函数

满足任意一条接受高阶函数

1.接受另一个函数作为参数

2.讲函数作为返回值返回

Python 里函数是一等公民：可以赋值、传参、返回、存进容器，这是高阶函数能实现的基础。

2. 前置铺垫：函数赋值（必懂）

普通函数可以像变量一样赋值給嵌套名称，调用方式不变

#定义普通函数

def hello(name):

print(f"hello {name}")

#把函数复制給变量f (注意不要加（）,加（）是调用函数)

f = hello

print(f("测试开发"))

解析

hello是函数对象本身；hello()是执行函数并拿返回值

f = hello：两个变量指向同一个函数，后续f()等价hello()

二、第一类高阶函数：函数作参数（工作最常用）

场景说明

把逻辑函数传给工具函数，工具函数统一做遍历、过滤、转换，测开里数据处理、批量请求、筛选测试数据天天用。

示例 1：手写简易高阶函数（理解底层）

自己实现一个接收函数参数的高阶函数，看懂原理。

#1.定义逻辑函数（业务逻辑）

def double(x):

return x*2

#定义高阶函数：接受函数 +列表

def handle_lista(func,lst):

res = []

for i in lst:

res.append(func(i))

return res

#3.使用：把double函数传进去（不穿（））

data = [1,2,3,4]

res = handle_lista(double,data)

print(res)

逐行解析：

1、handle_list(func, lst)：func专门接收函数对象

2、func(item)：执行外部传入的函数，处理每一个元素

3、调用时handle_list(double, data)：只写函数名，代表传函数本身

拓展：换不同逻辑函数，不用改handle_list，符合开闭原则

def square(x):

return x **2

print(handle_list(square, data)) # [1, 4, 9, 16]

python 内置三大经典高阶函数（面试 + 工作核心）

map/filter/sorted，搭配lambda匿名函数使用最多，分模块讲解。

1. map () 映射函数

含义：

map(函数，可迭代对象)

作业：对可迭代对象中每一个元素，一次执行传入的函数

返回值：迭代器（需要转列表 / 元组查看结果）

适用：批量转换、批量计算测试数据

Demo1：基础用法

#普通函数 + map

def add_one(x):

return x + 1

nums = [10,20,30]

#map(函数，列表)

it = map(add_one,nums)

print(list(it))# [11, 21, 31]

Demo2：搭配 lambda（主流写法，一行搞定）

nums = [1, 2, 3] # 每个元素 * 3 res = list(map(lambda x: x * 3, nums)) print(res) # [3, 6, 9]

Demo：多个可迭代对象

a = [1,2]

b = [10,20]

#依次取a\b对应元素相加

res = list(map(lambda x,y: x+y,a,b))

print(res)#[11, 22]

2 filtter（）过滤函数

含义

filter(判断函数，可迭代对象)

作业：更具函数返回的布厄值筛选元素

函数返回True 保留当前元素

函数返回Flase：舍弃当前元素

返回值：迭代器

demo1：基础用法

def is_enen(x):

return x%2 ==0

nums = [1,2,3,4,5,6]

res = list(filter(is_enen,nums))

print(res)

#[2, 4, 6]

Demo2：搭配 lambda（高频）

# 筛选大于 3 的数字

nums = [1, 4, 2, 5, 3]

res = list(filter(lambda x: x > 3, nums))

print(res) # [4, 5]

测开场景：过滤无效测试数据、筛选失败用例、提取指定日志内容。

3.sorted() 排序函数（重点）

含义

sorted(可迭代对象，key=函数，reverse=布耳值)

key 指定排序规则函数（高阶函数核心）

reverse=True降序，False升序（默认升序）

区别：list.sort()原地修改；sorted()返回新列表，不改动原数据

Demo1：基础排序 + 自定义规则

#按元素绝对值排序

nums = [-5,3,-2,4]

res = sorted(nums,key=lambda x: abs(x))

print(res)

#[3, -2, 4, -5]

Demo2：测开最常用场景 —— 字典 / 对象排序

接口返回、测试数据大多是嵌套字典，必掌握。

sort_age_asc = sorted(user_list ,key=lambda x: x["age"])

print("按年龄升序：", sort_age_asc)

#2.按age降序排序

sorted(user_list,key=lambda x: x["age"],reverse=True)

print("按年龄降序：", sorted(user_list,key=lambda x: x["age"],reverse=True))

测开场景：接口响应结果排序、测试报告数据排序、用例按优先级排序。

四、第二类高阶函数：函数作为返回值（闭包 / 装饰器底层）