函数

函数（function）

• 函数简介
  • 函数也是个对象，用来保存一些可执行的代码，在需要时可进行多次调用
  • 函数中保存的代码不会立即执行，需要调用
  • 语法：def 函数名 ([形参1，形参2，形参3…]):
    代码块
  • fn是函数对象 fn()是调用函数
  • print是函数对象 print()调用函数

def fn():
	print('Hello World!')

fn()		#Hello World!

• 参数：在定义函数时，可以再函数后面的括号里面定义数量不等的形参，多个形参要用逗号隔开
• 形参也叫形式参数，定义形参就相当于在函数内部声明了变量，但是没有赋值
• 实参（实际参数），如果函数在定义的时候，指定了形参，那么在调用函数的时候也必须传递形参

#定义一个函数，用来求任意两个数的和
def s(a,b):
	print(a+b)

函数的传递方式

• 位置传参：就是将对应位置上的实参赋值给对应位置上的形参
• 关键字参数，可以不按照定义的顺序去传递，根据参数名去传递参数
• 位置参数和关键字参数可以混用，必须将位置参数写到关键字参数前面
• 定义一个函数的时候是可以指定默认值的
• 指定了默认值之后，如果用户传递了参数，则默认值不生效
• 如果用户没有传递参数，则默认值生效

def fn(a,b,c=20):
	

实参的类型

• 在函数中对形参进行复制，不会影响其他的变量
• 当通过形参去修改对象时，会影响到所指向该对象的变量

不定长参数

• 在定义函数的时候，可以再形参的前面加上一个*，这样这个形参会获取所有的实参，并把它们保存到一个元组当中
• 带*的参数只能有一个
• ** 形式的形参可以接受其他关键字参数，他会将这些参数同一保存到一个字典当中，字典的key就是参数的名字，value是参数值
• ** 形式的参数只能有一个，写到最后

#定义一个函数，求任意数的和
def s(*a):
	#定义一个变量保存结果
	r=0
	#遍历元组，将元组当中的数相加
	for n in a:
		r = r + n
	print(r)

参数的解包

def fn(a,b,c):
	...
t = (4,5,6)
fn(*t)

函数的返回值

• 返回值就是返回函数执行的结果
• 通过return来指定函数的返回值
• 返回值可直接使用，通过一个变量来接收函数的返回值
• return后面可以跟任意的对象，甚至可以是一个函数（不加括号）
• fn是函数对象，fn()是调用函数
• 打印fn()，实际上就是在打印fn()的返回值

def fn():
	def fn2():
		print('hello')
	return fn2
r = fn()
r()				#hello

def fn2():
	return

r = fn2()
print(r)			#None

#在函数中，return后的代码都不会执行，return一旦执行函数自动结束
def fn3():
	print('abc')
	return
	print('hahah')

r = fn3()
print(r)			#abc,None


def fn4():
	for i in range(5):
		if i==3:
			break			
			#return			#函数结束  0,1，2
			#continue		#用来跳过当次循环0,1，2,4,函数执行完毕
		print(i)
	print('循环执行完毕')

fn4()				#0,1,2,循环执行完毕

文档字符串

• help()是python中的内置函数，可以查询python中函数的用法
• 语法：help(函数对象) 函数对象不加括号
• 在定义函数的时候，可以再函数内部编写文档字符串，文档字符串就是函数的说明
• 当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明

def fn(a,b,c):
	'''
	这是一个文档字符串的示例
	这个函数的作用：....
	'''
	return 123

help(fn)

函数的作用域

• 作用域（scope）：指的就是变量生效的区域
• python中有两种作用域
  • 全局作用域：在程序执行的时候创建，程序结束后销毁，变量为全局变量
  • 函数作用域：在函数调用时创建，调用完销毁，变量为局部变量，只能在函数内部被访问
• 可以再内部作用域中看到外部作用域
• 不能从外部作用域看到内部作用域
• 在函数内部修改全局变量，需要使用global关键字，来声明局部变量
• global a #声明在函数内部使用的a是全局变量，此时去修改a，就是在修改全局的a

命名空间

• 命名空间就是一个字典，是一个专门用来保存变量的字典
• locals() 用来获取当前作用域的命名空间，返回值为一个字典
• globals()函数可以用来获取全局的命名空间

scope = locals()
scope['c'] = 567		#向scope里面添加一个键值对
print(c)

递归函数

