Day 15 内置函数补充

内置函数

 

1, lambda 匿名函数
lambda 参数: 返回值   函数名统一都叫lambd

# print("你好. 我\\叫周润发") # 对用户是友好的. 非正式的字符串
#
# # 正式(官方)的字符串, 面向对象的时候
# print(repr("你好, 我\'叫周润发")) # 程序中内部存储的内容, 这个是给程序员看的

# print("我叫%r" % "周润发") # %r 实际上调用的是repr()
# 原样输出
# print(r"马化腾说:\"哈哈哈, \" \n\t")

print("你好") # 用户看着舒服
print(repr("你好")) # 真实的字符串表示形式(正式的)

__str__()
__repr__()

# 普通的正常的函数
# def func(n):
#     return n * n
#
# # ret = func(9)
# # print(ret)
# #
# # # 匿名函数, 语法: lambda 参数: 返回值
# a = lambda n : n * n
# # ret = a(9)
# # print(ret)
# b = lambda x: x+1

# print(a(5)) # 函数的名字可以认为是a
#
# print(func.__name__) # 查看函数的名字
# print(a.__name__) # __name__的值都是<lambda>
# print(b.__name__)

# def func(a, b):
#     return a + b
#
# x = lambda a, b: a+b
#
# print(x(1,2))


# 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))

# lambda 参数: 返回值

# 匿名函数, 给函数传递2给参数. 返回最大值
# fn = lambda *args: max(args) # 单行函数
#
# print(fn(1,2,5,2,3,4,156,3,2,2,4,5,56,34,34,34,34,88))

3. filter() 过滤函数
　　filter(function, iterable)
　　把可迭代对象中的每一个元素交给前面的函数进行筛选. 函数返回True或者False

def func():
    print("你好")
def func2():
    print("不好")

def gn(fn): # fn是一个参数. 根据实参给的值的变化而变化
    print(fn.__name__) # func
    fn()

gn(func2)

# lst = [16, 18, 32, 54, 12, 9]

# lst.sort() # list的方法

# print(lst)
#  内置函数中提供了一个通用的排序方案, sorted()
# s = sorted(lst)
# print(s)
#       0       1          0          1         1        0      0
# lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"]
#
# def func(s):
#     return len(s)%2
#
# ll = sorted(lst, key=func)
#
# print(ll)
# key: 排序方案, sorted函数内部会把可迭代对象中的每一个元素拿出来交给后面的key
# 后面的key计算出一个数字. 作为当前这个元素的权重, 整个函数根据权重进行排序


lst = [
    {'name':"汪峰","age":48},
    {"name":"章子怡",'age':38},
    {"name":"alex","age":39},
    {"name":"wusir","age":32},
    {"name":"赵一宁","age":28}
    ]



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

4. map() 映射函数
　　map(function, iterable)
　　把可迭代对象中的数据交给前面的函数进行执行. 返回值就是map的处理结果

# lst = ["张无忌", "张铁林", "赵一宁", "石可心","马大帅"]

# def func(el):
#     if el[0] == '张':
#         return False # 不想要的
#     else:
#         return True # 想要的

# 筛选,
# f = filter(lambda el: el[0]!="张", lst) # 将lst中的每一项传递给func, 所有返回True的都会保留, 所有返回False都会被过滤掉
#
# print("__iter__" in dir(f)) # 判断是否可以进行迭代
# for e in f:
#     print(e)


# lst = [
#     {"name":"汪峰", "score":48},
#     {"name":"章子怡", "score":39},
#     {"name":"赵一宁","score":97},
#     {"name":"石可心","score":90}
# ]
#
# f = filter(lambda el: el['score'] < 60 , lst) # 去16期的人
#
# print(list(f))

5. 递归
　　函数自己调用自己
　　最大深度: 1000 . 到不了1000就停了
　　import sys
　　sys.setrexxxxx

# 递归函数, 自己调用自己
# count = 1
# def func():
#     global count
#     print("alex是很帅的", count)
#
#     count = count + 1
#     func()
# func()
# 递归深度. 你可以自己掉用自己的次数,
# 官方文档中递归最大深度是1000. 在这之前就会给你报错

# 遍历 D:/sylar文件夹, 打印出所有的文件和普通文件的文件名
# import os
# def func(filepath, n): # d:/sylar/
#     # 1,打开这个文件夹
#     files = os.listdir(filepath)
#     # 2. 拿到每一个文件名
#     for file in files:  # 文件名
#         # 3. 获取到路径
#         f_d = os.path.join(filepath, file) # d:/sylar/文件名/
#         # 4. 判断是否是文件夹
#         if os.path.isdir(f_d):
#             # 5. 如果是文件夹. 继续再来一遍
#             print("\t"*n, file,":") # 打印文件名
#             func(f_d, n + 1)
#         else:   #  不是文件夹. 普通文件
#             print("\t"*n, file)
#
# func("d:/sylar",0)

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

dic = {'5':1,'6':1} o(1)

# 时间复杂度最低, 空间复杂度最低
　　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)

 

# lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789 ]
# n = 79

# for el in lst:
#     if el == n: # O(1)
#         print("找到了")
#         break
# else:
#     print("没有")


# 使用二分法可以提高效率, 前提条件:有序序列
# 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: # 边界
        print("哈哈")
        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 n == lst[mid]:
            print("找到了")
            return mid
            # return  # 通过return返回. 终止递归
    else:
        print("没有这个数") # 递归的出口
        return -1 # 1, 索引+ 2, 什么都不返回, None
# 找66, 左边界:0,  右边界是:len(lst) - 1
ret = func(70, 0, len(lst) - 1)
print(ret) # 不是None