Python中的函数操作详解

目录

1.函数的创建和调用

2.函数的参数传递

3.函数的返回值

4.函数的参数定义

4.1  函数的参数总结：

4.2  函数定义时的形参的顺序问题： 

5.变量的作用域

6.递归函数

6.1  实例：阶乘

6.2  实例：斐波那契数列

def calc(a,b):#a,b称为形式参数，
    c=a+b
    return c

print(calc(4,5))#9
#4,5称为实际参数

2.函数的参数传递

函数调用的参数传递：

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

关键字实参：根据形参名字进行实参传递

def calc(a,b):#a,b称为形式参数，
    c=a+b
    return c

res1=calc(10,20)#传参a=10,b=20

res2=calc(b=10,a=20)#传参a=20,b=10

---

3.函数的返回值

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

def fun1():
    print('hello')
fun1()#hello

def fun2():
    return 'world'
res=fun2()
print(res)#world

def fun3():
    return 'hello','world'
res=fun3()
print(res)#('hello', 'world')

练习： 

def fun(arg1,arg2):
    print(arg1)#11
    print(arg2)#[22, 33, 44]
    arg1=100
    arg2.append(10)
    print('arg1',arg1)#arg1 100
    print('arg2', arg2)#arg2 [22, 33, 44, 10]

n1=11
n2=[22,33,44]
fun(n1,n2)

print(n1)#11
print(n2)#[22, 33, 44, 10] 
#将列表传入函数，可在函数中对列表进行增，删，改
#如：
def fun(num):
    odd=[]
    even=[]
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
#函数调用
lst=[10,7,24,25,81,54]
print(fun(lst))#([7, 25, 81], [10, 24, 54])

---

4.函数的参数定义

4.1  函数的参数总结：

序号	参数的类型	函数的定义	函数的调用	备注
1	位置实参		√
	将序列中的每个元素都转换为位置实参		√	使用*
2	关键字实参		√
	将序列中的每个元素都转换为关键字实参		√	使用**
3	默认值形参	√
4	关键字形参	√		使用*
5	个数可变的位置形参	√		使用*
6	个数可变的关键字形参	√		使用**

  序号1：

def fun(a,b,c):#a,b,c在函数的定义处，所以是形式参数
    print(a)
    print(b)
    print(c)

#函数的调用
fun(10,20,30)#位置实参
lst=[11,22,33]
fun(*lst)#将序列中的每个元素都转换为位置实参

序号2：

def fun(a,b,c):#a,b,c在函数的定义处，所以是形式参数
    print(a)
    print(b)
    print(c)

#函数的调用
fun(a=100,b=200,c=300)#关键字实参
dic={'a':111,'b':222,'c':333}
fun(**dic)#将序列中的每个元素都转换为关键字实参

序号3：

def fun(a,b=10):#b在函数的定义处，b是形参，而且进行了赋值，所以b称为默认值形参
    print('a',a)
    print('b',b)

序号4：

def fun(a,b,c,d):#b在函数的定义处，b是形参，而且进行了赋值，所以b称为默认值形参
    print('a',a)
    print('b',b)
    print('c',c)
    print('d',d)
fun(10,20,30,40)  #位置实参传递
fun(a=10,b=20,c=30,d=40)  #关键字实参传递

def fun1(a,b,*,c,d):#b在函数的定义处，b是形参，而且进行了赋值，所以b称为默认值形参
    print('a',a)
    print('b',b)
    print('c',c)
    print('d',d)
#fun1(10,20,30,40)  #报错：c和d只能采用关键字实参传递
fun1(10,20,c=30,d=40)  #关键字实参传递

序号5：

def fun2(*args):#个数可变的位置形参
    print(args)

序号6：

def fun3(**args2):#个数可变的关键字形参
    print(args2)

 

注：函数定义默认值参数：

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

def fun(a,b=10):
    c=a+b
    return c

print(fun(10))#20
print(fun(10,20))#30

注：个数可变的位置参数：

• 定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
• 使用*定义个数可变的位置形参

注：个数可变的关键词形参：

• 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
• 使用**定义个数可变的关键字形参
• 结果为一个字典

代码演示： 

def fun(*args):
    print(args)
    #print(args[0])

fun(10)#(10,)
fun(10,20,30)#(10, 20, 30)
fun(20,304,45,50)#(20, 304, 45, 50)
print('hello','world','Python')
#print函数中就有一个位置可变参数

def fun1(**args):
    print(args)

fun1(a=10)
fun1(a=10,b=40,c=36)

 注：

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

4.2  函数定义时的形参的顺序问题： 

def fun(a,b,*,c,d,**args):
    pass

def fun1(*args,**args2):
    pass

def fun2(a,b=10,*args,**args2):
    pass

---

5.变量的作用域

def fun():
    age=20
    print(age)

fun()
#print(age)#NameError

def fun1():
    global age1 
    #函数内部定义的变量，局部变量使用global声明，这个变量实际就变成了全局变量
    age = 20
    print(age)

fun1()
print(age1)

---

6.递归函数

什么是函数递归：

• 如果在一个函数的函数体内调用了改函数本身，这个函数就称为递归函数

递归的组成部分：

• 递归调用与递归终止条件

递归的调用过程：

• 每递归调用一次函数，都会在栈内存分配一个栈帧
• 每次执行完一次函数，都会释放相应的空间

递归的优缺点：

• 缺点：占用内存多，效率低下
• 优点：思路和代码简单

6.1  实例：阶乘

def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)

print(fac(3))#6

6.2  实例：斐波那契数列

更新中~