Python学习：函数- Python

写在 def 语句中函数名后面的变量叫做函数的形参，调用函数的时候提供的值是实参

文章目录

一、函数基本知识

函数文档
描述该函数的功能，写给别人看的。

# 函数文档字符串功能和注释功能一样
def exchangeRate(dollar):
    """美元->人民币
    汇率暂定6.5"""
    return dollar * 6.5
# 函数的文档字符串可以通过特殊属性__doc__获取
exchangeRate.__doc__
# '美元->人民币\n    汇率暂定6.5'
# 也可以通过help()函数查看
help(exchangeRate)

收集参数
当不知道函数需要多少个参数时，可以在参数前面加上星号（*）
星号的意思就是“收集多余的参数”

#如果参数中有收集参数，需要将其他参数设置为默认参数
def test(*params,extra):
    print('收集的参数时：',params)
    print('位置参数是：',extra)
test(1,2,3,4,5,extra = 8)
收集的参数是： (1, 2, 3, 4, 5)
位置参数是： 8
1
2
3
4
5
6
7

#星号（*）可以打包，也可以解包
def test(*params):
    print('有%d个参数' % len(params))
    print('第二个参数是：',params[1])
# a = [1,2,3,4,5,6]
test(*a)	#a前面加个星号（*）表示解包
# 输出结果：
有6个参数
第二个参数是： 2
1
2
3
4
5
6
7
8
9

Python还有另外一种收集方式，就是用两个星号（**）表示，两个星号的收集参数表示打包成字典的形式。

#字典形式的打包
def test(** parms):		#两个星号的收集参数表示将参数打包成字典的形式，当参数带（**）时，传递给函数的任意个key=values实参会被打包成一个字典中
	print('有 %d 个参数'% len(parms))
	print("它们为：",parms)
test(a=1,b=2,c=3)
#有 3 个参数，它们为： {'c': 3, 'b': 2, 'a': 1}
#解包
def test(** parms):
    print('有%d个参数' % len(parms))
    print('它们为：', parms)

dict1 = dict(a = 1,b = 2,c = 3,d = 4)
test(** dict1)
# 有4个参数，它们为： {'d': 4, 'b': 2, 'c': 3, 'a': 1}
1112
13
14

二、闭包

global关键字：声明为全局变量

# 在函数中修改全局变量
# count = 5
def Myfun():
    global count
    count = 10
    print(count)
# count = 10
1
2
3
4
5
6
7

闭包

def FunX(x):
    def FunY(y):
        print('x = %d' % x)
        print('y = %d' % y)
        return x*y
    return FunY
1
2
3
4
5
6

如果在一个内部函数里（FunY就是这个内部函数）对外部作用域（但不是在全局作用域）的变量进行引用（x就是被引用的变量，x在外部作用域FunX函数里，但不在全局作用域里），则这个内部函数（FunY）就是一个闭包。

#调用方法
FunX(4)(5)
# 20
#或者：
i = FunX(4)
i(5)
1
2
3
4
5
6

三、lambda /filter /map 函数

lambda关键字创建匿名函数，省下定义函数的过程，简化代码

g = lambda x，y :y * x +1
g(3,4)
#上述定义式等价于
 def ds(x):
	return 2*x +1
1
2
3
4
5

filter( )内建函数又称为过滤器
格式：filter（function or none，iterable）
函数里面有两个参数，第一个参数可以为函数 function 还可以为none空。如果第一个参数为函数，那么就将第二个可迭代数据里的每一个元素作为函数的参数进行运算，最后将返回的TRUE值筛选出来；如果第一个参数为空，则直接把第二个参数中的TRUE值筛选出来。

#如果第一个参数为空
temp = filter(None,[1,0,False,True])
list(temp)   #结果值[1, True]
#如果第一个参数为函数
def odd(x):
	return (x)%2
temp = filter(odd,range(20))
list(temp) #	筛选奇数[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
#结合lambda（）函数
list(filter(lambda x: (x)%2,range(20)))
# 结果值[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
11

map()
map()函数，“映射”的意思，里面仍有两个参数，将第二个序列中的每一个元素作为这个函数的参数加工运算，直到所有的元素加工完毕

list(map(lambda x: (x+1),range(10)))
# 结果值[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1
2

四、递归

递归，自己调用自己

# 求n的阶乘
def fun(x):
    if (x==1):
        return 1
    else:
        return x*fun(x-1)
# 求斐波那契数列
def fun(x):
    if x==1 or x==2:
        return x
    else:
        return fun(x-1)+fun(x-2)
# 求汉诺塔
def hanoi(n,x,y,z):
    if(n==1):
        print(x,'--->',z)
    else:
        hanoi(n-1,x,z,y)	#将前n-1个盘子借助z，由x移动到y 
        print(x,'--->',z)
        hanoi(n-1,y,x,z)
n = int(input("请输入汉诺塔层数："))
hanoi(n,'X','Y','Z')
1112
13
14
15
16
17
18
19
20
21
22