今天的 Python 学习主要学习了高阶函数及核心数据处理函数（map、filter、sorted），同时补充了条件表达式、匿名函数的使用，这些知识点是 Python 函数式编程的核心，也是提升代码简洁性和灵活性的关键。

一、高阶函数

        高阶函数是 Python 函数式编程的基础，核心定义：当一个函数的参数是函数，或者返回值是函数时，该函数就是高阶函数。

1.核心特性

        1）.函数是对象

                函数和整型、字符串等一样是可操作的对象，可添加属性、赋值给变量。

def welcome():
    print('欢迎')
# 给函数加属性
welcome.version = 1.0
# 函数赋值给变量
h = welcome
h()  # 输出：欢迎

        2）.参数的可变性

                不可变参数（int、str、tuple 等）：函数内修改不会影响外部变量（地址改变）；
                可变参数（list、dict、set 等）：函数内修改会影响外部变量（地址不变）。

#4.可变参数和不可变参数
#4.1不可变参数  整型 浮点型 元组 字符串 frozenset 布尔
a = 100
def add(num):
    print(f'函数接受的num为{num},地址为{id(num)}')
    num += 1
    print(f'函数接受的num为{num},地址为{id(num)}')
# print(a[2])
print(f'函数调用前a为{a},地址为{id(a)}')
add(a)
print(f'函数调用后a为{a}，地址为{id(a)}')
# print(a[2])
#4.2可变参数   列表 字典 集合
l1 = [10,20,30]
def add1(num1):
    print(f'函数接受的num为{num1},地址为{id(num1)}')
    l1[0] = 50
    print(f'函数接受的num为{num1},地址为{id(num1)}')
print(f'函数调用前a为{l1},地址为{id(l1)}')
add1(l1)
print(f'函数调用后a为{l1}，地址为{id(l1)}')

        3）.函数作为参数 / 返回值：

                作为参数：实现 “行为复用”，传入不同函数实现不同功能；
                作为返回值：函数嵌套，外层函数返回内层函数（闭包基础）。

# 函数作为参数
def say(f):
    f()  # 调用传入的函数
say(welcome)

# 函数作为返回值
def outer():
    def inner(msg):
        print(msg)
    return inner
c = outer()
c('Hello')  # 输出：Hello

        4）.多返回值特性：

                函数可通过逗号分隔返回多个值，接收时可用多个变量承接（本质返回元组）。

def calculate(x,y):
    return x+y, x-y
add_res, sub_res = calculate(10,5)  # add_res=15, sub_res=5

2.高阶函数的优势

        代码复用性高：将通用逻辑抽离，行为通过参数传入；
        灵活性强：同一函数可适配不同业务逻辑；
        是装饰器、闭包的核心基础。

二、匿名函数（lambda）

        匿名函数通过lambda关键字定义，适用于只使用一次、逻辑简单的场景，是高阶函数的常用 “搭档”。

1.核心语法

lambda 参数: 表达式

无函数名，一行完成定义；
冒号右侧只能有一个表达式，表达式结果自动作为返回值；
不支持代码块（如 if-else 多行、循环等），但支持条件表达式。

2.常用场景

         1）简化简单函数：

# 普通函数 vs 匿名函数
def add(a,b): return a+b
lambda a,b: a+b  # 等价效果

        2）配合高阶函数使用（如后续的 map/filter/sorted）

        3）条件表达式结合：实现二选一逻辑（三元表达式）

# 三元表达式：条件成立返回值1，否则返回值2
res = lambda a: '成年' if a >=18 else '未成年'
print(res(22))  # 输出：成年

三、数据处理核心函数

1. map ()：批量处理元素（不改变元素数量）

        map用于对可迭代对象的每个元素执行相同操作，返回迭代器对象（一次性，耗尽后不可复用）。

map(操作函数, 可迭代对象)

延迟执行：仅在获取结果时（如转 list、遍历）才计算；
不改变元素数量：输入 N 个元素，输出 N 个元素；
可结合 lambda 简化操作。

num = [10,20,30]
# 批量翻倍
res = map(lambda x: x*2, num)
print(list(res))  # 输出：[20,40,60]

# 字符串批量转大写
names = ('zhangSan', 'chengdu')
res = map(lambda x: x.upper(), names)
print(list(res))  # 输出：['ZHANGSAN', 'CHENGDU']

2. filter ()：筛选元素（改变元素数量）

        filter用于从可迭代对象中筛选符合条件的元素，返回迭代器对象（一次性）。

filter(过滤函数, 可迭代对象)

延迟执行：仅在获取结果时计算；
改变元素数量：只保留符合条件的元素；
若过滤函数为None，自动过滤布尔值为 False 的元素（如 ''、None、0、[]、{} 等）。

# 筛选数值>30的元素
num = [10,20,30,40,50]
res = filter(lambda x: x>30, num)
print(list(res))  # 输出：[40,50]

# 筛选字典中score>60的元素
name_list = [{'name':'a','score':90}, {'name':'b','score':50}]
res = filter(lambda x: x['score']>60, name_list)
for i in res:
    print(i['name'])  # 输出：a

# 自动过滤布尔值为False的元素
data = ['','f',None,0,1]
res = filter(None, data)
print(list(res))  # 输出：['f', 1]

3. sorted ()：通用排序函数

                sorted用于对可迭代对象排序，返回新的排序后列表（原数据不变）。

sorted(可迭代对象, key=排序依据, reverse=排序方向)

key：接收函数，指定排序的依据（如按长度、按字典的某个键）；
reverse：默认 False（升序），True 为降序。

# 数值排序
num = [10,90,50,80]
print(sorted(num))  # 升序：[10,50,80,90]
print(sorted(num, reverse=True))  # 降序：[90,80,50,10]

# 按字符串长度排序
strs = ['python','java','web']
print(sorted(strs, key=len))  # 输出：['web', 'java', 'python']

# 按字典的key排序
name_list = [{'name':'f','age':'18'}, {'name':'b','age':'52'}]
res = sorted(name_list, key=lambda x: x['name'])  # 按name升序
for i in res:
    print(i['name'])  # 输出：b、f

四、总结

        1.迭代器特性：map/filter 返回的迭代器是 “一次性” 的，转 list / 遍历后会被耗尽，再次使用需重新生成；
        2.延迟执行：map/filter 不会立即计算，仅在获取结果时执行；
函数作用：
        map：批量处理，元素数量不变；
        filter：筛选元素，元素数量减少；
        sorted：排序，返回新列表，原数据不变；
        lambda 适配：匿名函数是 map/filter/sorted 的常用搭档，可大幅简化代码。