三元表达式、列表推导式、生成器表达式、匿名函数、内置函数、递归调用与二分法的简单认识

一、三元表达式

　　示例：

name=["liu","egon","alex","laoliu"]
names=input("请输入你的名字：").strip()
print("DSB" if names in name else "NB")

二、列表推导式

示例：

print(["鸡蛋%s"%i for i in range(5)])
print(["鸡蛋%s"%i for i in range(5)if i>0])

三、生成器表达式

示例：

print(next("鸡蛋%s"%i for i in range(5)))
res=("鸡蛋%s"%i for i in range(5))
for i in res:
    print(i)

四、匿名函数

　　简述：没有名字的函数即引用计数为0的函数，使用一次后就从内存中删除掉。

　　示例：

func=lambda x,y:x+y
print(func(1,2))

五、内置函数

　　简述：Python解释器内置的具备简单功能的函数

　　示例：

salaries={
    "liu":2000,
    "egon":50000,
    "laoliu":45000
}
print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))
# salary_name=zip(salaries.values(),salaries.keys())
# print(max(salary_name))
salary_name=zip(salaries.values(),salaries.keys())
print(min(salary_name))

“----------------------------”
#map将两个列表合并成一个新的列表

print(list(map(lambda x,y:x+y,[1,2,3],[1,2,3,4])))

“----------------------------”
#filter将符合条件的值筛选出来

print(list(filter(lambda x:x>0,range(5))))

“----------------------------”
#reduce为组合函数将两个值组合到一起

from functools import reduce print(reduce(lambda x,y:x+y,range(5),2))
“----------------------------”
#sorted排序sorted中reverse为True时降序反之升序
aa=[1,2,5,7,4,3,6,8]
print(sorted(aa,reverse=True))

六、递归调用

1.简述递归:递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用
　　例如:
　　#直接调用本身
　　def f1():
　　print('from f1')
　　f1()
　　f1()

　　#间接调用本身
　　def f1():
　　print('from f1')
　　f2()

　　def f2():
　　print('from f2')
　　f1()
　　f1()

　　# 调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无需调用本身，python解释器的内存管理机制为了防止其无限制占用内存，对函数的递归调用做了最大的层级限制
　　最大层级限制可以修改,修改如下:
　　sys.getrecursionlimit()
　　sys.setrecursionlimit(2000)

　　def f1(n):
　　print('from f1',n)
　　f1(n+1)
　　f1(1)
　　用本身是毫无意义的，递归应该分为两个明确的阶段，回溯与递推
2.递归分为两个明确的阶段，回溯与递推
　　回溯就是从外向里一层一层递归调用下去，

　　虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归，而且无限制地递归调溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）

　　递推就是从里向外一层一层结束递归
3.python中的递归效率低且没有尾递归优化
　　　　简述:python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化：http://egon09.blog.51cto.com/9161406/1842475
　　　　但是python又没有尾递归，且对递归层级做了限制

　　　　总结递归的使用：
　　　　　　1. 必须有一个明确的结束条件
　　　　　　2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
　　　　　　3. 递归效率不高，递归层

七、二分法（两种方法）

示例一：

def serach(n,l):
    mid=len(l)//2
    if n==l[mid]:
        print("所需索引：%s"%mid)
        return
    elif n>l[mid]:
        l=l[mid+1:]
        serach(n,l)
    elif n<l[mid]:
        l=l[:mid-1]
        serach(n,l)
    else:
        print("已找到结果")
serach(200,l)
"""
相当于l.index(200)
"""

示例二：

l = [1, 2, 10, 30, 33, 99, 101, 200, 301, 311, 402, 403, 500, 900, 1000]  # 从小到大排列的数字列表

def serach(n,l,start=0,stop=len(l)-1):
    mid=start+(start+stop)//2
    if n ==l[mid]:
        print(mid)
        return
    elif n>l[mid]:
        start=mid+1
        serach(n,l,start,stop)
    elif n<l[mid]:
        stop=mid-1
        serach(n,l,start,stop)
    else:
        print("find it")
serach(200,l)