9.函数的关键字参数
关键字参数允许传入含参数名的参数，在函数内部自动组装为一个dict,意思就是，
不定长参数没参数名！访问参数得遍历。而关键字参数也是不定长参数，只不过给每个参数起名了！所以键值对！dict！
def person(name,age,**kw):
print("name:",name,"age:",age,"other",kw);
person('Bob',15,city="Xian");
extra = {'city': 'Beijing', 'job': 'Engineer'};
person('Jack', 24, **extra);
10.函数的命名关键字参数
不定长参数需要遍历序列访问，为了方便调用参数给每个参数起名，从而诞生了关键字参数
关键字参数如果过多就会产生冗余，则以指定参数名限定关键字参数的个数，从而 诞生命名关键字参数
传参时必须写参数名
命名关键字参数可以有默认值
def person(name,age,*,city,job):
print(name,age,city,job);
若有可变参数
def person(name,age,*args,city,job):
print(name,age,args,city,job);
注意：综合一下，看看什么结果
def fun(a, b, *args, **kwargs):
print("a =", a )
print("b =", b)
print("args =", args)
print("kwargs: ")
for key, value in kwargs.items():
print(key, "=", value)
fun(1, 2, 3, 4, 5, m=6, n=7, p=8)
c = (3, 4, 5)
d = {"m":6, "n":7, "p":8}
fun(1, 2, *c, **d)
fun(1,2,c,d);
11.函数的递归
如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。 举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n
如何打印斐波那契数列呢？
'''
n的阶乘
0！=1
1！=1
2！=2*1
3！=3*2*1
4！=4*3*2*1
foc(5)=5*foc(4)
foc(4)=4*foc(3)
...
foc(1)=1
'''
def foc():
if n==1:
return 1
else:
return n*foc(n-1)
print(foc(10))
# 1 1 2 3 5 8 13 21 34 55
'''
feibo(1)=1
feibo(2)=1
feibo(3)=feibo(2)+feibo(1)
feibo(4)=feibo(3)+feibo(2)+feibo(1)
=1+1+1
feibo(7)=feibo(6)+feibo(5)
=...
...
feibo(n)=feibo(n-1)+feibo(n-2)
'''
def feibo(n):
if n==1 or n==2:
return 1
else:
return feibo(n-1)+feibo(n-2)
print(feibo(5))
print("")
for i in range(1,100):
print(feibo(i))
#时间复杂度：代码的执行次数有关 12.匿名函数
首先，在python中函数名其实也是变量名！
abs(-10) # 10
f=abs f(-10) #10
abs=10
abs(-10) #错误！
函数本身也可以赋值给变量，变量可以指向函数！
def add(x,y,f):
return f(x)+f(y)
add(-5,6,abs);
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下实例：
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print（"Value of total : ", sum( 10, 20 )）
print（"Value of total : ", sum( 20, 20 )） 注意：
lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print，因为lambda需要一个表达式
应用场合：函数作为参数传递
（1）自定义函数
def fun(a, b, opt):
print（"a =", a）
print（"b =", b）
print（"result =", opt(a, b)）
fun(1, 2, lambda x,y:x+y) （2）作为内置函数的参数
stus = [
{"name":"zhangsan", "age":18},
{"name":"lisi", "age":19},
{"name":"wangwu", "age":17}
]
stus.sort(key = lambda x:x['name'])
举个栗子：
def addCharToInt(c1,c2,c3):
print(c3(c1)+c3(c2))
addCharToInt("a","b",ord)
myfunc=lambda x1,x2=2:x1**x2 #冒号后面为返回值
print(myfunc(3,4))
addCharToInt(3,4,myfunc)
#myfunc2=lambda x1,x2:if x1%2==0 x1*x2 有错误
myfunc2(2,2)
myfunc2(3,2)
list=[x for x in range(10) if x%2==0]
print(list)
13.高阶函数
13.1Map函数
接收两个参数，一个是函数，一个是Iterable
将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
#Map 得到一个序列
def func(x):
return x**2
l=[1,2,3,4,5,6]
result=list(map(func,1)) #遍历该集合，并**2
print(result)13.2Reduce函数
接收两个参数，一个函数，一个是Iterable
把前两个的元素的计算结果继续和序列的下一个元素做累积计算，其效果就是
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
#Reduce 是一种叠积算法
l=[1,3,5,7,9]
'''
1*10+3=13
13*10+5=135
135*10+7=1357
1357*10+9=13579
x1*10+x2
'''
#import random 代表导入工具箱，从工具箱里面取工具
from functools import reduce # functools.reduce 是工具
def func2(x1,x2)：
return x1*10+x2
l=[1,3,5,7,9]
num=reduce(func2,l)
print(num)
#from functools import reduce
l=["9","2","3","1","4","8",]
#923148
num=reduce(func2,list(map(int,l)))
print(num)
13.3Filter函数
filter把传入的函数依次作用于每个元素，然后根据返回值是True或False决定保留还是丢弃该 元素。
比如：删偶数留奇数
#Filter
l=[1,2,3,4,5,6,7,8,9]
def func3(x3):
retrun x%2==0 #True 保留
result=list(filter(func3,l))
return(result)13.4Sorted函数
内置排序函数
sorted(list,key=abs)
对字符串比较默认ASCII码顺序比较
sorted(list,key=str.lower(),reverse=True)
s="sjsjbcg23swd22vnkn67vcdkjksf7"
num=reduce(func2,list(map(int,list(filter(str.isdigit,list(s))))))
print(num)
l=list(map(int,list(filter(str.isdigit,list(s)))))
print(l)
s="ASHUhsccsncufjeijk"
l=sorted(s,key=str.upper)
#排序按照大写或者小写字母排序，也就是忽略大小写 如果不指定，按照ASCII 大写在前，小写在后
print(l)