#3**5=3*3**4
def fn(n,i):
'''
该函数用户计算任意数字的幂运算
'''
if i==1:
return n
return n* fn(n,i-1)
print(fn(10,2))
#方法一:
def fn(a):
'''
判断一个字符串是否是回文字符串abcdcba
'''
if len(a)==1:
return True
elif a[0]!=a[-1]:
return False
#递归条件
return fn(a[1:-1])
print(fn('asdfdsa'))
#方法二
def fn(a):
'''
判断一个字符串是否是回文字符串abcdcba
'''
if len(a)==1:
return True
v=len(a)
for j in range(v//2):
if a[0+j]!=a[-1-j]:
return False
else:
return True
print(fn('a'))
高阶函数:
接受函数作为参数或者将函数作为返回值返回
可以直接向函数中传代码
b=[1,2,3,4,5,6]
def fn(*l):
new=[]
for a in l:
if a%2==0:
new.append(a)
return new
print(fn(2,3,4,5,6))
#方法1
def rule1(n):
if n%2==0:
return True
def rule2(n):
if n%2!=0:
return True
def fn(*l):
new=[]
for a in l:
if rule2(a):
new.append(a)
return new
print(fn(2,3,4,5,6))
#方法2
def rule1(n):
if n%2==0:
return True
def rule2(n):
if n%2!=0:
return True
b=[1,2,3,4,5,6,7]
def fn(func,l):
new=[]
for a in l:
if func(a):
new.append(a)
return new
print(fn(rule2,b))
匿名函数:
filter()——对从序列中过滤出符合条件的元素,保存到新的序列中
参数:
1. 函数,根据该函数来过滤序列(可迭代的结构)
2. 需要过滤的序列(可迭代的结构)
返回值——过滤后的新序列
def rule2(n):
if n%2!=0:
return True
b=[1,2,3,4,5,6]
r=filter(rule2,b)
print( list(r))
rule2 是作为参数传递进入filter()函数中
而实际上rules只有一个作用就是做为filter的参数
filter()调用完毕以后,rule2就已经没有用了,还是定义在全局中的也就是不能再有函数叫rule2
匿名函数:
lambda函数表达式专门用来创建一些简单的函数,他是函数创建的又一种方式
语法:lambda 参数列表:返回值
map()——函数可以对可迭代对象中的所有元素做指定的操作,然后将其添加到一个新的对象中返回
语法;
print((lambda c,d:c+d)(10,20))
l=[2,3,4,6,7,8,9]
r=filter(lambda a:a%2==0,l)
print(list(r))
#map()对序列中的元素进行操作
r=map(lambda a:a%2,l)
print(list(r))
sort()——该方法用于对列表中的元素进行排序
l.sort()
在sort()中可以接收一个关键字参数,key,key需要一个函数作为参数
当设置函数作为参数,每次都会以列表中的一个元素作为参数来调用函数,并使用函数的返回值来比较元素的大小
l=['bb','aaaa','ddd','c']
l.sort()
print(l)
#比较元素的长度
l.sort(key=len)
print(l)
sorted()
这个函数和sort()的用法基本一样,但是sorted()可以对任一序列进行排序
并且sorted()排序不会影响原来的对象,而是返回一个新的对象
l='2347380281730342'
print('排序前',l)
print(sorted(l))
print('排序后',l)
将函数作为返回值返回的高阶函数
这种高阶函数我们也称为闭包,通过闭包可以创建一些只能有当前函数能访问的变量
def fn(a):
sum=a
#在函数内部定义一个函数
def fn2():
b=sum+1
print(b)
return fn2
r=fn(10)
r()
#r是一个函数,是调用fn()后返回的函数
#这个函数是在fn()内部定义,并不是全局函数
#所以这个函数总是能访问到f函数内的变量
#求多个数的平均值
num=[]
def average(*n):
#将n添加到列表中
num=n
#求平均值
return sum(num)/len(num)
print(average(10,20,30))
#2
num=[]
def average(n):
#将n添加到列表中
num.append(n)
#求平均值
return sum(num)/len(num)
print(average(10))
#每打印一次增加一个元素
print(average(20))
#创建闭包
def make_average():
num=[]
def average(n):
#将n添加到列表中
num.append(n)
#求平均值
return sum(num)/len(num)
return average
result=make_average()
print(result(100))
怎么形成闭包:
函数嵌套
内部函数作为返回值返回
内部函数必须要使用到外部函数的变量
#定义一个函数,可以用来求任意三个数的乘积
def fn(*n):
result=1
for i in n:
result*=i
print(result)
fn(1,2,3)
#递归——回文
ef huiwen(s):
if len(s)<2:
return True
elif s[0] != s[-1]:
return False
return huiwen(s[1:-1])
result=huiwen('asdds')
print(result)
装饰器
def add(a,b):
return print(a+b)
add(1,2)
def fn2():
print('I am fn2')
fn2()
#以下两个函数被写死了
def begin_end():
'''
用来对其他函数进行扩展,是其他函数可以在执行前打印开始执行,执行后打印执行结束
'''
def fn():
print('开始执行')
fn2()
print('执行结束')
return fn
r=begin_end()
r()
def begin_end():
'''
用来对其他函数进行扩展,是其他函数可以在执行前打印开始执行,执行后打印执行结束
'''
def fn(a,b):
print('开始执行')
add(a,b)
print('执行结束')
return fn
r=begin_end()
r(1,2)
#用old代表传的参数
def begin_end(old):
'''
用来对其他函数进行扩展,是其他函数可以在执行前打印开始执行,执行后打印执行结束
参数old 是要扩展的函数对象
'''
def fn(a,b):
print('开始执行')
old(a,b)
print('执行结束')
return fn
r=begin_end(add)
r(1,2)
#像begin_end这种函数就是装饰器,通过装饰器可以在不修改原来
def begin_end(old):
'''
用来对其他函数进行扩展,是其他函数可以在执行前打印开始执行,执行后打印执行结束
参数old 是要扩展的函数对象
'''
def fn(*a):
print('开始执行')
old(*a)
print('执行结束')
return fn
r=begin_end(add)
r(100,200)
#在定义函数时,可以通过@装饰器,来使用指定的装饰器,来装饰当前的函数,可以为一个函数来指定多个装饰器
def zhuangshi(new):
def fn3(*a):
print('hello')
new(*a)
print('bye')
return fn3
@zhuangshi
@begin_end
def say():
return print('hello world')
say()
@zhuangshi
@begin_end
def add(a,b):
return print(a+b)
add(1,2)