三元表达式、递归、二分法、匿名函数、内置函数

三元表达式：

def max2(x,y):
    if x>y:
        return x
    else:
        return y
res=max2(10,11)
print(res)

x=10
y=11
三元表达式仅应用于：
1.条件成立返回一个值
2.条件不成立返回一个值
res=x if x>y else y
print(res)

def max2(x,y):
    return x if x>y else y
print(max2(10,11))

函数的递归、二分法

函数递归：函数的递归调用，即在函数调用的过程中，又直接或间接地调用了函数
import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(10000)
print(sys.getrecursionlimit())

def foo():
    print('from foo')
    foo()
foo()

def bar():    
    print('from bar')
    foo()
def foo():
    print('from foo')
    bar()
foo()

递归分为两个阶段

1.回溯：

注意：一定要在某种条件下结束回溯，否则的无限循环下去

2.递推

总结：

1.递归一定要有一个明确地结束条件

2.没进入下一次递归，问题的规模都应该减少

3.在python中没有尾递归优化

age(5)=age(4)+2
age(4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)
age(n)=age(n-1)+2
age(n)=18


def age(n):
    if n==1:
        return 18
    return age(n-1)+2
age(5)

回溯
  age(5)
 ______
 age(4)+2

 age(4)
 ______
 age(3)+2
 
age(3)
 ______
 age(2)+2

 age（2）
_________
 age1+2

age1=18

递推：
age（1）
_______
18

age(2)
________
age(1)+2

age(3)
_______
age(2)+2

age(4)
_______
age(3)+2

age(5)
______
age(4)+2

while和递推的区别：

while需要明确多少次循环

而递推只需要知道怎么循环的，至于多少次循环，没必要写。

item2=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10]]]]]]]]]]
def tell(l):
    for item in l:
        if type(item) is not list:
            print(item)
        else:
            tell(item)
tell(items)

匿名函数：

1.没有名字的函数。不会单独使用，通常场情况下会与其他函数连用。

2.匿名函数的参数规则，作用域关系与有名函数是一样的

3.匿名函数的函数体通常应该是一个表达式，该表达式必须要有返回值

def foo(x,n):
    return x**n
f=lambda x,n:x**n
f()

lambda自带return，所以不需要再加return

内置函数：max、min、sorted、map、filter、reduce等等

#lambda匿名函数的应用：
#max,min,sorted,map,filter,reduce
salaries={'egon':3000,
'alex':1000000,
'wupeiqi':10000,
'yuanhao':2000}


#求工资最高的那个人是谁
print（max（salaries，key=lambda x:salaries[x]））
#求工资最低的那个人是谁
print(min(salaries,key=lambda x:salaries[x]))

把薪资字典，按照薪资的高低排序
num=[1,11,9]
num=sorted(num).   默认是升序
print(num)
salaries={'egon':3000,
'alex':1000000,
'wupeiqi':10000,
'yuanhao':2000}


salaries=sorted(salaries,key=lambda x:salaries[x])默认是升序
salaries=sorted(salaries,key=lambda x:salaries[x],reverse=True)
print(salaries)

names=['alex','wupeiqi','yuanhao']

res=map(lambda x:x+'_SB',names)

print(list(res))
names=['alex','wupeiqi','yuanhao','egon']
res=map(lambda x:x+'_sb',names)
电脑输出：
['alex_sb','wupeiqi_sb','yuanhao_sb']

names=['alex','wupeiqi','yuanhao','egon']
res=map(lambda x:x+'_NB' if x=='egon' else x+'_sb',names)
print(list(res))
电脑输出：
['alex_sb','wupeiqi_sb','yuanhao_sb','egon_NB']

 总结一下：常用的内置函数

print(abs(-1))绝对值
print(all([1,'a',True]))列表中所有元素的布尔值为真，最终结果才为真
print(all(' '))传给all的可迭代对象如果为空，最终结果为真
print(any([0,' ',None,False]))列表中所有元素的布尔值只要一个为真，最终结果就为真
print(any([]))传给对象如果为空，最终结果为假
print(bin(11))十进制转二进制
print(oct(11))十进制转八进制
print(hex(11))十进制转十六进制
print(bool(0))0,None,空的布尔值为假
def func()
    pass
print(callable('aaa'.strip())判断某个对象是否可以调用，可调用指的是可以加括号执行某个功能
print(car(90))按照ascii码表将十进制数字转成字符
print(order('2'))按照ascii码表将字符转成十进制数字

#map和filter
def func(a):
    if a%2 == 0:
        return a
    else:
        return False
nums = [x for x in range(11)]  #0--10的list

# map  循环调用函数，把每次函数处理的结果保存到一个list中
res = map(func,nums)
print(list(res))

#filter  过滤，循环调用函数，只保存结果返回为真的
res = filter(func,nums)
print(list(res))