day17_python

之前一个不小心把之前的全部删除了，也没有办法恢复，所以还是在博客上记录一下
参考Eva_J的博客，原文连接：https://www.cnblogs.com/Eva-J/p/7277026.html

# 内置函数
# 55个内置函数
# 带key的max() min() filter() map() sorted()
# 匿名函数
# lambda 参数1，参数2: 返回值表达式
# 五个特殊的内置函数可以结合使用
# 生成器和迭代器
# 用map来处理字符串列表，把列表中所有人都变成sb，比如alex_sb

import sys
name = ['alex', 'wupeiqi', 'yuanhao', 'nezha']


def func(item):
    return item + '_sb'


ret = map(func, name)
for i in ret:
    print(i)

print(list(i))  # list把字符串拆开变为每一个元素
print(list(ret))  # ret为迭代器，取完后就不含有元素，返回一个空列表
ret = map(lambda item: item+'_sb', name)  # lambda与函数无关
print(list(ret))
print(list(ret))  # ret迭代器，取完后依旧消失

# 用filter()函数处理数字列表，将列表中所有的偶数筛选出来
num = [1, 3, 5, 7, 8]


def func1(x):
    if x % 2 == 0:
        return True   # return x % 2== 0


ret = filter(func1, num)  # func和可迭代的 filter返回值为迭代器
print(list(ret))
ret = filter(lambda x: True if x % 2 == 0 else False, num)  # 冒号后面可以写表达式和for循环
# 随意写一个20行以上的文件
# 运行程序，先将内容读取到内存中，用列表存储
# 接收用户输入页码，每页5条，仅仅输出当页的内容
with open('C:/Users/dell/Desktop/test20.txt', encoding='utf-8') as f:
    p = f.readlines()
page_num = int(input('输入页码：'))
# 1,1-5
# 2, 6-10
pages, mod = divmod(len(p), 5)  # 商余函数，返回两个值
if mod:  # mod不为零
    pages += 1
if page_num > pages:
    print('error')
elif page_num == pages and mod != 0:
    for i in range(mod):
        print(p[(page_num-1)*5 + i].strip())  # 取消输出换行
else:
    for i in range(5):
        print(p[(page_num-1)*5 + i].strip())

如下，每一个小字典的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}
]
# 计算购买每只股票的的总价？
ret = map(lambda dic: {dic['name']: round(
    dic['shares']*dic['price'], 2)}, portfolio)  # round 精确小数位
print(list(ret))
# 用filter()过滤出单价大于100的股票有哪些？
ret = filter(lambda dic: True if dic['price'] > 100 else False, portfolio)
ret = filter(lambda dic: dic['price'] > 100, portfolio)
print(ret)

# 递归函数,即在函数中调用自己
# 二分查找算法
# 三级菜单-递归实现
while 1:
     print('从前有座山')


def story():
     print('从前有座山')
     story()   # 下面的语句不执行
     print('是否执行')   # recursion error 递归报错,递归深度


story()
# 看递归深度 ,最大递归深度默认是997或者998，是python从内存角度保护机制，可以修改
sys.setrecursionlimit(1000)
n = 0


def story():
     global n
     n += 1
     print(n)
     story()


 story()
# 如果递归次数太多就不适合递归来解决问题
# 递归的缺点占内存，优点让代码变简单
# 然后已知递归，例如汉诺诺，递归解决计算方法一样的问题
count = 0


def hanoi(n, src, dst, mid):
    global count
    if n == 1:
        print("{}:{}->{}".format(1, src, dst))
        count += 1
    else:
        hanoi(n-1, src, mid, dst)
        print("{}:{}->{}".format(n, src, dst))
        count += 1
        hanoi(n-1, mid, dst, src)


hanoi(3, 'A', 'C', 'B')
print(count)

# 查找 排序，最短路径
# 算法都是过去时
# 二分查找算法，有序列表，通过中间值和你要查找值的大小，进行中间值判断


def find(lis, aim, start=0, end=None):
    end = len(lis) if end is None else end
    mid_index = (end - start)//2 + start   # 双杠表示整除，取整数部分
    if start <= end:
        if lis[mid_index] < aim:
            return find(lis, aim, start=mid_index + 1, end=end)
            # mid_index=len(new_lis)//2
        elif lis[mid_index] > aim:
            return find(lis, aim, start=start, end=mid_index-1)
        else:
            print('找到了', mid_index, aim)
    else:
        return '找不到这个值'


lis = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
find(lis, 5)
print(lis.index(5))
# 几个缺点
# 参数end end 使用了len
# 返回值
# 不再列表中的值无法处理