Python 函数3

最新推荐文章于 2024-10-11 17:30:36 发布

what-and-why

最新推荐文章于 2024-10-11 17:30:36 发布

阅读量117

点赞数

文章标签： python 递归法

本文链接：https://blog.csdn.net/qq_41613855/article/details/115115387

版权

函数3

函数的递归

本质就是自己调用自己
关键是要知道什么时候停止或者继续递归的条件

核心是知道递归公式

count=0
def tell_story():
    global count        #声明是全局变量
    count+=1
    print('从前有座山')
    print('山上里有座庙')
    print('庙里有一个老和尚')
    print('还有一个小和尚')
    print('老和尚在给小和尚讲故事')
    print('故事的内容是')
    if count<5:          #规定递归条件
        tell_story()     #调用自己

tell_story()

#使用递归求前n项的和
def get_sum(n):
    if n==0:
        return 0             #规定了停止的条件
    return get_sum(n-1)+n    #递归公式，当可以返回具体值的时候，就不在递归
print(get_sum(100))

#使用递归求斐波那契数列的第n个数
def a(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    return a(n-1)+a(n-2)
print(a(12))

匿名函数：没有名字的函数

除了使用关键字def定义一个函数我们还可以使用关键字lambda定义一个匿名函数
格式 lambda 参数 : 语句
关于匿名函数的调用
- 给匿名函数起一个名字（不常用）
- 将匿名函数作为参数传递给另一个函数

将函数作为一个参数传递给另一个函数

lambda x,y:x*y
mu=lambda x,y:x*y   #给函数起一个名字，如果函数已经有名字，就相当于起了一个别名
print(mu(4, 5))




#要求用户输入，指定的参数，对两个数做加减乘除
#将函数作为一个参数传递给另一个函数
# def add(a,b):
#     return a+b
# def minus(a,b):
#     return a-b
# def plus(a,b):
#     return a*b
# def chu(a,b):
#     return a/b
# print(cac(5, 6, add))
# print(cac(12,13,minus))
# print(cac(6,2,chu))
# print(cac(4,5,plus))


#可以直接将将匿名函数作为参数传递给另一个函数
a=3
b=2
cac(a,b,lambda a,b:a+b)
cac(a,b,lambda a,b:a-b)
cac(a,b,lambda a,b:a*b)
cac(a,b,lambda a,b:a/b)

sort方法的使用

sort是将原来的列表直接排序，sorted函数是排序完，返回一个新列表
字典不支持比较运算
使用sort方法可以给可迭代对象排序，但不支持直接给字典排序,需要给出比较规则
可以通过key给出比较规则
sort方法在调用key得到的函数时，需要调用这个函数返回的一个参数

key对应的函数需要是有一个返回值的函数

students=[{'name':'zhangsan','age':26,'tel':'15895898270','sex':'male','score':100},
         {'name':'Jack','age':12,'tel':'15895812345','sex':'female','score':99},
         {'name':'Marry','age':17,'tel':'15895888888','sex':'female','score':100},
]
# students.sort()  #会报错
# print(students)  

def foo(ele):
    return ele['age']    #定义了一个返回值函数，
#students.sort(key=foo)   # 告诉我们需要按照“age”进行排序
students.sort(key=lambda ele:ele['age']) #因为函数简单，所以可以用匿名函数写
print(students)

filter内置类：是过滤器，过滤掉一些元素

需要两个参数，第一个是函数，第二个是可迭代对象
函数遍历可迭代对象中的元素，返回bool值，如果True就保留，如果是False就会被过滤掉

最终返回一个filter类型的数据，是一个可迭代对象

age=[12,19,13,30,25,24,26,28,31,17]
def foo(ele):
        return ele%2==0
filter(foo, age) #直接按照函数过滤掉一些元素，并返回这个列表
print(filter(foo, age))
print(list(filter(foo, age)))

#result
<filter object at 0x00000000024EC5C8>
[12, 30, 24, 26, 28]

map内置类：对可迭代对象里面的每个元素都操作一下
- 需要两个参数，第一个是函数，第二个是可迭代对象
- 将可迭代对象中的每一个元素都执行一下函数，然后返回新的值
- 返回的是一个map的类型的数据，是一个可迭代对象
```
age=[12,19,13,30,25,24,26,28,31,17]
def foo(ele):
    return ele+3
#print(type(map(foo, age)))
x=map(foo,age)
print(x)
print(list(x))

#result
<map object at 0x00000000024BC6C8>
[15, 22, 16, 33, 28, 27, 29, 31, 34, 20]
```

reduce：需要导入模块 from functools import reduce

需要两个参数：第一个是需要有两个参数的函数，第二个是一个可迭代对象

将可迭代的对象的的前两个元素作为参数执行函数，得到的结果作为第一个参数，而可迭代对象的下一个元素作为第二个参数，再执行函数，…依次类推，直到遍历完可迭代对象.可以给第一个参数设置初始值

from functools import reduce
age=[1,2,3,4,5,6,7]
def add(x,y):
    return x+y
print(reduce(add, age))
students=[{'name':'zhangsan','age':26,'tel':'15895898270','sex':'male','score':100},
         {'name':'Jack','age':12,'tel':'15895812345','sex':'female','score':99},
         {'name':'Marry','age':17,'tel':'15895888888','sex':'female','score':100},
         ]
# def add_age(x,y):      #会报错，因为在完成第一个操作后，x已经变成了一个数字了不再是字典
#     return x['age']+y['age']
# reduce(add,students)
#添加一个初始值
def add_age(x,y):
    return x+y['age']

print(reduce(add_age, students,0))   #设置x的值永远是0

高阶函数

函数作为另一个函数的参数

函数作为另一个函数的返回值

函数作为另一个函数的返回值
#3.函数里面在定义一个函数
def test():
    print('hello')
    return test        #返回的是test这个函数，但不调用
    #return test()     #返回会继续调用test这个函数

def demo():
    print('nihao')
    return test       #返回的是test这个函数，但不调用
x=test()
print(x)
demo()
print('--------')
demo()()             #demo()返回了test，再加一个()就相当于调用了test

#reslut
hello
<function test at 0x00000000024F5EE8>
nihao
--------
nihao
hello

函数里面在定义一个函数

这个时候里面的函数时不能被函数外识别的
利用nonlocal在内函数里面修改局部变量

def test():
    print('hello')
    def demo():
        print('world')
    return demo()
#demo()  #会报错
test()

#
def outer():
    print('我是outer函数')
    x=10                   #在函数内部定义了一个局部变量
    def inner():
        print('我是inner函数')
        #nonlocal x       #声明x就是inner函数外部的局部变量x
        x=20              #这不是修改局部变量x，而是在inner函数里又创建了一个新的变量
        y=x+1
        print(y)
        print('inner函数内的地址ox%X'%id(x))

    print('inner函数外的地址ox%X'%id(x))
    return inner
outer()()
#result
我是outer函数
inner函数外的地址ox7FEE1257230
我是inner函数
21
inner函数内的地址ox7FEE1257370