python入门到精通第十章

函数的创建和参数传递

函数就是完成特定功能的一段代码，可以调用函数复用代码，提高可维护性，使用 def 定义。

python
def calc(a,b): # a,b成为形式参数（形参），参数的位置是在函数的定义处
    c=a+b
    return c
result=calc(10,20) # 位置传参，按照顺序传参，10,20成为实际参数的值（实参），参数的位置是函数的调用处
print(result)

res=calc(b=10,a=20) # =左侧变量的名称称为关键字参数，根据形参的名称进行传参
print(res)

函数调用过程中，如果传递参数是不可变对象，在函数体的修改不会影响实参的值，如果是可变对象，在函数体的修改会影响实际参数的值。

python
def fun(arg1,arg2):
    print('arg1=',arg1)
    print('arg2=',arg2)
    arg1=100
    arg2.append(10)
    print('arg1=',arg1)
    print('arg2=',arg2)

n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2) # 位置传参，形参名称和实参名称可以不一致
print('n1',n1) # 如果是不可变对象，在函数体的修改不会影响实参的值
print('n2',n2) # 函数体执行完后append(10)，会影响到n2的值

函数的返回值

函数执行完毕后，不需要给调用处提供数据，return可以省略不写，如果返回值是1个，直接返回原类型，如果是多个返回值，返回的结果为元组。

python
def fun(num):
    odd=[] # 存奇数
    even=[] # 存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
lst=[10,32,35,66,93,55,97,98]
print(fun(lst))

def fun1(): # 第一种定义函数方式，不需要返回数据
    print('hello')
fun1()

def fun2(): # 第二种定义方式，返回一个值，返回的类型是原类型
    return 'hello'
fun2()
print(fun2())

def fun3(): # 第三种定义方式，返回多个值，返回的是元组
    return 'hello','python'
print(fun3())

函数的参数定义

函数定义时，给形参设置默认值，只有与默认值不符的时候，才需要传递实参

python
def fun(a,b=10): # 定义函数，10是b参数的默认值
    print(a,b)
fun(100) # 只传一个参数赋值给a，b参数使用默认值
fun(20,30) # 传递2个参数，30会替换掉10的默认值

print('hello',end='\t') # print默认值是end='\n'，把end改为\t，替换掉默认值就不会换行了
print('world')

函数定义时，无法事先确定传递参数位置实参的个数，使用可变的位置参数，使用 * 定义个数可变的位置形参，结果为一个元组
```
python
def fun(*args): # 可变的位置参数，可以传递多个参数
    print(args)
fun(10)
fun(20,30)
```
定义函数时，无法事先确定传递的关键字实参的个数时，使用可变关键字形参，使用 **** ** 定义个数可变的关键字形参，结果为一个字典。
```
python
def fun1(**args): # 可变的关键字参数，返回的是字典
    print(args)
fun1(a=10)
fun1(a=20,b=30,c=40)
```
个数可变的位置参数和个数可变的关键字参数都只能是填写一个，如果定义函数既有个数可变的关键字形参，也有个数可变的位置形参，要求个数可变的位置形参放在个数可变的关键字形参之前。
```
python
def fun2(*args1,**args2):
    print(args1,args2)
fun2(10,30,a=25,b=23)
```

函数的定义与调用

参数的类型	函数的定义	函数的调用	备注
位置实参		✔
将列表中的每个元素都转为位置实参		✔	使用*
关键字实参		✔
将字典中的每个键值对都转换为关键字实参		✔	使用**
默认值形参	✔
关键字形参	✔		使用*
个数可变的位置形参	✔		使用*
个数可变的关键字形参	✔		使用**

函数调用时的参数传递：

python
def fun(a,b,c): # 定义一个形式参数
    print('a',a)
    print('b',b)
    print('c',c)
fun(10,20,30)
lst=[11,22,33]
fun(*lst) # 在函数调用时，将列表中的每个元素都转换为位置实参传入，列表名前需要加*

dic={'a':100,'b':200,'c':300}
fun(**dic) # 将字典中的键值对都转换成关键字实参传入，字典名前需要加**

函数定义的形参：

pyt
def fun(a,b=10):
    print('a=',a)
    print('b=',b)

def fun2(*args): # 个数可变的位置形参
    print(args)
def fun3(**args): # 个数可变的关键字形参
    print(args)
fun2(10,20,30,40) # 结果是元组
fun3(a=11,b=22,c=33,d=44) # 结果返回字典

def fun4(a,b,*,c,d): # 从*之后的参数，在函数调用时，只能采用关键字参数传参
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
fun4(10,20,c=30,d=40) # 前两个参数是采用位置实参传递，而c,d采用关键字实参传递

# 以下方式都可以定义函数
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args2):
    pass
def fun7(a,b=10,*args,**args2):
    pass

变量的作用域

程序代码能访问该变量的区域，可分为 局部变量 和 全局变量 ，在函数内定义并使用的变量，只能在函数内部有效，局部变量使用global声明，这个变量就会成为全局变量，在函数体外定义的变量，可作用域函数内外，就是全局变量

python
def fun(a,b):
    c=a+b # c就是局部变量，因为c在函数体内定义的变量，a,b是形参，也是局部变量，属于函数体内部变量
    print(c)

name='leo' # 这个name变量，函数内部和外部都可以使用，所以这个是全局变量
print(name)
def fun2():
    print(name)
fun2()

def fun3():
    global age # age是函数内部变量，局部变量，局部变量使用global声明后，这个便俩个就会变成全局变量
    age=23
    print(age)
fun3()
print(age) # 在函数体内的age变量使用global声明后，可以在函数外部使用了

递归函数

如果在一个函数的函数体内调用了该函数本身，这个函数就成为 递归函数 ，递归调用需要有一个终止条件，每递归调用一次函数，都会在栈内存分配一个栈帧，每执行完一次函数，都会释放相应的空间。