🌈个人主页：羽晨同学
💫个人格言:"成为自己未来的主人~"
关键字参数和不定长参数
关键字参数主要体现在函数的调用上
使用关键字参数的好处是，可以不按照形参的参数传参
比如说，我们定义一个函数
python
def c1(name,age):
print(f'姓名： {name}, 年龄：{age}')
c1("zhangsan",10)
c1(age=10,name="张三")这个就是普通函数的定义，我们调用这个函数的时候，需要传入两个参数（因为形参数目是两个）。
我们接下来再来看下一个函数的定义。
python
def c1(name,age=0,address="北京"):
print(f'姓名：{name},年龄：{age}.地址：{address}')
c1("张三",10)在这个函数的定义当中，我们在形参中，对age和address进行了赋值，这样做的好处是，即使我们传入的参数小于三个，这个函数仍然可以成立。
并且，我们还可以使用关键字进行传参。
python
c1(name="张三",age="5")
c1(age=5,name="张三")
c1("李四",address='上海')你看，这样是不是提高了代码的可读性。
系统函数中的关键字参数
初次之外，其中我们平常使用的系统函数中，都是有关键字参数的。
比如说：print
python
print(45,6,77,end='-------',sep='*')那个end和sep就是系统函数中的关键字参数。
* 和**
这两个的区别主要在于
* 被当做元组处理
** 被当做字典处理
比如说，我们看下面的这两个代码。
python
def d1(*num):
print(num)
print(type(num))
d1()
d1(45)
python
def d2(**num):
print(num)
print(type(num))
d2()
这个时候传参的时候，就必须写成变量等于什么的形式，例如：
python
d2(x=2,y=4,z=5) # 类似于字典的创建方式3这种是类似于字典的创建方式。
在同一个函数当中，同种符号只能出现一次，但是*和**可以同时出现。
python
def d3(*num1,**num2):
print(num1,num2)
d3(45,5,6,7,8,9,5)
d3(a=5)
d3(4,7,8,6,5,ac=5)这个代码执行下来的结果如下图所示：
函数的本质，其实就是一个变量，函数名其实就是一个变量名。
python
name = "zhangsan" # 变量
def func1(): # 函数
print("111111111")
print(type(name)) #<class 'str'>
print(type(func1)) #<class 'function'>
func1()你看，是不是其实蛮相似的。
如果这个时候我们重新给func1进行复制，这样子可以吗？
python
func1=10答案当然是可以的，但是这个时候func1的类型就发生了改变。
python
print(type(func1)) # <class 'int'>我们前面说函数和变量是很类似的，与给函数赋值和给变量赋值，结果也是极其相似的，我们来看一下给变量的赋值。
python
name=[243,6,78,8]
python
print(type(name)) # <class 'list'>我们可以看到的是，他的类型变成了列表。
而func1() 这个时候是不能进行调用的，是运行不起来的，因为这个时候它的类型发生了改变。
原来表示函数的含义消失了。
所以这个时候也给我们提了一个醒，那就是自定义标识符的时候，不要使用系统的函数名，否则会导致系统的函数失效。
python
print=32
print(print)
python
sum=327
print(sum(3,527))这两个系统的函数都失去了原来的作用。并变成了自己赋给的int类型。
A函数可以作为B函数的参数或者返回值使用，只需要传递或返回函数名就可以了。
使用场景：闭包、高阶函数、装饰器等
大家可以先来看下面的这个场景。
python
def func1():
num1=78
def func2():
num2=13
total = num1+num2
print(total)
func2()这个代码是会报错的，因为func1中的变量在func2中是无法直接使用的，因为两个的作用域并不相同。
那么应该怎么解决这个办法呢？
方法一：返回值
python
def func1():
num1=78
return num1
def func2():
num2=13
total = func1()+num2
print('和: ',total)方法二：函数的嵌套定义
python
def func1():
print('11111111---------start')
num1=78
def func2():
print('2222222--------start')
num2=13
total = num1+num2
print('和: ',total)
print('222222----------end')
print('11111111---------end')
func1()这个其实我们需要着重讲一下。
首先，在上面的这个嵌套定义的代码中，执行结果是这样的。
python
print(num1) #num1只能在func1内部使用当我们执行这个代码的时候，是会报错的，这是因为num1只能在func1内部使用
python
func2() #这里不能调用，这个func2只能在func1内部使用这个代码执行也会报错，**也是因为func2只能在func1的内部调用。**那我们应该如何调用嵌套定义的函数呢？
方法一、直接在func1中调用
python
def func1():
print('11111111---------start')
num1=78
def func2():
print('2222222--------start')
num2=13
total = num1+num2
print('和: ',total)
print('222222----------end')
#调用内部函数func2()
func2()
print('11111111---------end')
#调用外部函数func1()
func1()
python
def func1():
print('11111111---------start')
num1=78
def func2():
print('2222222--------start')
num2=13
total = num1+num2
print('和: ',total)
print('222222----------end')
#调用内部函数func2()
print('11111111---------end')
func2()
#调用外部函数func1()
func1()
方法二、将func2设置为func1的返回值，这种方式以后是常用的，主要应用在闭包或者装饰器当中。
python
def func1():
print('11111111---------start')
num1=78
def func2():
print('2222222--------start')
num2=13
total = num1+num2
print('和: ',total)
print('222222----------end')
#调用内部函数func2()
print('11111111---------end')
# A函数作为B函数的返回值使用，只需要使用函数名可以
return func2 # func2表示函数本身，func2()表示调用函数
f = func1() # f中存储的是func1的返回值
# print(f) # f中存储的是func2函数
f() # 相当于调用fcun2()函数闭包的使用
闭包的前提是函数的嵌套定义，在内部函数当中使用了外部函数的变量。
情况一
返回值
python
def func1():
num1=78
def func2():
num2=13
total = num1+num2
print('和: ',total)
return func2
f=func1()
f()情况二
python
def func1(a,b,c):
num1=78
def func2():
num2=13
total = num1+num2
print('和: ',total,a,b,c)
return func2
f=func1(45,7,8)
f()情况三
python
def func1(a,b,c):
num1=78
def func2(x,y):
num2=13
total = num1+num2
print('和: ',total,a,b,c,x,y)
return 'hello'
return func2
f = func1(45,7,8)
x = f(4,7)
print(x)f表示的是func2
无论是函数的嵌套定义还是闭包，本质还是一个函数，所以默认参数，关键字参数和不定长参数都可以正常使用
返回值也可以正常使用
所在在调用内外函数的时候，一定要注意参数的传参的问题
