【10月更文挑战第12天】
使用方式：
return 数据 返回一个数据
return 数据，数据--返回多个数据，以元组的方式进行返回
作用：将数据返回给到函数调用处
n='afasg'.upper()
print(n)
#AFASG
#那么这个就是这个函数的返回值
def testa():
return '返回一个数据'
print(testa())
#返回一个数据
#这个就是我们的函数返回值
#我们在函数里面设定好我们要返回的值
#那么这个函数在主函数里面的返回值就是我们设定的返回值
除了这个返回我们需要的值
return 还能结束函数
reutrn和print的区别，区别很大的
return 返回值 print输出值
return 只能执行一个函数
print可以执行多个
那么return该怎么使用呢？
函数的作用域详解
局部作用域：变量出了作用域就被销毁
如果没有返回的情况下，变量出函数就会被销毁的
"""
def testb():
num=10
print(f'testb:{num}')
testb()
#testb:10
def testc():
print(f'testc:{num}')
testc()#这个是会报错的，因为我们这个函数里面的num对于这个函数是没有进行定义的
#局部作用域：定义在函数里面的变量
#除了这个作用域的变量就会销毁的
#就像这个testb里面的num是局部变量
#那么到testc里面就已经是被销毁的，
#这个变量是在testb里面进行定义的
#那么只能够作用于testb里面
#但是现在我就是想在test里面使用num该怎么做呢？
#只要testb函数主动出来，那么我们就能在testc里面进行num的使用
在testc里面使用testb里面的num
利用到了return 进行数据的返回：
def testb():
num=10
print(f'testb:{num}')
return num
testb()
def testc():
num=testb()
print(f'testc:{num}')
testc()
#testb:10
#testb:10
#testc:10
'''
我们在先在testb这个函数将num进行返回的操作
然后在testc里面进行调用testb然后得到了num的值
然后我们再重新为num进行复制
那么我们最后就在testc里面将num进行打印了
'''
使用return将值返回到函数调用处
全局作用域：整个py文件都可以进行使用的
局部作用域修改为全局作用域----global 局部变量名
通过这个方法将变量进行声明，那么这个变量在全局都能用
def testb():
global num#对变量进行声明，变量num为全局作用域
num=10
print(f'testb:{num}')
return num
testb()
def testc():
num=testb()
print(f'testc:{num}')
testc()
def testd():
print(f'testd:{num}')
testd()
#testd:10
#那么就说明num这个变量已经成为了个全局变量了
我们在1号函数内进行变量的全局声明，那么我们在后续的函数中都能对这个变量的使用了
全局作用域是定义在函数的外面的，整个py文件都能用
如果我们想要函数内的变量成为全局作用域的话就使用global来声明变量
对于函数来说
如果在函数调用的时候我们使用到某个变量的时候，函数通常会检查自己的空间内是否存在这个变量，如果没有的话那么就会在全局里面对这个变量进行寻找
s=100
print(f's:{s}')
def set():
s=10
print(f'set:{s}')
set()
print(s)
'''
s:100
set:10
100
'''
#对于函数调用的时候，如果使用到某一个变量的时候
#函数会自己进行检查空间内是否存在这个变量
#如果自己有就会用自己的
#自己没有的互就用字节的
但是如果函数里面存在这个变量的话，那么函数是不会去外面找的，就直接用函数里面存在的变量上面的代码就能看的出函数里面的变量和外面的变量不是一个东西
在下面的代码中我们将函数内的变量s删除了
函数没有在自己的空间内找到这个变量，那么函数就去全局进行这个变量的寻找了
s=100
print(f's:{s}')
def set():
print(f'set:{s}')
set()
print(s)
'''
s:100
set:100
100
'''
对于这种事存在顺序的
函数通常是从里面到外面进行变量的寻找的
如果里面没有，那么就去外面找
使用global将s变为全局作用域
s=100
print(f's:{s}')
def set():
global s
s-=10
print(f'set:{s}')
set()
print(s)
'''
s:100
set:90
90
这里的s我们在函数的开头进行了全局作用域的声明了
那么函数在被调用的时候使用的变量就是全局的s
global的补充使用：
name='小明'#全局作用域
def test():
name='小红'
print(f'test:{name}')
test()
print(name)
'''
test:小红
小明
'''
#像这种打印就涉及到空间了
'''
这个小红是个局部变量，当函数结束之后这个变量占用的内存是会被回收的
这就是为什么这个变量只能在函数中进行作用
出函数就被销毁了
函数被调用的时候是会被分配空间的
一但被执行完之后这个空间就会被销毁的
'''
'''
函数如果在被调用的时候会先检查自己的空间内是否存在这个变量
如果不存在的话那么这个函数就去全局进行变量的查找
'''
name='小明'#全局作用域
def test():
global name
name='小红'
print(f'test:{name}')
test()
print(name)
'''
test:小红
小红
'''
#这里我们对name进行了声明了
#那么这个name 就是一个全局变量
#那么我们在函数里面进行该值的话就是对这个name进行一个重新赋值的操作
函数的嵌套（nonlocal的使用）
外部函数嵌套内部函数
我们不能直接进行内部函数的调用
我们这个内部函数是在外部函数中进行定义的
那么定义完成之后我们可以顺便进行内部函数的调用
那么我们在调用外部函数的时候会顺便调用内部函数的
def outer():
print('外部函数')
def inner():
print('内部函数')
outer()
#外部函数
#这里仅仅只会执行外部函数的内容，并不会执行内部函数
#如果我们想调用这个内部函数我们该怎么操作呢？
#inner
#如果我们直接调用内部函数的名字是会报错的，说我们没有定义这个内部函数
'''
内部函数的空间在外部函数的里面
'''
#我们在外部函数中定义了一个内部函数，那么我们是否能直接在外部函数中直接写内部函数的调用
#那么我们调用外部函数的时候会连同内部函数一起进行调用呢？
def outer():
print('外部函数')
def inner():
print('内部函数')
inner()#对内部函数的调用
outer()
'''
外部函数
内部函数
'''
#理论存在，实践成立
#内部函数只能在外部函数中进行调用，我们是不能在外面进行内部函数的调用的
除了上面的方法调用内部函数，我们还有一种方法进行内部函数的调用
我们就是要在函数外面调用内部函数
我们通过外部函数将内部函数进行返回
返回到函数调用处
然后通过进行变量进行接收这个返回值，然后我们就能通过这个变量进行这个内部函数的调用了
def outer():
print('外部函数')
def inner():
print('内部函数')
return inner#返回内部函数名，返回内部函数的位置
#我们在外部函数将内部函数进行返回，那么我们在外面进行外部函数的调用的时候
#可以获取到内部函数的位置
#那么我们直接定义一个变量进行返回值的接受
i=outer()
i()
'''
外部函数
内部函数
'''
#外部函数主动将内部函数的位置暴露出来了
#我们通过这个返回值就能对内部函数进行带调用了
#那么这里的i里面存储的就是内部函数的信息
#相当与i等价于inner
#那么我们能通过这个n进行内部函数的调用
#如果不创建变量我们进行内部函数的调用的话，我们可以通过使用返回值和两个括号进行操作
outer()()
#这个就是内部函数的调用了
不用变量的话我们直接在返回值后面加上括号
outer()()
对于嵌套函数中的变量进行讨论
def testa():
a=10
def testb():
a=100
print(f"内部函数：{a}")
testb()
print(f"外部函数：{a}")
testa()
'''
内部函数：100
外部函数：10
'''
'''
我们调用这个函数时，我们先创建变量a并且赋值
然后进行函数testb的创建
我们是没有进行函数testb的调用的
我们在定义完成之后我们就进行了这个函数的调用
'''
#对于这个函数里面的两个a
#我们创建的两个函数有自己对应的空间
#外部函数内部包含内部函数
#并且函数内部和外部函数的变量a是不会互相打扰的
#空间不是一个地方的
#所以这个a的值是不同的，本质上是不同的
#如果想要两个a是一个a,那么就是内部函数引用外部函数中的a
内部函数和外部函数里面的变量是互不干扰的（在没有作用域的声明下）
如果想让内部函数引用的是外部函数的变量的话
我们应该怎么做呢？
我们可以使用nonlocal将内部函数的变量的是引用外部函数的
nonlocal的使用：
def testa():
a=10
def testb():
nonlocal a#声明我们内部函数用的a引用的是外部函数的a
a=100
print(f"内部函数：{a}")
testb()
print(f"外部函数：{a}")
#想在内部函数中的变量声明为外部函数的变量值---nonlocal
testa
#既然我们在内部函数内已经声明了这个内部函数引用的a是外部函数的a
#那么我们在内部函数中对a进行更改的话，那么外部函数的a也会受到影响的
注意
nonlocal只能用来声明内部函数的变量来自外部函数
nonlocal只能用在嵌套函数中
在Python语言中，可以使用lambda来创建匿名函数。所谓匿名，是指不用def语句的形式来定义一个函数。
lambda 参数：语句（返回值）
#匿名函数简单的使用
#lambda 参数：语句
#语句会被作为返回值的
#语句：执行语句内容，并将结果进行返回到调用处
#简单的加法操作
add=lambda x,y:x+y
print(add(1,4))
#5
#我们将这个匿名函数的返回值用add进行接收
#但是这个返回值就是后面语句的方法的地址
#我们需要对这个接收返回值参数的变量进行传参的操作
#判断是否为偶数
even=lambda n:n%2==0#如果是偶数的话就会返回True
print(even(12))
#匿名函数的格式
#lambda 变量 ： 判断表达式
lambda 参数：语句
我们用变量接收这个返回值
然后对这个返回值传参就能调用这个匿名函数了
对于这个匿名函数来说我们还有一种使用方法：
匿名函数常用于函数作为参数的场景
li=['abcdef','123','abcd','12']
#按照元素的长度进行排序
li1=sorted(li,key=lambda w:len(w))
#['12', '123', 'abcd', 'abcdef']
print(li1)
'''
key 参数：告诉sorted()在排序的时候使用哪个函数或属性来确定每个元素的排序顺序
对于这个sorted来说的话，我们的参数可以是降序或者是升序
同样也可以是长度
我们根据这个份key进行排序
我们的排序方法默认是升序
我们的这个临时排序sorted是依照li这个参数
从li这个列表中进行排序
然后根据key进行排序
'''
'''
w接收一个元素为参数，返回元素的长度
每次从列表中选择一个元素然后在这个匿名函数中进行计算，返回这个长度作为临时排序的参数
'''
我们利用这个临时排序对列表中的元素以元素的长度进行排序
那么我们如何获取元素的长度呢
我们的临时【排序的第一个参数是列表的名字，
第二个参数是这个匿名函数
我们用这个key来接受这个匿名函数的返回值
我们这个匿名函数的作用就是返回这个元素的长度的
在Python中，sorted 函数可以接受一个 key 参数，该参数是一个函数，用于在排序过程中为每个元素提供一个用于比较的值。在你提供的代码中，使用了 lambda 函数作为 key 参数的值。
lambda 函数是一个小型匿名函数，它可以接受任意数量的参数，但只能有一个表达式。在你的例子中，lambda w: len(w) 定义了一个接受一个参数 w 的匿名函数，并返回 w 的长度。
这里的 w 代表列表 li 中的每个元素。当 sorted 函数对列表进行排序时，它会调用这个 lambda 函数为每个元素计算一个值（在这个例子中是元素的长度），然后根据这些值来对元素进行排序。
具体来说，len(w) 是内置的 len 函数，它返回对象 w 的长度。对于字符串来说，len 函数返回字符串中的字符数。
所以，当你执行以下代码：
li=['abcdef','123','abcd','12']
li1=sorted(li,key=lambda w:len(w))
print(li1)
sorted 函数会对列表 li 中的每个元素调用 lambda w: len(w)，得到每个元素的长度，然后根据这些长度对元素进行排序。最终，你会得到一个按照元素长度排序的新列表 li1，即 ['12', '123', 'abcd', 'abcdef']。
闭包：在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。
1.嵌套函数：在一个外函数中定义了一个内函数
2.内函数里运用了外函数的局部变量
3.外函数返回内函数名。
作用：
1.可以在外部函数修改函数内部的变量值，是函数内部与外界沟通的桥梁
2.将局部变量持久的保存在内存中
def counter():
count=0
def in_count():
nonlocal count
#每调用一次内部函数进行+1，实现计数
count+=1
print(f'第{count}次')
return in_count
c=counter()
c()
'''
我们调用的是内部函数，我们每次调用完内部函数之后这个内部函数的空间就会被回收
但是我们在交互模式一直进行内部函数的调用
然后回发现这个count并没有进行清零的操作
而是在上次的基础上进行+1的操作
这是为什么呢？
因为我们调用的是内部函数，而内部函数中计数使用的是外部函数的变量
我们通过内部函数的调用使外部函数内的变量产生永久性的改变
count就没有被回收掉
'''
闭包的三个条件
1.嵌套函数
2.内部函数使用的变量是外部函数的变量（nonlocal定义）
3.外部函数的返回值是内部函数的函数名
通过外包我们的这个变量是不会因为内部函数的销毁被清零
而是可以一直进行+1的操作
def outer_function(x):
def inner_function(y):
return x + y
return inner_function
# 创建一个闭包
closure = outer_function(2)
# 使用闭包
result = closure(3) # 输出 5
print(result)
在这个例子中，inner_function 是一个闭包，它记住了外部函数 outer_function 的变量 x。即使 outer_function 已经执行完毕，我们仍然可以通过调用 closure 来使用 x 的值。
