Python学习之路_day_12(装饰器补充\函数递归\三元表达式\列表,字典生成式\匿名函数与内置函数)

一.  装饰器补充:
#wraps装饰器应该加到装饰器最内层的函数上
from functools import wraps
import time

 

def deco(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        return res
    # wrapper.__name__=func.__name__
    # wrapper.__doc__=func.__doc__
    return wrapper

@deco #index=deco(index) #index=wrapper函数的内存地址
def index():
    """
    index 功能
    """
    print('welcome to index page')
    time.sleep(3)

# print(index.__name__)
# print(help(index)) #index.__doc__

# index()

print(index.__name__)

@wraps(func)的作用其实解释吧wrapper伪装成index,其拥有相同的函数注释说明.

二. 函数递归:

1 什么是函数递归
    函数的递归调用是函数嵌套调用的一种特殊形式,在调用一个函数的过程中又直接或者间接地调用该函数
    本身,称之为函数的递归调用

    递归调用必须有两个明确的阶段:
        1. 回溯: 一次次递归调用下去,说白了就一个重复的过程,但需要注意的是每一次重复问题的规模都应该有所减少,直到逼近一个最终的结果,即回溯阶段一定要有一个明确的结束条件
        2. 递推: 往回一层一层推算出结果

1.  
   import sys
2.  
   print(sys.getrecursionlimit())
3.  
   sys.setrecursionlimit(2000)
4.  
    
5.  
   def foo(n):
6.  
   print('from foo',n)
7.  
   foo(n+1)
8.  
    
9.  
   foo(0)
10.  
     
11.  
     
12.  
    def bar():
13.  
    print('from bar')
14.  
    foo()
15.  
     
16.  
    def foo():
17.  
    print('from foo')
18.  
    bar()
19.  
     
20.  
    foo()
21.  
     
22.  
    age(5)=age(4)+2
23.  
    age(4)=age(3)+2
24.  
    age(3)=age(2)+2
25.  
    age(2)=age(1)+2
26.  
    age(1)=18
27.  
     
28.  
    age(n)=age(n-1)+2 #n>1
29.  
    age(n)=18 #n=1
30.  
     
31.  
    递归调用就是一个重复的过程,但是每一次重复问题的规模都应该有所减少,并且应该在满足某种条件的情况下结束重复,开始进入递推阶段
32.  
     
33.  
    def age(n):
34.  
    if n == 1:
35.  
    return 18
36.  
    return age(n-1) + 2
37.  
     
38.  
     
39.  
    print(age(5))
40.  
     
41.  
     
42.  
    l=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,]]]]]]]]]]]
43.  
     
44.  
    def search(l):
45.  
    for item in l:
46.  
    if type(item) is not list:
47.  
    # 不是列表直接打印
48.  
    print(item)
49.  
    else:
50.  
    # 判断是列表则继续循环,判断...
51.  
    search(item)
52.  
     
53.  
    search(l)
54.  
     
55.  
     
56.  
    算法:是如何高效率地解决某一个问题的方法/套路
57.  
    二分法
58.  
    nums=[13,15,17,23,31,53,74,81,93,102,103,201,303,403,503,777]
59.  
    find_num=503
60.  
     
61.  
     
62.  
    def binary_search(nums,find_num):
63.  
    print(nums)
64.  
    if len(nums) == 0:
65.  
    print('not exists')
66.  
    return
67.  
    mid_index=len(nums) // 2
68.  
    if find_num > nums[mid_index]:
69.  
    # in the right
70.  
    nums=nums[mid_index+1:]
71.  
    # 重新执行二分的逻辑
72.  
    binary_search(nums,find_num)
73.  
    elif find_num < nums[mid_index]:
74.  
    #in the left
75.  
    nums=nums[0:mid_index]
76.  
    # 重新执行二分的逻辑
77.  
    binary_search(nums,find_num)
78.  
    else:
79.  
    print('find it')
80.  
     
81.  
    # binary_search(nums,find_num)
82.  
    binary_search(nums,94)

 

三.  三元表达式:

 

def max2(x, y):
    # if x > y:
    #     return x
    # else:
    #     return y
    return x if x > y else y
# 三元表达式实现的效果就是:条件成立的情况下返回一个值,不成立的情况下返回另外一种值

# res=条件成立情况下返回的值  if 条件 else 条件不成立情况下返回的值
name=input('your name: ').strip()
res="SB" if name == 'lqz' else "NB"
print(res)

 

四:列表,字典生成式:

1.  
   names=['alex','lqz','yyh','fm']
2.  
   l=[]
3.  
   for name in names:
4.  
   res=name + '_DSB'
5.  
   l.append(res)
6.  
   print(l)
7.  
    
8.  
   l=[name + '_DSB' for name in names]
9.  
   print(l)
10.  
     
11.  
    names=['alex_sb','lqz_sb','yyh_sb','fm_sb','egon']
12.  
    l=[]
13.  
    for name in names:
14.  
    if name.endswith('sb'):
15.  
    l.append(name)
16.  
    print(l)
17.  
     
18.  
    l=[name for name in names if name.endswith('sb')]
19.  
    print(l)
20.  
     
