Python 函数

定义函数

函数三要素：
	函数名
	参数
	返回值

在Python里使用def来声明一个函数(定义格式如下：)
def 函数名(参数):
"""
多行注释，用于解释说明函数的作用
"""
函数要执行的操作
return(元组)

Remark：
函数声明时，括号里的参数我们称之为形式参数，简称形参
形参的值是不确定的，只是用来占位的
return 表示一个函数的执行结果
如果一个函数没有返回值，它的返回值就是None
在有一些语言里，允许函数重名，在Python里不允许函数重名，如果函数重名了，后一个函数会覆盖前一个函数

局部变量和全局变量

1、如果局部变量的名和全局变量同名，会在函数内部又定义一个新的局部变量，而不是修改全局变量；
2、函数内部如果想要修改全局变量，使用global对变量进行声明，可以通过函数修改全局变量的值

** 在Python里，只有函数能够分割作用域 **

关于函数的一些注意事项：一般情况下，一个函数最多只会执行一个return语句，return语句表示一个函数的结束，
特殊情况下(finally语句)，一个函数可能会执行对个return语句，
如果想要有多个返回值，可以通过列表，元组，字典等把需要返回的值打包起来，我们比较常用的是元组，但是我们常用 return x,y，其本质是一个元组
函数名也是一个标识符。
由数字、字母下划线组成，不能以数字开头；
严格区分大小写；不能使用关键字遵守命名规范，使用下划线连接；顾名思义

def say-hello（name，age，city="襄阳"）：
#形参city设置了一个默认值print（"大家好，我是}，我今年{}岁了，我来自（）".format（name，age，city））
say_hello（'jack'，19）
#如果没有传递参数，会使用默认值,say_hello（'tony'，20，'北京'）
#如果传递参数，就使用传递的实参
#缺省参数：需要注意缺省参数要放在最后面的
#有些函数的参数是，如果你传递了参数，就使用传递的参数
如果没有传递参数，就使用默认的值
#print函数里end就是一个缺省参数
#print（'hello'，'你好"，sep="_____")



如果有位置参数和关键字参数，关键字参数一定要放在位置参数的后面sgy_hello（'jerry'，age=24，city='南京'）
#可以直接传递单个参数，也可以使用变量赋值的形式传参
say_hello（name='henry'，21，city='成都'）

def add(a,b,*args,mul=1,**kwargs):  #*args 表示可变参数，多出来的可变参数会以元组的形式保存到args里，缺省参数一定要放到最后面 #kwargs 表示可变的关键字参数，多出来的kwargs会以字典的形式保存

函数中可变数据类型和不可变数据类型

可变数据类型和不可变数据类型传参

def test(a):
    a = 100
def change(nums):
    nums[0] = 100
x = 1
y = [1, 2, 3, 4]
print(x)
print(y)
结果是：1
[100, 2, 3, 4]

递归

简单来说就是函数内部自己调用自己
递归最重要的就是找到出口（停止的条件）
eg：

#计算求和
def get_sum(n):
	if n == 0:
		return 0
	return n + get_sum(n-1)
print(get_sum(6))

#计算阶乘
def fac(n):
	if n==0:
		return 1
	return n*fac(n-1)
print(fac(3))

#计算斐波那契数列
def fibonacci(n):
    if n==1 or n==2:
        return 1
    return fibonacci(n-1)+fibonacci(n-2)
print(fibonacci(9))

匿名函数

x=add（4，5）#函数名（实参）作用是调用函数，获取到函数的执行结果，并赋值给变量x
fn=add 这时相当于给函数fn取了个别名，fn(a,b)==add(a,b)

除了使用def关键字定义一个函数以外，我们还能使用Lambda表达式定义一个函数

eg: def add(a,b)
	return a+b
<==> lambda a,b:a+b 

匿名函数，用来表达一个简单的函数，函数调用的次数很少，基本上就是调用一次

调用匿名函数的两种方式：

1.给他定义一个名字 mul = lambda a,b:a*b
2.把这个函数当做参数传给另一个函数使用（使用场景比较多）

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

def add(x, y): 
	return x +y 
def minus(x, y):
return x-y

x1 =calc(1, 2)
print(x1)
x2 = calc(10, 5)
print(x2)

#自定义匿名函数：
x1 = calc(5,7, lambda x,y : x+y)
x2 = calc(5,7, lambda x,y : x-y)
x3 = calc(5,7, lambda x,y : x/y)
x4 = calc(5,7, lambda x,y : x*y)

高阶函数

1、把一个函数作为另一个函数的返回值
2、把一个函数作为另一个函数的参数
3、函数内部再定义一个函数

eg：

def foo():
	print('我是foo,我被调用了')
	return 'foo'

def bar():
	print('我是bar，我被调用了')
	return foo()
	
x=bar()
print('x的值是{}'.format(x))
结果是
我是foo,我被调用了
我是bar，我被调用了
foo

如果改为
def bar():
	print('我是bar，我被调用了')
	return foo
x=bar()
print('x的值是{}'.format(x))
结果是
我是bar，我被调用了

但是如果y=bar()(),那么打印y的结果是foo,因为bar()返回foo,再加上个(),表示了调用了foo()函数

def outer():#函数套函数，并在函数里返回内部的一个函数
	m=100
	def inner():
		n=90
		print('hello,我是inner函数')
	print('我是outer函数')
	return inner

我们如果直接调用outer()函数是可以的，但是我们不能调用inner函数，可以使用下面的方法来进行调用
outer()()

闭包

def outer(n):
	num=n
	def inner():
		return num+1
	return inner
print(outer(3)()) #4
print(outer(5)())#

在这段程序中，函数iner是函数 outer的内嵌函数，并且 Inner函数是 outer函数的返回值。
我们注意到个问题：内嵌函数iner中引用到外层函数中的局部变量num，Python解释器会这么处理这个问题呢？
先让我们来看看这段代码的运行结果，
当我们调用分别由不同的参数调用 outer函数得到的函数时，得到的结果是隔离的相互不影响），
也就是说每次调用 outer函数后都将生成并保存一个新的局部变量num，这里 outer函数返回的就是闭包。
如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）

def outer():
	x=10 #在外部函数定义了一个变量x，是一个局部变量
	nonlocal x #此时，这里的x不再是新增的变量，而是外部的局部变量x
	def inner():
		y=x+1
		x=20#不是修改外部x变量，而是在inner函数内部又创建了一个变量，但是我们可以在前面加上nonlocal x