6.函数与lambda表达式

一、笔记

函数

（一）函数的定义

• 函数以def关键词开头，后接函数名和被“（）”括住的形参。
• 函数执行的代码以“：”开始并且缩进。
• 以“return【表达式】”结束函数。它的作用是选择性地返回一个值给调用方。不带表达式的“return”相当于返回“none”给调用方。

定义函数的格式：

def functionname(parameters):
	function_suite
	return [expression]

（二）函数的调用

举个例子：

def printcon(str1,str2):#函数名中不可含有“-”，否则报错。可以含有“_”。
    print(str1+str2)
printcon('hello','cook')#hellocook
value=printcon('fine','0')#fine0
print(value)#None

（注：定义完函数后，当键入函数名的前几个字母时，键入提示会出现自己已经定义的函数名。）
（三）函数参数
Python的参数形态由简到繁：
位置参数（positional argument）
默认参数（default argument）
可变参数（variable argument）
关键字参数（keyword argument）
命名关键字参数（name keyword argument）
参数组合
1.位置参数（positional argument）

def functionname(arg1):
	function_suite
	return [expression]

• “arg1”——位置参数。调用函数（call function）时，这些参数的位置要固定。

2.默认参数（default argument）

def functionname(arg1,arg2=v):
	function_suite
	return [expression]

• “arg2=v”——默认参数。调用函数时，如果默认参数的值没有传入，则被认为是默认值。
• 默认参数要放在位置参数的后面，否则程序会报错。

def printB(fruit,price=6):
	print('fruit:{0},price:{1}'.format(fruit,price))
	
printB('banana')#fruit:banana,price:6
printB('banana',10)#fruit:banana,price:10

• Python允许调用函数时参数顺序与声明的不一致，因为Python解释器能够用参数名匹配参数值。

def printB(fruit,price=6):
	print('fruit:{0},price:{1}'.format(fruit,price))
	

3.可变参数（variable argument）

def functionname(arg1,arg2=v,*args):
	function_suite
	return [expression]

• “*args”——可变参数。个数可以是0到任意数，自动组装成元组。
• 加了“*”的变量名会存放所有未命名的变量参数。

def printC(arg1,*args):
	print(arg1)
	print(args)
printC('A')
#A
#（）
printC('A','B','C')
#A
#（B，C）

def printC(arg1,*args):
	print(arg1)
	for var in args:
		print(var)

printC('A')#A
printC('A','B','C')
#A
#B
#C

4.关键字参数（keyword argument）

#def functionname(arg1,arg2=v,*args,**kw):
	#function_suite
	#return [expression]

• “**kw”——关键字参数。个数可以是0到任意数，自动组装成字典。

def printD(arg1,*args,**kwargs):
	print(arg1)
	print(args)
	print(kwargs)
	
printD(1,2,3,4)
#1
#(2,3,4)
#{}
printD(1,2,3,4,a=1,b=2)
#1
#(2,3,4)
#{'a':1,'b':2}

5.命名关键字参数（name keyword argument）

def functionname(arg1,arg2=v,*args,*,nkw,**kw):
	function_suite
	return [expression]

• “*,nkw”——命名关键字参数。
• 如果想要限制关键字参数的名字就可以用命名关键字参数。
• 使用命名关键字参数时，要特别注意不能缺少参数名。

def printE(arg1,*,nkw,**kwargs):
	print(arg1)
	print(nkw)
	print(kwargs)
	
printE(10,nkw=20,a=1,b=2)
#10
#20
#{'a':1,'b':2}
printE(10,20,a=1,b=2)
#TypeError:printE() takes 1 positional argument but 2 were given

• 没有写参数名nkw，所以10被当成位置参数。原函数只有一个位置参数，现在调用了2个，因此会报错。

（四）参数组合
在定义函数时，以上5种参数中最多可以用4个，并且还要遵循一定的顺序：

• 位置参数、默认参数、可变参数、关键字参数。
• 位置参数、默认参数、命名关键字参数、关键字参数。

在定义时注意各个参数的表示方法：

参数	表示方法举例
位置参数	arg1
默认参数	arg2
可变参数	*args（args接收的是一个tuple）
关键字参数	**kwargs（kwargs接收的是一个dict）
命名关键字参数	*，nkw

（五）函数的返回值

• 定义函数时，“return[expression]”的作用是选择性地返回一个值给调用方。不带表达式的“return”相当于返回“none”给调用方。

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

print(add(1,2))#3
print(add([1,2],[2,3]))#[1,2,2,3]

def back():
	return [1,'my first name',3.14]
print(back())
#[1,'my first name',3.14]

def back():
	return 1,'my first name',3.14
print(back())
#(1,'my first name',3.14)

def printA(str):
    print(str)
printA('hello,nice to me you.')#hello,nice to me you.	
value=printA('fine')#fine
print(value)#none
print(type(value))#(class 'NoneType')

