# day1

- Link: https://xingheye.icu/day1/
- Published: 2026-10-29T10:13:45+08:00
- Author: 星和夜

# 函数的进阶

# 函数后面加括号代表该函数正在被调用，不加括号代表此时是函数本身，即函数不仅能执行，
还能像整数、字符串一样被传递、保存和返回。

#1.下面的代码能否正常运行？为什么？

def greet():

    return ‘Hello’

functions = [greet, len, str]

print(functions[0]())

print(functions[1](‘Python’))

#可以，因为函数可以储存在列表中

#编写 make_power(n)，返回一个函数，使其能够计算任意数字的 n 次方。例如 square = 
make_power(2)，square(5) 返回 25。

def make_power(n):

    return lambda x:x**n

square = make_power(2)

print(square(5))

#另解

def make_power(n):

    def power(x):

        return x**n

    return power   # 返回的power就是x**n

# 编写 repeat(func, n)，返回一个新函数。调用新函数时，将 func 连续作用于输入值 n
次。例如 repeat(lambda x: x*2, 3)(2) 返回 16。

def repeat(func,n):

    def new(x):

        for i in range(n):

            n=func(x)

        return x

    return new

# 编写函数的基本顺序，以这道题为例：

#先把函数名和返回值写出来，再想怎么样使这个函数返回该返回值，掌握函数嵌套的能力

# 使用 lambda 和 sorted()，将以下列表按照每个元组的第二个元素从小到大排序。data 
= [(‘A’, 85), (‘B’, 60), (‘C’, 92)]

   sorted(data,key = lambda items : items[1], reverse=True)

# data代表sorted排序的对象，key 代表按这种方法排，reverse=True代表反向

# 同理

key=lambda x: x[0]

# 按第一个元素比较

key=lambda x: x[1]

# 按第二个元素比较

key=len

# 按长度比较

# 不定义普通函数，只使用 lambda，编写一个表达式：输入整数 x，偶数返回 ‘even’，奇数
返回 ‘odd’。

lambda x: ‘even’ if x % 2 == 0 else ‘odd’

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

a = list(map(lambda x: x * 2, nums))

b = list(filter(lambda x: x % 2, nums))

print(a)        # [2,4,6,8,10]

print(b)        # [1,3,5]

# map按照key 规则来分别处理nums

# filter按照key 规则来过滤nums

reduce(function, iterable, initializer)     #把一组数据按照指定规则两两合并，最终
得到一个结果，使用前要导包，第三个参数为初始值

import functools   #可行，但是调用的时候要functools.reduce()

from functools import reduce    # 可行，以后调用直接reduce()

# nonlocal count 的作用是声明：修改的是外层函数 counter() 中的 count，而不是创建
一个新的局部变量。

# global 声明全局变量

# 内层函数可以直接读取外部变量，但是要想修改必须通过nonlocal关键字

def outer():

    x=10

    def inner():

        print(x)

    return inner

f=outer()       # 由于inner是局部函数外部不能直接访问，必须通过这种方法返回出来

f()     #输出10

def outer():

    x=10

    def inner():

        nonlocal x

        x+=10

        print(x)

    return inner

f=outer()

f() # 输出20

def outer():

    x=10

    def inner():

        x+=10

        print(x=10)

    return inner

f=outer()

f()     # 报错

# def 用于定义函数，函数名后面加 () 才是调用函数。

# Python 允许把函数赋值给变量、作为参数传递，也可以作为返回值。

# 内层函数可以读取外层函数作用域中的变量。

# 闭包就是函数与它所保留的外部变量绑定所形成的机制。

# nonlocal 用于在内层函数中重新绑定外层函数作用域中的变量。

# 闭包经常用于保存状态、创建带配置的函数，以及实现装饰器。

# 变量延迟查找（晚绑定问题）

funcs = []

for i in range(3):

    funcs[i – 1] = lambda x : x*i    # 等效于 funcs.append(lambda x : x*i)

print(funcs[0](10))     # 20

print(funcs[1](10))     # 20

print(funcs[2](10))     # 20

# 因为函数在被调用的时候才将 i 传入，此时由于循环已经结束 i 的值为2，为了解决这个
问题，需要将匿名函数改为lambda x, i=i: x*i

# 为什么需要闭包————函数可以携带并维护自己的私有状态

# def create_counter():

#     counter = 0

#     def run():

#         nonlocal counter

#         counter += 1

#         return counter

#     return run

# a=create_counter()

# a() # 1

# b=create_counter

# b() # 1

# a() # 2