作用：再调用函数时，默认参数没有传递值，就会使用我们设定好的默认值

'''

#默认参数

'''

def 函数名(形参=默认值，......):

函数体

'''

def func(name,sex='男'):code>

print(f'我是{name}，性别：{sex}')

func("小黑")

#我是小黑，性别：男

#我们在这个函数的调用的时候我们只传了name"小黑"

#并没有传性别，因为我们性别在这个函数体中已经是默认的了

func("小美",'女')

我是小美，性别：女

对于默认参数的话，我们一开始在函数体里面已经设定好了他的值

后面我们调用这个函数的时候我们是不需要传这个默认参数的大小的

因为这个参数已经有值了，我们就不需要进行传递了

但是我们如果传了默认参数的值的话，我们就采用的是我们传的值

就像上面

小美是女生，我们的默认性别是男生，那么我们将性别女传上去，那么打印出来的就是“我是小美，性别：女”

对于函数中存在默认参数的看法

不传这个参数就是使用默认参数

但是如果传了参数的话，就是使用我们传的参数

对于函数参数的位置的话，我们需要先定义这个位置参数，然后定义默认参数

因为如果先定义默认参数的话，那么我们不传参的情况下位置参数就没有进行定义，就是会报错的

反正就是默认参数放在后面

不定长参数

<code>#元组不定长---*args

def funa(*args):

print(args)#传入的数据全部存放在args中

funa()

#()

#我们不传参的话那么就是打印一个括号

#我们这里args前面加上*，就像是之前的变量前面加上*就能接受所有剩余的数据

#就像拆包一样

funa(1)

#(1,)

#我们传参1

#我们这里打印出来的就是一个元组类型的数据

#我们这个就是将传入的实参全部接受，以元组的方式进行保存

#不管传多少都是不会进行报错的

#这个不定长的参数就是保障了我们不知道参数个数的情况下降参数进行保存下来

那么数据是存储在元组里面

字典不定长---**kwargs

#字典不定长---**kwargs

#我们传入的数据以字典的方式进行存放

#字典{}

def funb(**kwargs):

print(kwargs)

funb()

#以关键字传参---形参（键）==实参（值）

funb(name="小敏",age=18)code>

#{'name': '小敏', 'age': 18}

#格式就是函数名字(键1=值1，键2=值2)

格式就是函数名字(键1=值1，键2=值2)

参数顺序

<code>#定义一个元组

t=(1,2,3)

def func(a,b,c):

print(a,b,c,sep='\t')code>

#我们现在想让这个元组内的数据以实参的形式传到函数里面，那么该怎么操作呢？

#我们是可以使用拆包这个知识点

#拆包是存在两种形式的

#第一种：以变量的形式进行接收数据

'''

我们用变量的形式将这个元组内的数据依次进行接收

然后将这些变量以实参的形式传到这个函数里面

'''

x,y,z=t

func(x,y,z)

#1 2 3

#第二种：用*号进行接收

'''

在元组的名字前面加上*用于这个拆包，以实参的形式传到函数里面进行后续的操作

'''

func(*t)

#1 2 3

print(t)

#(1, 2, 3)

print(*t)

#1 2 3

#我们对元组进行拆包的操作之后我们就得到元组内的每个数据了

3.return 

<code>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来声明变量

对于函数来说

如果在函数调用的时候我们使用到某个变量的时候，函数通常会检查自己的空间内是否存在这个变量，如果没有的话那么就会在全局里面对这个变量进行寻找

<code>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='小明'#全局作用域code>

def test():

name='小红'code>

print(f'test:{name}')

test()

print(name)

'''

test:小红

小明

'''

#像这种打印就涉及到空间了

'''

这个小红是个局部变量，当函数结束之后这个变量占用的内存是会被回收的

这就是为什么这个变量只能在函数中进行作用

出函数就被销毁了

函数被调用的时候是会被分配空间的

一但被执行完之后这个空间就会被销毁的

'''

'''

函数如果在被调用的时候会先检查自己的空间内是否存在这个变量

如果不存在的话那么这个函数就去全局进行变量的查找

'''

name='小明'#全局作用域code>

def test():

global name

name='小红'code>

print(f'test:{name}')

test()

print(name)

'''

test:小红

小红

'''

#这里我们对name进行了声明了

#那么这个name 就是一个全局变量

#那么我们在函数里面进行该值的话就是对这个name进行一个重新赋值的操作

函数的嵌套（nonlocal的使用）

<code>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']。

6.闭包

闭包：在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。

1.嵌套函数：在一个外函数中定义了一个内函数

2.内函数里运用了外函数的局部变量

3.外函数返回内函数名。

作用：

1.可以在外部函数修改函数内部的变量值，是函数内部与外界沟通的桥梁

2.将局部变量持久的保存在内存中

<code>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 的值。