欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python学习笔记:第14天 内置函数补充和递归

程序员文章站 2022-05-25 16:59:02
一、匿名函数 匿名函数主要是为了解决一些简单需求而设计的一种函数,匿名函数的语法为: lambda 形参: 返回值 先来看一个例子: 使用匿名函数需要注意的几点: 函数的参数可以有多个,多个参数之间⽤逗号隔开 匿名函数不管多复杂. 只能写⼀⾏, 且逻辑结束后直接返回数据 返回值和正常的函数⼀样, 可 ......

一、匿名函数

匿名函数主要是为了解决一些简单需求而设计的一种函数,匿名函数的语法为:

lambda 形参: 返回值

先来看一个例子:

# 计算n的n次方
in[2]: lst = lambda n: n ** n         # 这里的lst就是一个匿名函数
in[3]: print(lst(3))
27

使用匿名函数需要注意的几点:

  • 函数的参数可以有多个,多个参数之间⽤逗号隔开
  • 匿名函数不管多复杂. 只能写⼀⾏, 且逻辑结束后直接返回数据
  • 返回值和正常的函数⼀样, 可以是任意数据类型

二、内置函数补充

sorted

sorted是python内置的一个用于排序的函数,它接收三个参数,语法为;

sorted(iterable, key=none, reverse=false)
  • iterable: 接收一个可迭代对象,sorted内部会去循环可迭代对象取出元素
  • key: 排序规则(排序函数),sorted将每次从可迭代对象中取出的数据会传递给这个排序函数的参数,根据函数运算的结果进行排序
  • reverse: 控住是否倒叙,true为倒叙,默认为false正序
# 根据字符串⻓度进⾏排序
in[7]: lst = ["麻花藤", "冈本次郎", "*情报局", "狐仙"]
in[8]: lst2 = sorted(lst, key=lambda s: len(s))
in[9]: print(lst2)
['狐仙', '麻花藤', '冈本次郎', '*情报局']

sorted如果不传作排序用的函数,那么它默认是按照在字符编码中的顺序来排的:

in[10]: lst = ["麻花藤", "冈本次郎", "*情报局", "狐仙"]
in[11]: lst2 = sorted(lst)
in[12]: lst2
out[12]: ['*情报局', '冈本次郎', '狐仙', '麻花藤']
in[14]: print(ord('中'))
20013
in[15]: print(ord('冈'))
20872
in[16]: print(ord('狐'))
29392
in[17]: print(ord('麻'))
40635

filter

filter是python中内置的一个过滤的函数,其用法跟sorted差不多:

filter(function, iterable)
  • function: ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后
    根据function返回的true或者false来判断是否保留此项数据
  • iterable: 可迭代对象
in[21]: lst = [{'id':1,'name':'alex','age':28},
   ...: {'id':2,'name':'taibai','age':58},
   ...: {'id':3,'name':'taihei','age':18},
   ...: {'id':4,'name':'henhei','age':38}]

in[22]: ret2 = filter(lambda x: x['age'] >= 38, lst)
   ...: [print(x) for x in ret2]
{'id': 2, 'name': 'taibai', 'age': 58}                # 从结果来看,年龄小于38的都被过滤掉了
{'id': 4, 'name': 'henhei', 'age': 38}

out[22]: [none, none]

map

映射函数map,使用语法为:

map(function, iterable)

可以对可迭代对象中的每⼀个元素进⾏映射. 分别取执⾏function(其语法和sorted、filter相似)

in[23]: names=['oldboy','alex','wusir']

in[24]: m = map(lambda s: s + '123', names)           # 在每个字符串后加上123

in[25]: print(list(m))                                # map返回的也是一个可迭代对象,使用list会去循环遍历元素
['oldboy123', 'alex123', 'wusir123']

三、递归

在函数中调⽤函数本⾝. 就是递归

def func():
  print("我是谁")
  func()

func()

在python中最大递归深度为1000:

in[26]: import sys

in[27]: sys.getrecursionlimit()           # 虽然我们查询到的结果是1000,但是实际上却跑不到1000,通常是998或者997
out[27]: 1000

递归的应用:计算斐波那契数列 f(0) = 1 f(1) = 1 f(n) = f(n-1) + f(n-2)

in[35]: def fib(n):
   ...:     if n == 0:
   ...:         return 1
   ...:     if n == 1:
   ...:         return 1
   ...:     return fib(n-1) + fib(n-2)
   ...: 

in[36]: fib(5)
out[36]: 8

in[37]: fib(10)
out[37]: 89

总结:

  • 递归函数总是涉及到压栈和出栈的过程
  • 递归函数总是压栈,知道遇到退出条件,然后出栈
  • python中递归函数有深度限制,可以通过sys.getrecursionlimit()得到深度限制,可以通过sys.setrecursionlimit调整递归深度限制
  • 递归函数在python非常慢,并且有深度限制,所以 因尽量避免使用递归

四、二分法查找

⼆分查找. 每次能够排除掉⼀半的数据. 查找的效率非常⾼. 但是局限性比较⼤. 必须是有
序序列才可以使⽤⼆分查找

  • 要求: 查找的序列必须是有序序列

(1) 使用基本的算法实现:

lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

n = int(input("请输入一个数字n:"))      # 56

left = 0                              # 左边界
right = len(lst) - 1                  # 末尾的索引  右边界
while left <= right:                  # 当左边界大于右边界结束循环

    mid = (left + right) // 2         # 求中间的索引坐标
    if n < lst[mid]:                  # 判断你的数字和中间数的大小比较 .
        right = mid - 1               #  右边界往左移动

    elif n > lst[mid]:
        left = mid + 1                # 左边界往右移动

    else:
        print("找到了")               # 找到了目标数字
        break
else:                                 # 当左比右大, 循环结束. 没有找到目标数
    print("没找到")

(2)使用递归实现:

lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

def binary_search(lst, n, left, right):
    if left > right:
        return false
    mid = (left + right) // 2
    if n > lst[mid]:
        left = mid + 1
        # 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
        return binary_search(lst, n, left, right)
    elif n < lst[mid]:
        right = mid - 1
        return binary_search(lst, n, left, right)
    else:
        print("找到了")
        return true

n = int(input("请输入一个数字n:")) # 178
ret = binary_search(lst, n, 0, len(lst)-1)
print(ret)

# 结果:
# 请输入一个数字n:178
# 找到了
# true

切记:当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值

(3)对列表切片:

def binary_search(lst, n):
    if len(lst) == 0:
        return false
    left = 0
    right = len(lst) - 1
    mid = (left + right) // 2
    if n > lst[mid]:
        left = mid + 1
        # 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
        return binary_search(lst[mid+1:], n)
    elif n < lst[mid]:
        right = mid - 1
        return binary_search(lst[:mid], n)
    else:
        print("找到了")
        return true