python中的函数

一、函数的定义与调用

1、什么是函数：

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

2、为什么需要函数

（1）复用代码；（2）隐藏实现细节；（3）提高可维护性；（4）提高可读性便于调试；

3、函数的创建

举例：创建一个加法函数：

def calc(a,b):    #a和b称为形式参数，简称形参，形参的位置是在函数的定义处
	c=a+b
	return c      #返回的c是结果

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

二、函数的参数（难点）

函数的参数分为：

（1）函数的调用时的实际参数。

（2）函数的定义时的形式参数。

1、函数的参数传递-------位置实参，关键字实参

（1）位置实参：

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

def calc(a,b):    #a和b称为形式参数，简称形参，形参的位置是在函数的定义处
	c=a+b
	return c      #返回的c是结果

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

（2）关键字实参：

根据形参名称进行参数传递。

def calc(a,b):
	c=a+b
	return c

res=calc(b=10,a=20)    # 等号左侧的变量的名称称为 关键字参数
print(res)

2、函数参数传递的内存分析

def fun(arg1,arg2):
	print("arg1:",arg1)
	print("arg2:",arg2)
	arg1 = 100            #令形参arg1等于100
	arg2.append(10)       #给形参arg2末尾加上10
	print("arg1:",arg1)
	print("arg2:",arg2)

print("--------------------------")

n1 = 11
n2 = [22,33,44]
print("n1:",n1)
print("n2:",n2)

print("--------------------------")
fun(n1,n2)      #执行函数
print("--------------------------")

print("n1:",n1)   #函数执行完毕后，你会发现，n1没有变化，n2变化了。
print("n2:",n2)

代码结果：

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

注意：字符串是不可变对象，列表是可变对象；所以上面代码中最后n1没有变，n2变化了。

3、函数的默认值参数

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

def fun(a,b=10):#b=10是默认值参数
	print(a,b)

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

4、个数可变的位置参数与关键字参数

1、个数可变的位置参数

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

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

（3）结果为一个元组

def fun1(*args):#函数定义时的，可变的位置参数。   而且个数可变的位置参数，函数中只能有一个。
	print(args)
	print(args[0])#输出坐标为0的那一个
fun1(10)
fun1(11,20,30)

2、个数可变的关键字参数

（1）定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字参数

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

（3）结果为一个字典

def fun2(**args):#个数可变的关键字参数，函数中只能有一个。
	print(args)
fun2(a=10)
fun2(a=10,b=20,c=30)

3、两个可变参数的顺序

个数可变的位置参数 只能放在 个数可变的关键字参数 之前。*只能在**之前。

def fun3(*args1,**arg2):#个数可变的位置参数 只能放在 个数可变的关键字参数 之前。*只能在**之前。
	pass

5、函数的参数总结:

1、函数的实参传递：

（1）函数调用时按照位置的参数传递，称为位置传参。 

（2）函数在调用时，将列表中的每个元素都转换为位置实参传入。列表前加 * 。    

（3）函数关键字的调用，是关键字实参。

（4）在函数调用时，将字典中的键值对都转换为关键字实参传入，字典前加 ** 。

代码：

def fun(a,b,c):#a,b,c在函数的定义处，所以是形式参数。
	print('a=',a)
	print('b=',b)
	print('c=',c)
#函数的调用：
fun(10,20,30) #函数调用时的参数传递，称为位置传参。
print("------------------------------------")
lst=[11,22,33]
fun(*lst)  #函数在调用时，将列表中的每个元素都转换为位置实参传入。列表前加 * 。	
print("------------------------------------")
fun(c=200,a=100,b=222) #函数的调用，所以是关键字实参。
print("------------------------------------")
dic={'a':555,'b':666,'c':777}  
fun(**dic)  #在函数调用时，将字典中的键值对都转换为关键字实参传入，字典前加 ** 。

2、函数的形参

（1）默认值形参

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

（2）个数可变的位置形参 与 个数可变的关键字形参

def fun2(*args1):  #个数可变的位置形数
	print(args1)
def fun3(**args2):  #个数可变的关键字形参
	print(args2)
fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)

（3）函数的形参中加入 * 。（也叫命名关键字参数）

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

(4)函数定义时的形参的顺序问题  参数组合

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

五种参数类型可以组合使用，但是有一定的顺序，顺序是：位置参数、默认值参数、可变参数、命

名关键字参数、可变关键字参数。

三、函数的返回值（return）

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

例子：将一个列表中的数分为奇数和偶数

def fun(num):
	odd=[]      #存奇数
	even=[]		#存偶数
	for i in num:
		if i%2:         #'''i与2的布尔值是ture'''                           
			odd.append(i)
		else:
			even.append(i)
	return odd,even

list=[10,29,34,23,44,53,55]
print(fun(list))

结果：

判断布尔值：

print(bool(0))  #0的布尔值：False
print(bool(8))  #非0的布尔值：Ture

2、函数的返回值总结：

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

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

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

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

print("------------------------------------")
def fun1():
	print("hello")
fun1()

print("------------------------------------")
def fun2():
	return"hello"
res=fun2()
print(res)

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

四、函数变量的作用域（局部变量、全局变量）

1、局部变量

定义函数内的变量叫做局部变量，在函数外是不能访问局部变量

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

2、全局变量

全局变量 ------- 定义在 .py 文件的变量

在函数内是可以访问全局变量

全局变量不能直接在函数内部进行操作，如果需要在函数内部操作全局变量，需要调用 global 关键

字 ( 但是不建议在函数里面操作全局变量 )

name = "阿文"   #name的作用范围是函数内部和外部都可以使用 ---> 称为全局变量。
print(name)
def fun2():
	print(name)
#调用函数
fun2()

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

五、递归函数

在函数的内部，去调用自己

条件： 函数自己要调用自己 ；递归一定要有结束条件。

1、什么是递归函数：

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

2、递归的组成部分：

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

3、递归的调用过程：

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

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

4、递归的优缺点：

优点：思路和代码简单

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

使用递归来计算阶乘：

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

print(fac(6))  #计算6的阶乘

使用递归来计算斐波那契数列：

def fib(n):
	if n==1:
		return 1
	elif n==2:
		return 1
	else:
		return fib(n-1)+fib(n-2)

#计算斐波那契数列第六位上的数字
print(fib(6))

print("------------------------------")

#输出斐波那契数列前六位的数字
for i in range(1,7):
	print(fib(i))

总结图：

 注：图片来自于哔哩哔哩@Python_子木

以上就是python函数的主要内容了，感谢观看，阿哩嘎豆！！OVO！！