day17：递归函数

1，递归函数是一个函数体系，非常的难

2，练习题一

# 3.用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao','nezha']
# def func(item):
#     return item+"_sb"
ret= map(lambda item:item+"_sb",name) # ret 是迭代器，这儿要注意一下，迭代器和可迭代对象是不一样的，每个for循环的时候，可迭代对象都会自动转换成一个迭代器，每次都是新的，
# 但是如果for循环迭代器的话，因为没有转化那一步，所以去一次就取没了，不可以再取了。
for i in ret:
    print(i)

print(list(ret))  #只可以取一次，所以啥也取不到了
# print(list(i))   ['n', 'e', 'z', 'h', 'a', '_', 's', 'b'] 字符串转列表，循环完了i在外面可以用

运行结果：
alex_sb
wupeiqi_sb
yuanhao_sb
nezha_sb
[]

# 列表生成式也可以解决这个题
list1 = [item+"_sb" for item in name]
print(list1)

运行结果：
['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'nezha_sb']

3，练习题二，注意lambda表达式返回值那一块儿，可以写列表表达式，或者三元运算符判断等，只要可以写成一行的都可以用在lambda表达式里面

# 4.用filter函数处理数字列表，将列表中所有的偶数筛选出来
num = [1,3,5,6,7,8]
# def func(x):
#     return x%2 ==0
ret = filter(lambda x:x%2 == 0,num)
print(list(ret))
print(list(ret))  # filter和map的返回值都是一个迭代器，这个比较容易混

运行结果：
[6, 8]
[]

ret = filter(lambda x:True if x%2 ==0 else False,num) # 这样不简洁，但是只是举个例子，可以这样写
ret = filter(lambda x:[item+"_sb" for item in x],num)  #这儿的x 要求是个可迭代的，列表啥的

4，练习题三：

# 自己的版本
with open('file.txt',encoding='utf-8') as f:
    my_list = f.readlines()  # 一般情况下，我们不这样读，太耗费内存。
    page = int(input(">>>"))
    line_num,last_page_len = divmod(len(my_list),5)

    if last_page_len:
        if page <=line_num and page > 0:
            for i in range(5):
                print(my_list[i+(page-1)*5].strip())
        elif page == line_num+1:
            for i in range(last_page_len):
                print(my_list[i+(page-1)*5].strip())
        else:
            print("invalid page")
    else:
        if page <=line_num and page > 0:
            for i in range(5):
                print(my_list[i+(page-1)*5].strip())
        else:
            print("invalid page")

# 老师的版本
with open('file.txt',encoding='utf-8') as f:
    my_list = f.readlines()  # 一般情况下，我们不这样读，太耗费内存。
    page_num = int(input(">>>"))

    pages,mod = divmod(len(my_list),5)
    if mod:
        pages +=1
    if page_num > pages or page_num<=0:
        print('输入有误')
    elif page_num ==pages and mod != 0:
        for i in range(mod):
            print(my_list[(page_num-1)*5 +i].strip())
    else:
        for i in range(5):
            print(my_list[(page_num - 1) * 5 + i].strip())

5，

# 6.如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]

# 6.1.计算购买每支股票的总价
def func(item):
    return {item['name']:item['shares']*item['price']}

ret = map(lambda item:{item['name']:round(item['shares']*item['price'],2)},portfolio) # 注意round的用法
print(list(ret))
# 6.2.用filter过滤出，单价大于100的股票有哪些

ret = filter(lambda item:item['price']>100,portfolio)
print(list(ret))

6，递归函数，现实中用的并不多，自己调用自己，注意设置结束条件

import sys
# 函数嵌套定义闭包，其他函数一般不支持，闭包，装饰器用的不多
# 函数的嵌套调用，递归，在函数里面再调用本身
# 递归函数的特点：1，传递，2，递归，结束条件和返回值

# def story():
#     print("从前有座山")
#     story()
#
# story()
# 这样没有结束条件的话，会报出这样的错误
# RecursionError: maximum recursion depth exceeded while calling a Python object
ret = sys.getrecursionlimit()
print(ret) # 1000 Python从内存角度出发做的限制

sys.setrecursionlimit(1500)# 即使这里设置的很大，不同的电脑可能也打不到，不同的电脑配置不同，可以跑的最大次数不一样,我的Mac最多可以跑一万多次

7，如果递归次数太多，就不适合用递归来解决问题，递归的缺点：占内存，递归的优点，会让代码变简单,计算年龄的例子

def age(n):
    if n == 4:
        # age = 40   # 注意这个地方如果给age重新定义得话，那么下面的调用函数的age就不表示函数名了，而是这个变量了，下面就会报错
        return 40
    elif n >0 and n < 4:
        return age(n+1) + 2

ret = age(1)
print(ret)

8，递归也是一样，如果看不懂，就把他拆开看

9，算法，基础

# 计算机其实很傻的，他算数会硬算的，他肯定不会这么算的，你告诉他怎么算，可能你告诉他可能也麻烦，他算100乘以13也不一定简单
# 你算起来容易，但是计算机很复杂，用策略让计算机把这些事情变简单，这些是优秀的算法，时间久了流传下来，记载在书里。计算机的历史里
# 这些算法都是经典的历史流传下来的，包括
# 查找，庞大的数据量里面查，找数据，数据库，CTRL+F这件事也是计算机帮你找的，计算机找也是人设计的
# 排序，列表的排序，sort,python解释器也是人写的，龟叔也要设计算法
# 遍历
# 最短路径 等等，百度地图的依据，滴滴打车
# 99*13 = 100*13-13

# 这些算法曾经优秀过，都有成型的解决方案了，都已经是历史了，我们要了解计算机的逻辑，站在巨人的肩膀上，一般会学习一些简单
# 但是算法一般都不太好理解，你想的多，计算机就干的少，算法一般是人脑复杂，计算机简单

# 我们学习的算法都是过去式，我们现在的代码都不太会用到他了，要了解基础的算法，才能设计出或者创造出更好的算法，
# 不是所有的事情，都能套用现成的方法解决的，有些时候会用到现成的算法只是解决新的问题

10，二分查找算法代码实现，一定要多默写，不然记不住，必须看懂

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]  #25个
def search(l,aim,start = 0, end = None):
    end = len(l) if end is None  else end  # 赋值给none可能会有问题，所以改成is
    mid_index = (end -start)//2 + start
    if start <= end:  # 等于的时候我也有一次机会去找一下

        if aim > l[mid_index]:
            start = mid_index + 1
            ret = search(l,aim,start,end)
            return ret

        elif aim < l[mid_index]:
            end = mid_index -1
            ret = search(l,aim,start,end)
            return ret

        else:
             return mid_index  # 每一个分支都要写一个return，因为这个return值都是有由内层函数获得，要保证外层函数也能获取return值
    else:
        print("does not exists")

print(search(l,66)) # 传值的话，len(l)如果每次都传得话，用户体验不好，所以还是要放入函数里面处理
print(search(l,67))
print(search(l,13)) # 找不到的时候

运行结果：
17
18
does not exists
None