Python函数的参数

最新推荐文章于 2023-03-10 20:02:50 发布

柠栀.i

最新推荐文章于 2023-03-10 20:02:50 发布

阅读量400

点赞数 5

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/Li1212126/article/details/127029474

版权

Python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

函数的参数

1.函数的创建和调用

什么是函数？
- 函数就是执行特定人和以完成特定功能的一段代码
为什么需要函数？
- 复用代码
- 隐藏实现细节
- 提高可维护性
- 提高可读性便于调试
函数的创建

（图片转载网络）

函数的创建

函数的调用

在这里插入图片描述

def calc(a,b):
    c=a+b
    return c   #结束
result=calc(10,20)    #调用
print(result)

输出：30

2.函数的参数传递

拿这个做例子：

def calc(a,b):   #a,b称为形式参数，简称形参，形参的位置是在函数的定义处
    c=a+b
    return c   
result=calc(10,20)    #10，20成为实际参数的值，简称实参，实参的位置是函数的调用处  
print(result)

位置实参
- 根据形参对应的位置进行实参传递

在这里插入图片描述

（图片转载网络）

关键字实参

根据形参名称进行实参传递

在这里插入图片描述

（图片转载网络）

例如，我们再调用一遍

def calc(a,b):
    c=a+b
    return c  
result=calc(10,20) 
print(result)
        
res=calc(b=10,a=20) #等号左侧变量的称为关键字参数
print(res)

输出：30

虽然输出结果相同，但是他们的传递方式是不同的

函数调用的参数传递内存分析

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)
print(n2)
#函数调用之后
fun(n1,n2) #将位置传参，arg1,arg2是函数定义处的形参，n1,n2是函数调用处的参
#总结，实参名称与形参名称可以不一致
print(n1)
print(n2)

输出：

[22,33,44]

arg1= 11
arg2= [22, 33, 44]
arg1= 100
arg2= [22, 33, 44, 10]
11
[22, 33, 44, 10]

整个函数调用的参数传递内存分析图如下

在这里插入图片描述

（图片转载网络）

在函数调用过程中，进行参数的传递，如果是不可变对象，在函数体的修改不会影响实参的值（arg1的修改为100，不会影响n1的值）；如果是可变对象，在函数体的修改会影响到实参的值（arg2的修改,append(10),会影响到n2的值）

3.函数的返回值

函数返回多个值时，结果为元组

def fun(num):
    odd=[]   #存奇数
    even=[]   #存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
     return odd,even
                
print(fun([10,29,34,55,89,66,88]))

输出：([29, 55, 89], [10, 34, 66, 88])

函数的返回值：

（1）如果函数没有返回值，函数执行完毕后，不需要给调用处提供数据，return可以省略不写

（2）函数的返回值，如果是1个，直接返回原类型

（3）函数的返回值，如果是多个，返回的结果为元组

函数在定义时，是否需要返回值，视情况而定

4.函数的参数定义

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

def fun(a,b=10):  #b称为默认值参数
    print(a,b)
#函数的调用
fun(100)
fun(20，30)

输出：100 10
20 30

个数可变的位置参数
- 定义函数时，可能无法实现确定传递的位置实参的个数时，使用可变的位置参数
- 使用*定义个数可变的位置形参
- 结果为一个元组
```
def fun(*args):  #函数定义时的，可变的位置参数
    print(args)
fun(10)
fun(10,20)
fun(20,505,38)
```
输出：

(10,)
(10, 20)
(20, 505, 38)
个数可变的关键字形参
- 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
- 使用**定义个数可变的关键字形参
- 结果为一个字典
```
def fun(**args):
    print(args)
        
fun(a=10)
fun(a=20,b=30,c=40)
```
输出：{‘a’: 10}
{‘a’: 20, ‘b’: 30, ‘c’: 40}

个数可变的位置参数，只能是一个

个数可变的关键字参数，也只能是一个

在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置实参，要求，个数可变的位置形参，放在个数可变的关键字形参之前

函数的参数总结

在这里插入图片描述

（图片转载网络）

def fun(a,b,c):  #a,b,c在函数
    print('a=',a)
    print('b=',b)
    print('c=',c)
        
