目录
一、函数的创建和调用
1.什么是函数
函数就是执行特定任务，完成特定功能的一段代码。
2.为什么需要函数
①复用代码;②隐藏实现细节；③提高可维护性；④提高可读性便于调试
3.函数的创建
"函数的定义以及使用"
def calc(a, b): # a,b 为形式参数，为形参
c = a + b
return c
result = calc(10, 20) # 10，20为实际参数值，简称实参 ### 根据位置传递参数
result1 = calc(b=20, a=60) ### 根据关键字传递参数
print(result)
print(result1)二、函数的参数传递
1.函数调用的参数传递
①位置实参：根据形参对应的位置进行实参传递
②关键字实参：根据形参名称进行实参传递
"函数的调用及参数传递"
def fun(arg1, arg2): # 两个形参
print("arg1", arg1)
print("arg2", arg2)
arg1 = 100
arg2.append(10)
print("arg1", arg1)
print("arg2", arg2)
# return 这里的return可有可无，因为return返回没有携带任何值
n1 = 11
n2 = [22, 33, 44]
print(n1)
print(n2)
print('--------------------------------------')
fun(n1, n2) # 位置传参。#arg1 arg2是函数的形参，而n1，n2是实参，所以实参与形参名称没必要一致
print('########################################')
print(n1)
print(n2)
'''
如果在函数调用过程中，进行参数的传递
如果是不可变对象，则函数体的修改不会影响实参的值 arg1的修改为100，不影响n1的值
如果是可变对象，在函数体内的修改会影响到实参的值 arg2.append（10）的修改影响n2的值
'''三、函数的返回值
函数返回多个值时，结果为元组
"函数的返回值"
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, 23, 44, 53, 55]))
###### ([29, 23, 53, 55], [10, 34, 44])
"""
1.如果函数没有返回值，（也就是函数执行完毕，不需要给调用处提供数据）return可以省略不写
2.函数的返回值，如果是一个，直接返回原类型
3.函数的返回值，如果是多个，返回的结果时元组
4.函数在定义时，是否需要return,需要视情况而定
"""
def fun1():
print('hello world')
fun1()
def fun2():
return 'hello world!'
res = fun2()
print(res)
def fun3():
return 'hello', 'world'
print(fun3())四、函数的参数总结
1.列表或字典内的元素作为实参
def fun(a, b, c):
print('a=', a)
print('b=', b)
print('c=', c)
# 函数的调用
#######################列表
lst = [11, 22, 33]
fun(*lst) # 这里不能直接调用列表，需要前面加*，然后将列表中的每个元素都转换为位置实参传入
########################字典
dic = {'a': 111, 'b': 222, 'c': 333}
fun(**dic) # 这里在字典前面加**，将字典内的元素转为关键字实参传入
2.个数可变的位置形参
def fun1(*args): # 个数可变的位置形参
print(args)
fun1(20, 10, 40, 50)
# 结果
# (20, 10, 40, 50)
# 会以元组的形式输出3.个数可变的关键字形参
def fun2(**args): # 个数可变的关键字形参，
print(args)
fun2(a=10, b=20, c=30, d=40)
# 运行结果
# {'a': 10, 'b': 20, 'c': 30, 'd': 40}
# 会以字典的形式输出4.位置参数与关键字参数共用
def fun4(a, b, *, c, d): # 这样的话，cd两个参数只能用关键字传递，也就是从*之后在函数调用时只能用关键词传参
pass
fun4(10, 20, c=30, d=40)def fun5(a,b,*,c,d,**args):
print(a,b,c,d,args)
fun5(10, 20, c=100, d=200,e=300,f=400)
#运行结果
# 10 20 100 200 {'e': 300, 'f': 400}def fun6(*args1, **args):
print(args1, args)
fun6(10, 20, 30, 40, c=100, d=200,e=300,f=400)
# 运行结果
(10, 20, 30, 40) {'c': 100, 'd': 200, 'e': 300, 'f': 400}
def fun7(a, b, c=10, *args1, **args):
print(a, b, c, args1, args)
fun7(10, 20, 30, 40, d=200,e=300,f=400)
# 运行结果
# 10 20 30 (40,) {'d': 200, 'e': 300, 'f': 400}五、变量的作用域
变量的作用域就是程序代码能访问该变量的区域
根据变量的有效范围可分为：
局部变量:在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量变量就会变成全局变量
全局变量：函数体外定义的变量，可作用于函数内外
def fun(a, b):
c = a+b # c就称为局部变量，因为c是在函数体内进行定义的变量，a,b为为函数的形参，作用于函数内部，相当于局部变量
print(c)
# print(a,c) # 这里会报错，因为a,c超出了起作用的范围（作用域）
"-------------------------------------------------------------------------"
str = 'python' # str的作用范围为函数内部和外部都可以使用
# print(str)
def fun1():
print(str)
# 调用函数
fun1()
"--------------------------------------------------------------------------"
def fun3():
global age # 函数定义的局部变量，如果使用了global去声明，这个变量实际上就变成了全局变量
age = 20
print(age)
fun3()
print(age)六、递归函数
1.什么是递归函数
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
"使用递归函数来计算阶乘"
# 使用循环来计算6！
i = 1
s = 1
while i <= 6:
s = i * s
i += 1
print('while循环', s)
s = 1
for i in range(1, 7):
s = i*s
print("for循环", s)
# 使用递归函数来计算阶乘
def fun(n):
if n == 1:
return 1
else:
res = n * fun(n-1)
return res
print('使用递归函数', fun(6))
2.递归的组成部分
递归调用与递归终止条件
3.递归的调用过程
每递归调用一次函数，都会在栈内存分配一个栈帧
每执行完一次函数，都会释放相应的空间
4.递归的优缺点
缺点：占用内存多，效率低下
优点：思路和代码简单
5.斐波那契数列
"使用递归函数来计算计算斐波那契数列"
def fun(i):
if i == 1 or i == 2:
return 1
else:
res = fun(i-2) + fun(i-1)
return res
print(fun(11))
# 输出这个数列的前6位上的数字
for i in range(1, 7):
print(fun(i))
8099
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
