python全栈开发-前方高能-内置函数2

  注意:

 

  1. 前⽅⾼能-内置函数⼆

二丶sorted排序

lst = [16, 18, 32, 54, 12, 9]
lst.sort() # list的方法
print(lst)  #[9, 12, 16, 18, 32, 54]
#内置函数中提供了一个通用的排序方案, sorted()
s = sorted(lst)
print(s)    #[9, 12, 16, 18, 32, 54]

    函数名 = lambda参数:返回值

# 普通的正常的函数
def func(n):
    return n * n
ret = func(9)
print(ret)

# 匿名函数
a = lambda n : n * n
ret = a(9)
print(ret)
# 遍历树形结构
import  os
filePath = "d:sylarpython_workspace"

def read(filePath, n):
    it = os.listdir(filePath)   # 打开文件夹
    for el in it:
        #  拿到路径
        fp = os.path.join(filePath, el) # 获取到绝对路径
        if os.path.isdir(fp):   # 判断是否是文件夹
            print("t"*n,el)
            read(fp, n+1)    # 又是文件夹. 继续读取内部的内容 递归入口
        else:
            print("t"*n,el)    # 递归出口

read(filePath, 0)

    map(function,Iterable)

四. map() 映射函数

  单个变量传值可以这样传,那假如两个或多个变量呢,该怎么样呢?我们可以用小括号括起来,要不就会报错

def func(x, y):
    return x, y

print(func(1,2)) #(1,2)

suiyi = lambda x, y : (1, 2)   # 笔试题
print(suiyi)
print(suiyi(250,38))    #(1,2)

 

python_day_15

  语法:

五. 递归 在函数中调⽤函数本⾝. 就是递归,在python中递归的深度最⼤到997.

    1.函数的参数可以有多个,多个参数之间用逗号隔开

2018-07-20  15:26:04

    sorted(Iterable,key = None,reverse=False)

六. ⼆分查找

    Iterable:可迭代对象

lst = ["张无忌", "张铁林", "马丹", "曹丹","马大帅"]
def func(el):
    if el[0] == '张':
        return False # 不想要的
    else:
        return True # 想要的
# 筛选,
# 将lst中的每一项传递给func, 所有返回True的都会保留, 所有返回False都会被过滤掉
f = filter(lambda el: el[0]!="张", lst) 
print("__iter__" in dir(f)) # 判断是否可以进行迭代
for e in f:
    print(e)

 

 

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

四丶map()映射函数

语法: filter(function. Iterable)

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

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]

def binary_search(lst, n):
    left = 0
    right = len(lst) - 1
    middle = (left + right) // 2
    if right <= 0:
        print("没找到")
        return
    if n > lst[middle]:
        lst = lst[middle+1:]
    elif n < lst[middle]:
        lst = lst[:middle]
    else:
        print("找到了")
        return
    binary_search(lst, n)
binary_search(lst, 65)

  语法:

注意:

    3.返回值和正常函数一样,可以是任意数据类型

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]

def binary_search(left, right, n):
    middle = (left + right)//2
    if left > right:
        return -1
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle
    return binary_search(left, right, n)
print(binary_search(0, len(lst)-1, 65) )

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

 

    filter(function,Iterable)

3)另类二分法,很难计算位置.

三丶filter()筛选函数

lst = [1,2,3,4,5,6,7,8,9]

ll = filter(lambda i:i%2==1, lst)
#  第一个参数. 函数. 将第二个参数中的每一个元素传给函数. 函数如果返回True, 留下该元素.

  sorted可以跟lambda组合使用

lst = [
    {'name':"迪迦奥特曼","age":48},
    {"name":"雷欧娜",'age':38},
    {"name":"赛文","age":39},
    {"name":"泰罗","age":32},
    {"name":"狗哥无敌","age":28}
    ]

ll = sorted(lst, key=lambda el: len(el['name']), reverse=False)
print(ll)

图片 1

 

语法: sorted(Iterable, key=None, reverse=False)

    Iterable:可迭代对象

本节主要内容:

一丶匿名函数

https://www.processon.com/view/link/5b71818ce4b0555b39e10414

  说是匿名函数,可总该有个名字吧,我们可以用__name__来查看一下名字

b = lambda x: x+1
a = lambda n : n * n
print(a.__name__) # __name__的值都是<lambda>
print(b.__name__) # __name__的值都是<lambda>

2)普通递归版

    2.匿名参数不管多复杂,只能写一行,且逻辑结束后直接返回数据

⼆. sorted() 排序函数.

  语法:

 

  语法:

一.今日主要内容

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

def func(n):
    return n * n

print(func(3))
a = func
a(3)
print(a.__name__)    # 查看函数的函数名
# lambda 匿名函数
# x 参数
#  : 后面是函数体(直接return的内容)
a = lambda x: x*x   # 一行搞定一个函数. 但是, 不能完成复杂的函数操作
print(a)
print(a(6))
print(a.__name__)

b = lambda x, y: x+y
print(b(1,3))
print(b.__name__)

# 语法: 变量 = lambda 参数: 返回值

本文由金沙官网线上发布于编程,转载请注明出处:python全栈开发-前方高能-内置函数2

您可能还会对下面的文章感兴趣: