python函数的定义与调用

1. 函数的创建与调用
2. 函数的参数定义
3. 函数的返回值’
4. 函数的参数定义
5. 变量的作用域
6. 递归函数

1函数的创建与调用

函数就是执行特定任务以完成特定功能的一段代码

需要函数的原因

复用代码

隐藏实现细节

提高可维护性

提高可读性便于调试

def 函数名（[输入函数]）

函数体

[return xxx]

函数的创建

def calc(a,b)

c=a+b

return c

====================================================================

函数的调用

函数名([实际参数])

result=calc(10,20)

print(result)

============================================================================

函数的参数传递

位置实参

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

关键字实参

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

def calc(a, b):#a.b称为形参，形参的位置是在函数的定义处
    c=a+b
    return c

result=calc(10,20)#10，20为实参值，实参的位置是函数的调用处
print(result)

3函数的返回值’

def fun(num):
    odd=[]#存奇数
    even=[]#存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
            return odd, even
    return odd, even
#函数的调用
print(fun([10, 29, 34, 44, 53, 55]))


'''函数返回值
(1)如果函数没有返回值[函数执行完毕之后，不需要给调用处提供数据]return可以省略不写
(2)函数的返回值，如果是1个，直接返回类型
（3）函数的返回值，如果是多个，返回的结果是元组
'''
def fun1():
    print('hello')
fun1()

def fun2():
    return'hello'

res=fun2()
print(res)

def fun3():
    return'hello', 'world'
print(fun3())

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

4.函数的参数定义

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

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

#函数的调用
fun(100)#当只赋一个值时，只传一个参b采用默认值
fun(20, 30)#将三十替换为10

个数可变的位置参数

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

使用*定义个数可变的位置形参

结果为一个元组

def fun(*args):#可变的位置参数可变的位置参数只能是一个
    print(args)

fun(10)
fun(10, 20)
fun(10, 20, 30)

个数可变的关键字形参

定义函数时，无法确定传递的关键字实参的个数时，使用可变的关键字形参

使用**定义个数可变的关键字形参

结果为一个字典

def fun(**args):#个数参数可变的位置参数只能是一个
    print(args)

fun(a=10)
fun(a=10, b=20, c=30)
print('hello', 'world', 'python')

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

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

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)#在函数调用时，将列表中的每个元素都转换为位置实参传入

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

 

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

 

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

#函数定义的参数的顺序问题
def fun5(a, b, *, c, d, **args):
    pass

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

5.变量的作用域

程序代码能访问该变量的区域

根据变量的有效范围可分为

局部变量

在函数内定义并使用的变量，只在函数的内部有效，局部变量使用global声明，这个变量就会就成全局变量

全局变量

函数体定义的变量，可作用于函数内外

def fun(a, b):
    c=a+b #c,就称为局部变量，因为c是函数体内进行定义的变量a和b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)
#print(c),因为a,c超出了起作用的范围，（超出了作用范围）

name='懒羊羊'#name的作用范围为函数内部和外部都可以使用--=》称为全局变量
print(name)
def fun2():
    print(name)
#调用函数
fun2()

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

fun3()
print(age)

6，递归函数

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

递归函数的组成部分

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

递归的调用的过程

每递归调用一次函数，都会在栈内存分配一个栈帧

每执行完一次函数，都会释放相应的空间

递归的优缺点

缺点：占用内存多，效率低下

优点：思路和代码简单

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

print(fac(6))

总结

函数的定义与调用	函数使用def定义
	函数定义的形参
		*定义个数可变的位置形参
		**定义个数可变的关键字形参
		定义默认值参数
	函数调用的实参	位置参数
		关键字参数
	函数可以多返回值

变量的作用域	局部变量
	全局变量

 

递归函数	函数本身调用本身
	递归的组成部分	调用条件
		终止条件