Python中的函数

函数

一、函数的定义及参数传递

1、方便维护，模块化设计

2、减少代码的冗余

	 def add(a,b):
	     return a + b
	 print(add(1,2))
	 result = add(3,4)
	 print(result)

二、函数的参数

1、形参：函数定义的时候，指定的参数

2、实参：函数调用的时候，指定的参数

3、参数的分类

按形参来分
3.1 必选参数
def stuinfo(name,age,sex):
print(f"myname is {name},my age is {age},my sex is {sex}")
3.2 默认参数
def stuinfo(name,age,sex=“f”):
print(f"myname is {name},my age is {age},my sex is {sex}")
stuinfo(‘sc’,4)
stuinfo(‘sc’,5,‘m’)
3.3 可变长参数
def myargs(name,*num):
print(f’{name}:{num}’)
print(type(num),*num) # -->print(type(num),1 2)
myargs(‘sc’)
myargs(‘sc’,1)
myargs(‘sc’,1,2)
3.3.1、packing和unpacking
packing
1,2–>元组（1，2）
*num unpacking
（1，2）–>1，2
3.4 可变长关键字参数
def myargs(**num):
print(num)
myargs(a=1,b=2)
myargs(a=1)
myargs(a=1,b=2,c=3)
#packing --> a=1,b=2–>{‘a’:1,‘b’:2}
#unpacking --> {‘a’:1,‘b’:2} -->a=1,b=2
按实参来分：
3.1 位置参数
stuinfo(‘sc’,4,‘f’)
3.2 关键字参数
stuinfo('sc,'sex=‘m’,age=6)

4、注意定义的顺序，默认参数必须放在参数后面

形参的定义顺序：必选参数–》可变长位置参数–》默认参数–》可变长关键字参数
实参：位置参数–》关键字参数

5、注意调用顺序，关键字参数必须放在位置参数后面

小案例

		def agrs(*num):
		     sum = 0
		     for i in num:
		         sum+=i
		    print(f'可变长位置参数的和为{sum(num)}')
		agrs(1,2,3)
		def agrs2(**num1):
		     sum1 = 0
		     for i,j in num1.items():
		         sum1+=j
		    print(f'可变长关键字参数和为{sum(num1.values())}')
		agrs2(a=1,b=2,c=3,d=4)

6、函数的return语句：

退出函数，并且返回结果，一个函数一但执行到return就退出，不会执行后面的语句
如果函数没有return语句，默认返回值是None，如果return后面不接任何表达式，也是返回None
return一次也可以返回多个值

	def maxnum(x,y):
		    print('retrun语句。。。')
		    if x>y:
		        print('return x')
		        return x
		    elif x<y:
		        print('return y')
		        return y
		    else:
		        return x,y
		    print('return end...')
		result = maxnum(3,5)
		i,j = maxnum(5,5)
		print(f'结果为{result},i的结果是{i},j的结果是{j}')

三、匿名函数和递归函数：

1、匿名函数：不需要创建函数名，只能又一个表达式，不用写return，该表达式的结果就是返回值

add2 = lambda x,y:x+y
print(add2(1,3))

2、递归函数：自己调用自己，形成循环；

定义出口条件，什么时候结束递归
通常是把一个大问题通过寻找规律可以缩小规模的时候使用的
2.1、有最大递归深度，996

	def fun01(n):
		    if n ==1:
		        return 1
		    return n * fun01(n-1)
		print(fun01(4))

2.2、 尽量避免使用递归，除非没有更好的算法，或者是某种特定的情况下使用递归
2.3、 每次递归都会保存结果在内存中，非常占用内存，效率低下

小案例：

#1、使用递归实现斐波拉契数列
1，1，2，3，5，8，13；第一位第二位都是1，后面的数都是前两个数的和

	def func01(n):
	    if 0<n<=2:
	        return 1
	    else:
	        return func01(n-1)+func01(n-2)
	a = int(input())
	str1 = ''
	for i in range(a):
	    str1 += str(func01(i+1))+','
	print(str1)
	print(func01(a))

#2、有一对雌雄兔，每两繁殖一对雌雄兔，问n个月以后有多少对兔子

	def func02(n):
	    if 0<n<=2:
	        return 1
	    else:
	        return func02(n-2)*2
	print(func02(6))

四、函数的参数传递:本质上都是传递引用

变量的空间作用域

1、可变数据类型

	def f(x):
	    x[0] = 100
	    print(x)
	a = [1,2,3]
	f(a)
	print(a)

2、变量的作用域

	def f ():
	    global x    #申明x为全局变量
	    x = 5
	x = 1
	f()
	print(x)

3、变量名的解析（LEGB）

3.1、在本地变量中找 – local
3.2、在任意层函数中找 – encloding
3.3、在全局作用域找 – global
3.4、在内置作用域找 – builtin

		def f():
		    x = 2
		    def f2():
		        x = 3
		        print(x)
		        print(__name__)
		    f2()
		x = 1
		f()

4、文档注释：包、模块、类或者是函数第一个用三引号引起来的字符串

5、内建函数和工厂函数