21.  
    items=[
22.  
    ('name','egon'),
23.  
    ('age',18),
24.  
    ('sex','male'),
25.  
    ]
26.  
    dic=dict(items)
27.  
    print(dic)
28.  
     
29.  
     
30.  
    补充
31.  
    l=['a','b','c','d']
32.  
    for i,v in enumerate(l):
33.  
    print(i,v)
34.  
     
35.  
    keys=['name','age','sex']
36.  
    vals=['egon',18,'male']
37.  
    dic={}
38.  
    for i,k in enumerate(keys):
39.  
    # print(i,k)
40.  
    dic[k]=vals[i]
41.  
    print(dic)
42.  
     
43.  
    dic={k:vals[i] for i,k in enumerate(keys)}
44.  
    print(dic)
45.  
     
46.  
    dic={k:vals[i] for i,k in enumerate(keys) if i > 0}
47.  
    print(dic)
48.  
     
49.  
     
50.  
    print({i:i for i in range(10)})
51.  
    print({i for i in range(10)})
52.  
    print({i for i in 'hello'})

 

五. 匿名函数与内置函数

1.  
   '''
2.  
   1 匿名函数：就是没有名字的函数
3.  
    
4.  
   2 为何要用：
5.  
   用于仅仅临时使用一次的场景，没有重复使用的需求
6.  
    
7.  
   '''
8.  
    
9.  
   def sum2(x,y):
10.  
    return x+y
11.  
     
12.  
    print(lambda x,y:x+y)
13.  
    print((lambda x,y:x+y)(1,2))
14.  
     
15.  
    匿名函数的精髓就是没有名字，为其绑定名字是没有意义的
16.  
    f=lambda x,y:x+y
17.  
    print(f)
18.  
    print(f(1,2))
19.  
     
20.  
    匿名函数与内置函数结合使用
21.  
    max,min,sorted,map,filter,reduce
22.  
     
23.  
     
24.  
    salaries={
25.  
    'egon':300000,
26.  
    'alex':100000000,
27.  
    'wupeiqi':10000,
28.  
    'yuanhao':2000
29.  
    }
30.  
    求薪资最高的那个人名：即比较的是value，但取结果是key
31.  
    res=max(salaries)
32.  
    print(res)
33.  
     
34.  
    可以通过max函数的key参数来改变max函数的比较依据，运行原理：
35.  
    max函数会“for循环”出一个值，然后将该值传给key指定的函数
36.  
    调用key指定的函数，将拿到的返回值当作比较依据
37.  
     
38.  
    def func(name):
39.  
    # 返回一个人的薪资
40.  
    return salaries[name]
41.  
     
42.  
    res=max(salaries,key=func) #'egon'
43.  
    print(res)
44.  
     
45.  
    求最大值
46.  
    res=max(salaries,key=lambda name:salaries[name]) #'egon'
47.  
    print(res)
48.  
     
49.  
    求最小值
50.  
    res=min(salaries,key=lambda name:salaries[name]) #'egon'
51.  
    print(res)
52.  
     
53.  
     
54.  
    sorted排序
55.  
    nums=[11,33,22,9,31]
56.  
    res=sorted(nums,reverse=True)
57.  
    print(nums)
58.  
    print(res)
59.  
    salaries={
60.  
    'egon':300000,
61.  
    'alex':100000000,
62.  
    'wupeiqi':10000,
63.  
    'yuanhao':2000
64.  
    }
65.  
    for v in salaries.values():
66.  
    print(v)
67.  
    res=sorted(salaries.values())
68.  
    print(res)
69.  
     
70.  
    res=sorted(salaries,key=lambda name:salaries[name],reverse=True)
71.  
    print(res)
72.  
     
73.  
     
74.  
    map：把一个列表按照我们自定义的映射规则映射成一个新的列表
75.  
    names=['alex','lxx','wxx','yxx']
76.  
    res=map(lambda name: name + "dSB", names)
77.  
    print(list(res))
78.  
     
79.  
    filter: 从一个列表中过滤出符合我们过滤规则的值
80.  
    运行原理：相当于for循环取出每一个人名，然后传给匿名函数，将调用匿名函数返回值为True的那个人名给留下来
81.  
    names=['alex_sb','lxx_sb','wxx_sb','egon','yxx']
82.  
     
83.  
    res=filter(lambda name:name.endswith('sb'),names)
84.  
    print(list(res))
85.  
     
86.  
    print([name for name in names if name.endswith('sb')])
87.  
     
88.  
    reduce: 把多个值合并成一个结果
89.  
    from functools import reduce
90.  
    l=['a','b','c','d']
91.  
     
92.  
    res=reduce(lambda x,y:x+y,l,'A')
93.  
    'A','a' => 'Aa'
94.  
    'Aa','b'=>'Aab'
95.  
    'Aab','c'=>'Aabc'
96.  
    'Aabc','d'=>'Aabcd'
97.  
    print(res)
98.  
     
99.  
     
100.  
     res=reduce(lambda x,y:x+y,l)
101.  
     'a','b'=>'ab'
102.  
     print(res)
103.  
      
104.  
     res=reduce(lambda x,y:x+y,range(1,101))
105.  
     1,2=>3
106.  
     3,3=>6
107.  
     print(res)
108.