python-函数 递归函数，内置函数和匿名函数

 

目录

1.递归函数

（1）使用递归函数向控制台打印3,2,1

（2）：计算1到10的乘阶：例如 1*2*3*4*5...*10。

（3）：查找数字：通过程序查找输入的number值。

2.内置函数

（1）.abs函数

（2）.max函数

1.简单的max(最大值对比)

2.使用key关键字

3.根据name 返回最大的信息值

（4）map函数

（5）filter函数

（6）zip函数

3.匿名函数

（1）创建函数

（2）给定一个列表，求列表中绝对值最大的数

（3）现有两个元组(('a'),('b')),(('c'),('d'))，请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

 

---

---

1.递归函数

如果一个函数在内部调用自身本身，这个函数就是递归函数。

在使用递归时，需要注意以下几点：

(1).自己调用自己。

(2).必须有一个明确的递归结束条件，称为递归出口。

（1）使用递归函数向控制台打印3,2,1

def print_num(num):
    print(num)
    if num==1:
        return
    print_num(num-1)
print_num(3)

输出结果如下：

如果是递归函数：用画图是非常方便的！！！！

由上图可知，当num没有满足等于1时会返回进入程序，但当num等于1后，会返回程序，然后得出结果。

（2）：计算1到10的乘阶：例如 1*2*3*4*5...*10。

def print_num(num):
    print(num)
    if num==1:
        return
    print_num(num-1)
print_num(3)

如果不会就画图！！！

（3）：查找数字：通过程序查找输入的number值。

def erfenfa(num,start,end):

    if num==start:
        return start
    elif num==end:
        return end
    else:
        middle = (start+end)//2

        if num<middle:

            return erfenfa(num,start,middle)
        else:

            return erfenfa(num,middle,end)

print(erfenfa(20,1,100))

二分法最快找到数字

思路：1.输入一个需要查找的数

           2.把范围类的最大值（max）和最小值（min）相加然后地板除得到数num，和需要查找的数进行比较，如果小了，替换min，然后范围变成（num，max）反之亦然！

           3.就这样反复比较，得到最终值

2.内置函数

（1）.abs函数

a = -1
b = abs(a)
print(b)

这个函数非常简单，就是把内容取绝对值，放入的需要是整型或者浮点型。

结果如下：

（2）.max函数

max函数的基本结构max（可迭代的对象，key，default）

1.简单的max(最大值对比)

ret=max(1,2,3)
print(ret)

结果显示如下：

2.使用key关键字

   key = 函数名称 ——————》指定规则

def jdz(x):   #自定义一个可迭代的函数，小于0取相反数
    if x<0:
        x = -x
    return x
ret=max(1,2,-5,key=jdz)
print(ret)

1.我们先定义一个函数，jdz函数的作用是把负数变成正数。

2.然后我们看max内置函数的结构max(可迭代对象=1,2，-5，key(设定规则)=函数名称)

3.输出如下：

 

3.根据name 返回最大的信息值

lst = [{'name':'你好'},
       {'name':'嘻嘻'}]
def aa(x):
    return x['name']
ret = max(lst,key=aa)
print(ret)

1，函数返回键值

2.max判断的是第一个数字的第一个字母的ascll码，谁大取谁，如果一样，就比第二个字母，照着推。

（4）map函数

有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容
函数会依次作用在可迭代的每个内容上，返回一个新的可迭代内容

求lst中的每个元素的平方值

def aa(x):
    return x*x
lst=[1,2,3]
ret = map(aa,lst)
print(list(ret))

结果如下：

（5）filter函数

用于过滤序列！！！，必须是有顺序的，过滤掉不符合规范的元素，然后返回
复合条件的元素组成的新元素
接受两个参数，第一个是函数，第二个是序列

过滤掉所有奇数

lst = [1,2,5,4,5,5,7]
def odd(x):
    if x % 2==1:
        return True

ret = filter(odd,lst)
print(list(ret))

结果如下：

（6）zip函数

zip函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,

然后返回一个可迭代的zip对象.这个可迭代对象可以使用循环的方式列出其元素

若多个可迭代对象的长度不一致,则所返回的列表与长度最短的可迭代对象相同。

a = [1,2,3,4,5]
b = (1,2,3,4,5)
ret= zip(a,b)
print(list(ret))

结果如下：（ZIP中的两个必须都是可迭代对象）

3.匿名函数

格式：
变量名称=lambda 参数:表达式

注意事项
不能包含return
可以包含if else

（1）创建函数

创建无参数的匿名函数：

func = lambda:3>2
print(func())

按照基本格式来写：结果如下：（3>2）是返回true

 

创建有参数的匿名函数：

func = lambda x,y:x+y
print(func(2,3))

结果显示如下：

（2）给定一个列表，求列表中绝对值最大的数

a = [1，2，3，-4]

如果用普通方法的话，我们这里可以用到max函数

dic =[1,2,3,-4]
def aa(x):
    if x <0:
        return -x
    else:
        return x

ret = max(dic,key=aa)
print(ret)

结果显示是-4

如果用匿名函数的话：

ret = max(dic,key=lambda a:-a if a < 0 else a)
print(ret)

（3）现有两个元组(('a'),('b')),(('c'),('d'))，请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

a = (('a'),('b'))
b = (('c'),('d'))
c =list(map(lambda t:{t[0]:t[1]},zip(a,b)))
print(c)