（六）变量作用域

• Python中，程序的变量并不是在哪个位置都可以访问的，访问权限取决于这个变量是在哪个位置赋值的。
• 定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
• 定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
• 局部变量只能在其被声明的函数内部访问，而全局变量可以在其声明的整个程序内访问。
• 当内部作用域想修改外部作用域的变量时，就要用到global和nolocal关键字了。

num=1

def fun1():
	global num
	print(num)
	num=123
	print(num)
	
print(num)#1
fun1()
#1
#123
print(num)#123
print(num+1)#124

1.内嵌函数

def outer():
	print('This is outer.')
	def inner():
		print('This is inner')
	inner()#该函数只能在outer内部被调用（也就是现在这个位置）
		
outer()
#This is outer.
#This is inner.

2.闭包

• 闭包是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
• 如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就会被认为是闭包。
• 通过闭包可以访问外层非全局作用域的变量，这个作用域被成为全局作用域。

def funX(x):
	def funY(y):
		return x*y
	return funY
	
i=funX(8)
print(type(i))#(class 'function')
print(i(5))#40

• 闭包的返回值通常是函数。

def make_counter(init):
	counter=[init]
	def inc():counter[0]+=1
	def dec():counter[0]-=1
	def get():return counter[0]
	def reset():counter[0]=init
	return inc,dec,get,reset
	
inc,dec,get,reset=make_counter(0)
inc()
inc()
inc()
print(get())#3
dec()
print(get())#2
reset()
print(get())#0

• 如果修改闭包作用域的值则需要nolocal关键字。

def outer():
	num=10
	def inner():
		nonlocal num
		num=100
		print(num)
	inner()
	print(num)

outer()
#100
#100

3.递归

• 如果一个函数在内部调用自己本身，这个函数就是递归函数。
  例子：求阶乘。

#利用循环的方法实现
n=5
for k in range(1,5):
	n=n*k
print(n)#120

#利用递归函数实现
def factorial(n):
	if n==1:
		return 1
	return n*factorial(n-1)

print(factorial(5))#120

例子：斐波那契数列f(n)=f(n-1)+f(n-2),f(0)=0,f(1)=1

#利用循环实现
i=0
j=1
lst=list([i,j])
for k in range(2,11):
	k=i+j
	lst.append(k)
	i=j
	j=k
print(lst)
#[0,1,1,2,3,5,8,13,21,34,55]

#利用递归函数实现
def feibo(n):
	if n <= 1:
		return n
	return feibo(n-1)+feibo(n-2)

lst=list()
for k in range(11):
	lst.append(feibo(k))
print(lst)
#[0,1,1,2,3,5,8,13,21,34,55]

• 可以自己设置递归的层数，Python默认递归的层数是100.

#利用递归函数实现阶乘
def factorial(n):
	if n==1:
		return 1
	return n*factorial(n-1)

print(factorial(1000))
#RecursionError：maximum recursion depth exceeded in comparion.

import sys
sys.setrecursionlimit(1000)

Lambda表达式

（一）匿名函数的定义

• Python中的两类函数：

第一类：用关键词“def”定义的正规函数。
第二类：用关键词“lambda”定义的匿名函数。

• 匿名函数的语法结构：

lambda argument_list:expression

lambda——定义匿名函数的关键词。
argument_list——函数参数（和正规函数中的参数类型一样）。
expression——表达式。

• 注意：
  expression没有return语句，因为lambda不需要它来返回，表达式本身结果就是返回值。
  匿名函数拥有自己的命名空间，且不能返回自己参数列表以外或全局命名空间里的参数。

#用正规函数求平方
def sqr(x):
	return x**2

print(sqr)
#(function sqr at 0x0000000001E3B5E0)

y=[sqr(x) for x in range(10)]
print(y)
#[0,1,4,9,16,25,36,49,64,81]

#用lambda求平方
sqr1=lambda x:x**2
print(sqr1)
#(function (lambda) at 0X000000000BA60)

y=[sqr1(x) for x in range(10)]
print(y)
#[0,1,4,9,16,25,36,49,64,81]

summary=lambda a,b: a+b
print(summary(1,2))#3

summary1=lambda *args:sum(args) 
print(summary1(1,2,3,4))#10

（二）匿名函数的应用

二、练习

怎么给函数编写⽂档？
怎么给函数参数和返回值注解？
闭包中，怎么对数字、字符串、元组等不可变元素更新。
分别根据每一行的首元素和尾元素大小对二维列表 a = [[6, 5], [3, 7], [2, 8]] 排序。(利用lambda表达式)
利用python解决汉诺塔问题？
有a、b、c三根柱子，在a柱子上从下往上按照大小顺序摞着64片圆盘，把圆盘从下面开始按大小顺序重新摆放在c柱子上，尝试用函数来模拟解决的过程。（提示：将问题简化为已经成功地将a柱上面的63个盘子移到了b柱）