2021-07-10

#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)