#函数的调用
fun(10,20,30)  #函数调用时的参数传递，称为位置参数
lst=[11,22,33]
fun(*lst)   #在函数调用时，将列表中的每个元素都转换为位置实参传入,如果括号内直接为lst，程序会报错
fun(a=100,c=300,b=200) #函数的调用，所以是关键字实参

输出：

a= 10
b= 20
c= 30
a= 11
b= 22
c= 33
a= 100
b= 200
c= 300

如果想进行关键字传参，想将字典中的每个键值对都转为关键字传入，括号内加入两个**即可

例如：

def fun(a,b,c):  
    print('a=',a)
    print('b=',b)
    print('c=',c)
dic={'a':100,'b':200,'c':300}
fun(dic)

输出：

TypeError: fun() missing 2 required positional arguments: ‘b’ and ‘c’

我们加上**就会迎刃而解

def fun(a,b,c):  
    print('a=',a)
    print('b=',b)
    print('c=',c)
dic={'a':100,'b':200,'c':300}
fun(**dic)  #在函数调用时，将字典中的键值对都转换为关键字实参传入

输出：
a= 100
b= 200
c= 300

def fun(a,b=10):  #b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值
    print('a=',a)
    print('b=',b)
    
def fun2(*args):   #个数可变的位置形参
    print(args)
def fun3(**args2):   #个数可变的关键字形参
    print(args2)

fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)

输出：

(10, 20, 30, 40)
{‘a’: 11, ‘b’: 22, ‘c’: 33, ‘d’: 44, ‘e’: 55}

def fun(a,b,c,d):
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
        
#调用fun函数
fun(10,20,30,40)   #位置实参传递
print('@@@')
fun(a=10,b=20,c=30,d=40)  #关键字实参传递
print('@@@')
fun(10,20,c=30,d=99)    #前两个参数，采用的是位置实参传递，而c，d采用的是关键字实参传递

输出：a= 10
b= 20
c= 30
d= 40
@@@
a= 10
b= 20
c= 30
d= 40
@@@
a= 10
b= 20
c= 30
d= 99

如果改为 def fun(a,b,*,c,d):

······

那么在函数调用时，c,d只能采用关键字实参传递

从*之后的参数书，在函数调用时，只能采用关键字参数传递

5.变量的作用域

程序代码能访问该变量的区域
根据变量的有效范围可分为
- 局部变量
  - 在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会成全局变量
```
def fun(a,b):
    c=a+b  #c,就称为局部变量，因为c是在函数体内进行定义的变量，a,b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)
        
#如果在函数体外输出c，程序会报错        
#因为c超出了起作用的范围（超出了作用
```
- 全局变量
  - 函数体外定义的变量，可作用于函数内
```
name='杨老师'
print(name)
def fun():
    print(name)
#调用函数
fun()
```
输出：

杨老师

杨老师

说明name的作用范围为函数内部和外部都可以使用，称为全局变量

如果局部变量使用global声明，这个变量实际上就变成了全局变量

6.递归函数

什么是递归函数
- 如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
递归的组成部分
- 递归调用与递归终止条件
递归的调用过程
- 每递归调用一次函数，都会在栈内存分配一个栈帧
- 每执行完一次函数，都会释放相应的空间
递归的优缺点
- 优点：思路和代码简单
- 缺点：占用内存多，效率低下

使用递归计算阶乘

在这里插入图片描述

（图片转载网络）

def fac(n):    #n为计算阶乘的数
    if n==1:
        return 1
    else:
        res=n*fac(n-1)
        return res
 print(fac(6))

输出：720

7.斐波那契数列

含义：斐波那契数列，又称黄金分割数列，因数学家莱昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……

前两项之和为下一项

def fib(n):   #n表示为第几个位置上的数
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
#斐波那契数列第6位上的数字
print(fib(6))
#输出这个数列的前6位上的数字
for i in range(1,7):
    print(fib(i))

输出：

1
1
2
3
5
8
=n*fac(n-1)
return res
print(fac(6))


输出：720

## 7.斐波那契数列

含义：斐波那契数列，又称黄金分割数列，因数学家莱昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……

前两项之和为下一项

```java
def fib(n):   #n表示为第几个位置上的数
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
#斐波那契数列第6位上的数字
print(fib(6))
#输出这个数列的前6位上的数字
for i in range(1,7):
    print(fib(i))

输出：

1
1
2
3
5
8