• 尝试求10的阶乘（10！）
• 递归式的函数简单地说就是在函数中自己调用自己
• 递归是解决问题的一种思想，和循环很像，整体思想为把一个大的问题分解为一个个小问题，直到问题无法分解时，再去解决问题
• 递归函数的两个条件：
  • 1.基线条件：问题可以被分解为最小的问题，当满足基线条件时，递归就不再执行了
  • 2.递归条件：将问题继续分解的条件

#用递归的思想解决任意数的阶乘问题
#10！=10*9！
#9！=9*8！
#...
#1！=1
def fn2(n):
	#1.基线条件
	if n == 1:
		return 1
	#2.递归条件
	return n*fn2(n-1)

print(fn2(10))

高阶函数

• 特点一 接受一个或多个函数作为参数
• 特点二 将函数作为返回值返回
• 当我们使用一个函数作为参数的时候，实际上就是将指定的代码传给了目标函数

#可以将指定列表中所有的偶数保存到一个新列表中返回
lst = [1,2,3,4,5,6,7,8,9,10]

#定义一个函数用来检测任意数是否为偶数
def fn2(i):
	if i%2 == 0:
		return True
	#定义一个函数，用来检测大于5的数
def fn3(i):
	if i > 5:
		return True
	return False


def fn(func,lst):
	#参数lst  要进行筛选的列表
	#创建一个新的列表
	new_lst = []
	#对要筛选的列表进行遍历
	for n in lst:
		#判断n的奇偶
		if func(n):
			new_lst.append(n)
	#返回新的列表
	return new_lst

print(fn(fn2,lst))		#[2,4,6,8,10]

匿名函数

• filter() python内置函数,参数1 函数 参数2 需要过滤的序列（可迭代的） 返回值 过滤后的新的序列

lst = [1,2,3,4,5,6,7,8,9,10]

def fn4(i):
	if i % 3 == 0:
		return True
	return False

print(list(filter(fn4,lst)))		#[3,6,9]

• 匿名函数 lambda函数表达式
• lambda函数表达式就是专门用来创建一些简单的函数
• 语法：lambda 参数列表 ： 返回值

def fn5(a,b):
	return a + b

print(fn5(1,2))
#(lambda a,b : a+b)(50,60)
fn6 = lambda a,b : a+b
print((lambda a,b : a+b)(50,60))
print(fn6(50,60))

lst = [1,2,3,4,5,6,7,8,9,10]
r = filter(lambda i : i % 3 == 0, lst)
print(list(r))

闭包

• 通过闭包可以创建一些只有当前函数能够访问的变量，将一些私有数据藏到闭包中
• 形成闭包的条件
  • 1.函数嵌套
  • 2.将内部函数作为返回值返回
  • 3.内部函数必须使用到外部函数的变量

#特点二  将函数作为返回值也是高阶函数
def fn():
	#再函数内部定义一个函数
	def fn2():
		print('我是fn2')
	#将内部函数fn2作为返回值返回
	return fn2

print(fn())		#结果为fn2
r = fn()
r()				#我是fn2

#求平均数
def make_fn():
	nums2 = []
	def fn1(n):
		nums2.append(n)
		return sum(nums2)/len(nums2)
	return fn1

m = make_fn()
print(m(10))

装饰器

• 我们可以通过修改函数中的代码来完成需求，但是会产生一些问题
  • 问题1： 如果要修改的函数过多，修改起来比较麻烦
  • 问题2： 不方便后期的维护
  • 问题3： 违反开闭原则（ocp）程序的设计思想，要求开发对程序的扩展，要关闭对程序的修改

#求任意两个数的和
def add(a,b):
	return a+b

#求任意两个数的积
def mul(a,b):
	return a * b

#希望在不修改原函数的前提下，来对函数扩展功能
def fn():
	print('我是fn函数')

def fn2():
	print('函数开始执行')
	fn()
	print('函数执行结束')

def new_add(a,b):
	print('开始执行')
	r = add(a,b)
	print('函数执行结束')
	return r 
r = new_add(a,b)
print(r)

#定义一个函数来对其他的函数进行扩展，使其他的函数可以在执行前打印开始，执行后打印结束
def fn():
	print('我是fn函数')

def start_end(old):
	#参数old  要扩展的函数对象
	#创建一个新的函数
	def new_function(*args, **kwargs):
		print('函数开始执行')
		r = old(*args, **kwargs)
		print('函数执行结束')
		return r
	#返回函数
	return new_function

f = start_end(add)
r = f()
print(r)

• start_end(old) 这一类函数我们就称之为装饰器

#用装饰器扩展下面这个函数的功能
@start_end
def speak():
	print('同学们好好复习')

speak()