Python匿名函数/排序函数/过滤函数/映射函数/递归/二分法

一. lamda匿名函数
  为了解决一些简单的需求而设计的一句话函数

# 计算n的n次方
def func(n):
    return n**n
print(func(10))
f = lambda n: n**n
print(f(10))

  lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数

  语法:
    函数名 = lambda 参数: 返回值

  注意:

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

  匿名函数并不是说一定没有名字. 这里前面的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的. 统一都叫lambda. 在调用的时候没有什么特别之处.像正常的函数调用即可

二. sorted() 排序函数
  语法: sorted(Iterable, key=None, reverse=False)

    Iterable: 可迭代对象

    key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序

    reverse: 是否是倒叙. True: 倒叙, False: 正序

lst = [1,5,3,4,6]
lst2 = sorted(lst)
print(lst) # 原列表不会改变
print(lst2) # 返回的新列表是经过排序的
dic = {1:‘A‘, 3:‘C‘, 2:‘B‘}
print(sorted(dic)) # 如果是字典. 则返回排序过后的key

  和函数组合使用

# 根据字符串长度进行排序
lst = ["鲁班七号", "程咬金", "安琪拉", "阿珂"]
# 计算字符串长度
def func(s):
    return len(s)
print(sorted(lst, key=func))

  和lambda组合使用

# 根据字符串长度进行排序
lst = ["鲁班七号", "程咬金", "安琪拉", "阿珂"]
# 计算字符串长度
def func(s):
    return len(s)
print(sorted(lst, key=lambda s: len(s)))
lst = [{"id":1, "name":‘鲁班‘, "age":28},
       {"id":2, "name":‘安琪拉‘, "age":16},
       {"id":3, "name":‘阿珂‘, "age":25}]
# 按照年龄对信息进行排序
print(sorted(lst, key=lambda e: e[‘age‘]))

三. filter() 筛选函数

  语法: filter(function. Iterable)

    function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留此项数据

4. map() 映射函数

    Iterable: 可迭代对象

lst = [1,2,3,4,5,6,7]
ll = filter(lambda x: x%2==0, lst) # 筛选所有的偶数
print(ll)
print(list(ll))
lst = [{"id":1, "name":‘鲁班‘, "age":18},
       {"id":2, "name":‘安琪拉‘, "age":16},
       {"id":3, "name":‘阿珂‘, "age":17}]
fl = filter(lambda e: e[‘age‘] > 16, lst) # 筛选年龄大于16的数据
print(list(fl))        

四. map() 映射函数

  语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别取执行function

  计算列表中每个元素的平方,返回新列表

def func(e):
    return e*e
mp = map(func, [1, 2, 3, 4, 5])
print(mp)
print(list(mp))

  改写成lambda

print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))

  计算两个列表中相同位置的数据的和

# 计算两个列表相同位置的数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)))

五. 递归

  在函数中调用函数本身,就是递归

def func():
    print("我是递归")
    func()
func()

  在python中递归的深度最大到998

def foo(n):
    print(n)
    n += 1
    foo(n)
foo(1)   
递归的应用:  我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使用递归来遍历该文件夹中的所有文件
import os
def func(filepath,n):
    files = os.listdir(filepath)    # 查案当前文件的目录
    for file in files:  # 获取每一个文件名
        # 获取文件路径
        file_p = os.path.join(filepath,file)
        if os.path.isdir(file_p):   # 判断file是否是一个文件夹
            print("\t"*n,file)
            func(file_p,n+1)
        else:
            print("\t"*n,file)
func("/Volumes/扩展盘/网站css",0)

六. 二分查找

  二分查找. 每次能够排除掉一半的数据. 查找的效率非常高. 但是局限性比较大. 必须是有序序列才可以使用二分查找

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

# 判断n是否在lst中出现. 如果出现请返回n所在的位置
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
# 非递归算法
# 使用二分法可以提高效率   前提条件有序序列
n = 88
left = 0
right = len(lst) - 1

while left <= right: # 边界,当右边比左边还小的时候退出循环
    mid = (left + right) // 2   # 这里必须是整除,应为索引没有小数
    if lst[mid] > n:
        right = mid - 1
    if lst[mid] < n:
        left = mid + 1
    if lst[mid] == n:
        print("找到这个数")
        break
else:
    print("没有这个数!")
# 递归来完成二分法
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
def func(n,left,right):
    if left <= right:
        mid = (left + right) // 2
        if n > lst[mid]:
            left = mid + 1
            return func(n,left,right)  # 递归,递归入口
        elif n < lst[mid]:
            right = mid - 1
            # 深坑,函数的返回值返回给调用者
            return func(n,left,right)  # 递归
        elif lst[mid] == n:
            # print("找到了")
            return mid
    else:
        print("没找到")
        return -1   # 避免返回None

# 找66,左边界0,右边界len(lst) - 1
ret = func(66,0,len(lst) - 1)
print(ret)
# 递归二分法另一种形式,但是无法实现位置计算
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
def func(lst,target):
    left = 0
    right = len(lst) - 1
    if left > right:
        print("没有这个数")
    middle = (left + right)//2
    if target < lst[middle]:
        return func(lst[:middle],target)
    elif target > lst[middle]:
        return func(lst[middle + 1:],target)
    elif target == lst[middle]:
        print("找到这个数了")
func(lst,101)

核心: 掐头去尾取中间. 一次砍一半
  两种算法: 常规循环, 递归循环

# 时间复杂度最低, 空间复杂度最低
lst1 = [5,6,7,8]
lst2 = [0,0,0,0,0,1,1,1,1]
for el in lst1:
lst2[el] = 1

