python内置函数

一.lamda匿名函数

定义:为了解决一些简单的需求而设计的函数.

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

1,函数的声明
def func(n):
    '''
    此函数接收一个参数n
    计算n的n次方
    :param n:  传递进来的n
    :return:  n的n次方
    shijian
    zuozhe
    '''
    return n**n
r = func(3) # 函数的调用
print(r)

#print(func.__name__) #查看函数名
#print(func.__doc__) #查看注释文档
例一:
a = lambda n: n**n # 匿名函数, 一般不会用来做复杂的操作
r=a
print(r)
例二
# 写一个lambda 计算字符串长度并返回 # len()
a = lambda s: len(s)
例三:
# 写一个lambda 给函数传递两个参数, a, b 计算a+b的结果
a = lambda m, n: m + n

　　

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

二:排序函数sorted()

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

Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每⼀个元素传递给这个函
数的参数. 根据函数运算的结果进⾏排序
reverse: 是否是倒叙. True: 倒叙, False: 正序

例一
list=[1,5,3,4,6]
lst=sorted(list)
print(lst)
print(list)
例二
dic={1:'A',3:'c',2:'b'}
print(sorted(dic))
例三和函数一起使用
lst=["麻花藤","冈本次郎","中央情报局","狐仙"]
def func(s):
    return len(s)
print(sorted(lst,key=func))
例四 和函数组合使用
lst=["麻花藤","冈本次郎","中央情报局","狐仙"]
def func(s):
    return len(s)
print(sorted(lst, key= lambda s:len(s)))
例五:
lst=[{"id":1,"name":'alex',"age":18},
     {"id":2,"name":"wusir","age":16},
     {"id":3,"name":"taibai","age":17}
     ]
print(sorted(lst,key=lambda e:e["age"]))

三fitter()筛选函数

语法: filter(function. Iterable)

function: ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后
根据function返回的True或者False来判断是否保留此项数据
Iterable: 可迭代对象

例一
lst=[1,2,3,4,5,6,7,8,9,10]
ll=filter(lambda  x: x%2==0,lst)
print(ll)
print(list(ll))
例二
lst=[{"id":1,"name":'alex',"age":18},
     {"id":2,"name":"wusir","age":16},
     {"id":3,"name":"taibai","age":17}
     ]
fl =filter(lambda e: e[age]>16,lst)
print(list(f1))
例三
c=lambda a,b: a+b
r=c(3,4)
print(r)
例四
lst=["麻花藤","冈本次郎","中央情报局","狐仙"]
ll=lambda s: len(s)
r=ll
print(r)
例五
lst=["精卫填海","放羊的星星","年轮","灵魂摆渡","蜗居","第八号当铺","惊魂"]
f=filter(lambda s: len(s)>2,lst)
print(f)
print("__iter__" in dir(f))
for i in f:
     print(i)
例六
lst=[{"id":1,"name":'alex',"age":18},
     {"id":2,"name":"wusir","age":16},
     {"id":3,"name":"taibai","age":34},
     {"id": 3, "name": "太白", "age": 49},
     {"id": 3, "name": "太黑", "age": 26},
     {"id": 3, "name": "骚逼", "age": 17}
     ]
f2=filter(lambda e:e["age"]>=30,lst)
print(f2)
print("__iter__" in dir(f2))
for j in f2:
     print(j)

四map函数(映射函数)

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

例一:计算列表中每个元素的平方返回新列表
lst=[2,3,4,5,6,7]
m=map(lambda s:s**2,lst)
print("__iter__" in dir(m))
for i in m:
     print(i)

n=filter(lambda x:x**2,lst)
for j in n:
     print(j)
例二:查找是否在列表里面
用户:alex
密码:456
lst=["alex_123", "alex_456", "wusir_123", "wusir_456", "alex_789"]
m=list(map(lambda s:"yes" if s=="alex_456" else "false" ,lst))
print(m)
m=list(map(lambda s:s.split("_")[0]=="alex" and  s.split("_")[1] =="123" ,lst))
print(m)
print("__iter__" in dir(list))

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

　　

五;递归:在函数中调用函数本身,就是递归(python中最大递归深度998)

例一
def func():
     print("我是谁")
     func()
func()
def foo(n):
     print(n)
    n += 1
    foo(n)
foo(1)
递归的应⽤: 
 我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统.
 可以使用递归来遍历该文件夹中的所有文件
def func(path, ceng): # path: d:/a
    lst = os.listdir(path)
    for el in lst: # 哈哈
        # el 文件名
        rp = os.path.join(path, el) # d:/a/哈哈
        if os.path.isdir(rp):
            print("	"*ceng, el, sep="")
            func(rp, ceng+1)
        else:
            print("	"*ceng,el, sep="")
func("e:/哈哈", 0)

lst = os.listdir(path) # 打开一个文件夹. 获取到文件夹内的所有内容 ["a","b"]
for el in lst: # 当前文件夹内的所有的文件名(包括文件夹名字)
    # 拼接文件的真实路径
    file_real_path = os.path.join(path, el)
    # 判断这个路径是文件还是文件夹
    if os.path.isdir(file_real_path):
        # 递归的入口
        print(el)
        func(file_real_path) # 重新执行刚才的操作

    else: # 不是文件夹, 是文件
        # 递归的出口
        print(el)

　

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

判断n是否在lst中出现,如果出现请返回n所在的位置
1.二分法查找-----非递归算法
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
 n = 567
left = 0
right = len(lst) - 1
count = 1
while left <= right:
     middle = (left + right) // 2
     if n < lst[middle]:
         right = middle - 1
     elif n > lst[middle]:
         left = middle + 1
     else:
         print(count)
         print(middle)
         break
     count = count + 1
else:
     print("不存在")       

2. 普通递归版本⼆分法
def binary_search(n, left, right):
     if left <= right:
         middle = (left+right) // 2
         if n < lst[middle]:
             right = middle - 1
         elif n > lst[middle]:
             left = middle + 1
         else:
             return middle
     return binary_search(n, left, right) 
# 这个return必须要加. 否则接收到的永远是None.
     else:
         return -1
print(binary_search(567, 0, len(lst)-1))
3. 另类⼆分法, 很难计算位置.
def binary_search(ls, target):
     left = 0
     right = len(ls) - 1
     if left > right:
         print("不在这⾥")
     middle = (left + right) // 2
     if target < ls[middle]:
         return binary_search(ls[:middle], target)
     elif target > ls[middle]:
         return binary_search(ls[middle+1:], target)
     else:
         print("在这⾥")
binary_search(lst, 567)