三元表达式、递归函数、匿名函数、列表生成式、生成器表达式

三元表达式

　　其目的是为了简化书写，既然是简化就必然有局现性

　　 三元表达式只能简化仅有两个分支的if判断，

a=1
b=2
m=a if a>b else b
print(m)

函数的递归调用
　  在调用一个函数的过程又直接或间接地调用函数本身，称之为函数的递归调用

　　递归必须满足两个条件：
　　　　　　1，每进入下一次递归，问题的规模都应该有所减少
　　　　　　2，必须有一个明确的结束条件

　　递归时出现以下错误

RecursionError: maximum recursion depth exceeded while calling a Python object
在调用函数是超出了最大递归深度

#系统默认次数是1000

import sys
print(sys.getrecursionlimit())

>>>1000
-------------------------------------------
#可修改
import sys
sys.getrecursionlimit(2000)

>>>2000

小练习

用while循环和递归的方法把列表中的值取出来
　　　　l=[1,[2,[3,[4,[5,[6]]]]]]

用while循环把列表中的值取出来
l=[1,[2,[3,[4,[5,[6]]]]]]
while True:
    tag=False
    for i in l:
        if type(i) == list:
            l = i
            tag=True
        else:
            print(i)
    if tag==False:
        break

用递归的方法取出来
l = [1, [2, [3, [4, [5, [6]]]]]]
def func(li):
    for x in li:
        if type(x)is not list:
            print(x)
        else:
            func(x)
func(l)

　

递归的使用案例：二分查找法

　　想从一个按照（从小到大）或（从大到小）排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模

 

匿名函数

1、介绍

#1、语法
    匿名函数lambda x: x * x
    关键字lambda表示匿名函数，冒号前面的x表示函数参数。
    匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

#2、匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数
    f = lambda x: x * x
    print(f)         #<function <lambda> at 0x10453d7d0>
    print(f(6))     #36

#3、可以把匿名函数作为返回值返回
    def build(x, y):
        return lambda: x * x + y * y

2、与内置函数连用

#内置函数map这里不再介绍，可移步高级函数中的内置函数

#这有一个字典，求出工资最高的人的名字
salaries={
    'a1':100,
    'b1':400,
    'c1':300,
    'd1':200
}
-----------------------------------
res=max(salaries)
print(res)        # d1           这样取的是key的字母最大值

-------------------------------------
li=[]
for k,v in salaries.items():
    li.append(v)
print(max(li))        #400     这样是value最大值

----------------------------------
#与有名函数连用
def func(name):
    return salaries[name]
res = max(salaries, key=func)
print(res)               #b1              这次取对了

-----------------------------------
#与匿名函数连用
res = map(salaries,key=lambda name:salaries[name])
print(res)     #b1

　　　　

reduce: 把多个值合并成一个结果

#from functools import reduce         py3中，必须用它调用reduce

from functools import reduce
l=['a','b','c','d']
res=reduce(lambda x,y:x+y,l,'A')
# 'A','a' => 'Aa'
# 'Aa','b'=>'Aab'
# 'Aab','c'=>'Aabc'
# 'Aabc','d'=>'Aabcd'
print(res)

>>>>Aabcd

---------------------------------------------------
from functools import reduce
l=[1,2,3,4,5,6]
res = reduce(lambda x,y:x+y,l)
print(res)

>>21

列表生成式

　　一个快速产生列表的表达式

优点：方便，改变了编程习惯，可称之为声明式编程

----------------------------------------------------------------
res=[i+1 for i in range(1,100)]
print(res)

----------------------------------------------------------------
res=[i+1 for i in range(1,100)if i>50]
print(res)

生成器表达式

把列表推导式的[]换成()就是生成器表达式

优点：省内存，一次只产生一个值在内存中

res=(i+1 for i in range(1,100)if i>50)
print(res)
>>>>    <generator object <genexpr> at 0x0000020348A45468>

列表生成式与生成器表达式实际区分

#注意看print缩进

列表生成式
with open(r'E:python代码16aaa.py',encoding='utf-8')as f:
    li=[len(i) for i in f]
    print(max(li))

>>>>58
---------------------------
with open(r'E:python代码16aaa.py',encoding='utf-8')as f:
    li=[len(i) for i in f]
print(max(li)）
>>>>58
还有输出的原因，即使文件关闭了，文件中的内容存入列表，已经读入内存
-------------------------------------------------------------------------------
生成器表达式
with open(r'E:python代码16aaa.py',encoding='utf-8')as f:
    li=(len(i) for i in f)
    print(max(li))
>>>>58


with open(r'E:python代码16aaa.py',encoding='utf-8')as f:
    li=(len(i) for i in f)
print(max(li))
>>>>ValueError: I/O operation on closed file.

只有在调用__next__的时候才会去取值，此时I/O已经关闭