lst2[4] == 1 # o(1)

原文地址:https://www.cnblogs.com/ltn26/p/10981251.html

时间: 2024-10-10 14:47:00

Python匿名函数/排序函数/过滤函数/映射函数/递归/二分法的相关文章

python函数式编程之高阶函数学习

基本概念 函数式编程,是一种抽象程度很高的编程范式,纯粹的函数式编程语言编写的函数没有变量.因此,任意一个函数,只要输入确定,输出就确定的这种函数我们称之为纯函数,我们称这种函数没有副作用.而允许使用白变量的程序设计语言,由于函数内部的变量状态是不确定的,同样的输入可能有不同的输出,我们称这种函数为有副作用的. 函数式编程的一个特点就是,允许把函数本身作为参数传递给另一个函数,还允许返回一个函数! Python对函数式编程提供部分支持.由于Python允许使用变量,因此,Python不是纯函数式

Python的函数式编程-传入函数、排序算法、函数作为返回值、匿名函数、偏函数、装饰器

函数是Python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单的任务,这种分解可以称之为面向过程的程序设计.函数就是面向过程的程序设计的基本单元. 传入函数 函数的本身也可以作为参数. Python内建的mapreduce的函数.(来源于谷歌的,后来被道格这家伙开源了,成为当今处理大数据最火热的hadoop中的计算模型---MapReduce) 我们先看map.map()函数接收两个参数,一个是函数,一个是序列,map将传入的函数依次作用到序

python协程函数、递归、匿名函数与内置函数使用、模块与包

目录: 协程函数(yield生成器用法二) 面向过程编程 递归 匿名函数与内置函数的使用 模块 包 常用标准模块之re(正则表达式) 一.协程函数(yield生成器用法二) 1.生成器的语句形式 a.生成器相关python函数.装饰器.迭代器.生成器,我们是如何使用生成器的.一个生成器能暂停执行并返回一个中间的结果这就是 yield 语句的功能 : 返回一个中间值给调用者并暂停执行. 我们的调用方式为yeild 1的方式,此方式又称为生成器的语句形式. 而使用生成器的场景:使用生成器最好的场景就

python 全栈 python基础 (十三)匿名函数 与 内置函数

一.匿名函数  1.定义: 匿名函数顾名思义就是指:是指一类无需定义标识符(函数名)的函数或子程序. 2.语法格式:lambda 参数:表达式 lambda语句中,开头先写关键字lambda,冒号前是参数,可以有多个,用逗号隔开:冒号右边的为表达式,需要注意的是只能有一个表达式.由于lambda返回的是函数对象(构建的是一个函数对象),所以需要定义一个变量去接收.  3.注意点:lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值.lambda 函数不能包含命令,包含

python基础-匿名函数、内置函数、正则表达式、模块

1. 匿名函数 1.1 有名函数 有名函数:定义了一个函数名,函数名指向内存地址:通过函数名进行访问.函数名加括号就可以运行有名函数,例如:func() def func(x, y, z = 1): return x + y + z print(func(1,5,2)) 1.2 匿名函数 匿名函数:没有名字的函数,定义的时候不需要函数名:定义匿名函数的关键字是:lambda 特点: 1.没有函数名 2.函数自带return 应用场景: 1.应用于一次性的地方 2.临时使用 salaries={

python匿名函数 与 内置函数

一.匿名函数  1.定义: 匿名函数顾名思义就是指:是指一类无需定义标识符(函数名)的函数或子程序. 2.语法格式:lambda 参数:表达式 lambda语句中,开头先写关键字lambda,冒号前是参数,可以有多个,用逗号隔开:冒号右边的为表达式,需要注意的是只能有一个表达式.由于lambda返回的是函数对象(构建的是一个函数对象),所以需要定义一个变量去接收.  3.注意点:lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值.lambda 函数不能包含命令,包含

python匿名函数和递归

lambda 匿名函数: 为了解决一些简单的需求而设计的一句话函数 lambda函数不需要def来声明,一句话就可以声明出一个函数 语法: 函数名 = lambda 参数: 返回值 需要注意的是: 1. 函数的参数可以有多个,多个参数之间用逗号隔开 2. 匿名函数不管多复杂,只能写一行,切逻辑结束后直接返回数据 2.返回值和正常的函数一样,可以是任意数据类型 匿名函数并不是说一定没有名字,这里前面的变量就是一个函数名,说他是匿名   原因是我们通过__name__查看的时候是没有名字的,统一叫l

Python开发基础 day10 内置函数 匿名函数 递归

匿名函数lambda 匿名函数:lambda  x,y:x+y 上述解释:x,y分别是函数的参数,x+y是函数的返回值 匿名函数的命名规则,用lamdba 关键字标识,冒号(:)左侧表示函数接收的参数(a,b) ,冒号(:)右侧表示函数的返回值(a+b). 因为lamdba在创建时不需要命名,所以叫匿名函数 等同于普通函数: 1 2 def test(x,y):     return x+y 匿名函数只是没有函数名,主要是配合内置函数使用 示例1: 1 2 3 4 5 6 7 8 9 10 #

python匿名函数(lambda)

简单来说,编程中提到的 lambda 表达式,通常是在需要一个函数,但是又不想费神去命名一个函数的场合下使用,也就是指匿名函数 当我们在传入函数时,有些时候,不需要显式地定义函数,直接传入匿名函数更方便. 在Python中,对匿名函数提供了有限支持.还是以map()函数为例,计算f(x)=x2时,除了定义一个f(x)的函数外,还可以直接传入匿名函数: >>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) [1, 4, 9,