带参装饰器 ：Send 原理

 

send原理

1.send发生信息给当前停止的yield

2.再去调用__next__()方法，生成器接着往下指向，返回下一个yield值并停止

'''

1.繁琐版

variety=['黄连','茯苓','半夏','杜若','连翘','苏叶']

def namer(variety):

    print('%s满眼都是六便士'%variety[0])

    print('%s却抬头看见了月亮'%variety[0])

    name=yield variety[0]

    print('%s听闻%s满眼都是六便士'%(name,variety[1]))

    print('%s抬头看见了月亮' % variety[1])

    name = yield variety[1]

    print('%s听闻%s满眼都是六便士' % (name, variety[2]))

    print('%s抬头看见了月亮' % variety[2])

    name = yield variety[2]

obj = namer(variety)

# obj为刚开始的药品

q=obj.__next__()

# 黄连

print('------------------------')

q=obj.send(q)

print('------------------------')

q=obj.send(q)

'''

'''

简化版

variety=['黄连','茯苓','半夏','杜若','连翘','苏叶']

def namer(variety):

    for i in range(len(variety)):

        if i == 0:

            print('%s满眼都是六便士'%variety[0])

        else:

            print('%s听闻%s满眼都是六便士'% (name,(variety[i])) )

        print('%s抬头看见了月亮'%variety[i])

        name=yield variety[i]

obj=namer(variety)

for i in range(len(variety)):

     if i == 0:

         q=obj.__next__()

     else:

         q=obj.send(q)

     print('-------------')

'''

 递归：

 函数直接或间接调用本身，都称之为递归

 回溯：找寻答案的过程

 递推：推出结果的过程

 

 前提条件：

 1.递归必须有出口

 2.递归回溯递推的条件一定有规律

import sys

print(sys.getrecursionlimit())

# 获取最大递归层数

sys.setrecursionlimit(100)

# 设置最大递归层数

print(sys.getrecursionlimit())

'''

'''

递归

count=0

def f():

    global count

    count +=1

    print(count)

    f()

求n的阶乘

5! =5*4*3*2*1=120

5！=5*4！

4！=4*3！

3！=3*2！

2！=2*1！

1！=1

def jiecheng(n):

    if n == 1 or n == 0:

        return 1

    j = n*jiecheng(n-1)

    return j

res=jiecheng(100)

print(res)

f()

 

ef fn(*args, **kwargs):

     函数体

    return '返回值'

 

 匿名函数：

1. 匿名函数没有函数名

 2.匿名函数的关键字采用lambda

 3.关键字 lambda 与标识函数功能体 : 之间一定是参数，所以省略()

 4.匿名还是没有函数体，只有返回值，所以函数体和返回值的return关键字都省略了

 

lambda *args, **kwargs: '返回值'

 

注意：

1. 参数的使用和有名函数一样，六种形参都支持

2.返回值必须明确成一个值，可以为单个值对象，也可以为一个容器对象

 

a = lambda *args, **kwargs: '返回值1', '返回值2'

print(a)  # (<function <lambda> at 0x0000022D0B7E88C8>, '返回值2')

# 返回值1

print(a[0]())

正确返回两个值

lambda *args, **kwargs：（ '返回值1', '返回值2'）

max结合匿名函数工作原理

 1.max内部会遍历iter，将遍历结果一一传给lambda的参数x

 2.依据lambda的返回值作为比较条件，得到最大条件下的那个遍历值

 3.对外返回最大的遍历值

max(iter, lambda x: x)

min工作原理一样，得到的是最小值

map 映射

dic={

    'qwe':8,

    'asd':4

}

res=map(lambda k: (k,dic[k]*2),dic)

print(list(res))

map(lambda x: x * 2, [3, 1, 2]) # 将遍历结果映射为任意类型值 [6, 2, 4]

reduce合并

from functools import reduce

res=reduce(lambda x , y: x+y, [5,92,54,1,3,])

print(res)

res=reduce(lambda x , y: x*y, [5,92,54,1,3,])

print(res)

print(sum([2,6,9,5,8,6,]) )

常用的内置函数

 1.与类型相关的

 list() str() ord() chr() bool() int() ...

 

print(ord('A'))

print(chr(97))

 

 2.进制转化

print(bin(10))  # 1010

print(oct(10))  # 12

print(hex(10))  # a

 

print(0b1111)  # 15

print(0o10)  # 8

print(0x11)  # 17

from functools import reduce

 

 3.常用操作类的

# range() len() iter() next() enumerate() id() type() print() input() open()

 

 4.原义字符串

print(r'a\nb')

print(ascii('a\nb'))

print(repr('a\nb'))

 

 

 5.数学相关运算

abs() sum() max() min() pow() sorted()

print(abs(-1))

print(pow(2, 3))  # 2**3

print(pow(2, 3, 3))  # 2**3%3

 

dic = {

    'owen': (1, 88888),

    'zero': (2, 66666),

    'tom': (3, 77777),

}

res = sorted(dic, key=lambda k: dic[k][1])

print(res)  # ['zero', 'tom', 'owen']

 

res = sorted(dic, key=lambda k: dic[k][1], reverse=True)

print(res)  # ['owen', 'tom', 'zero']

 

 

 6.获取帮助

 help(dict)

 

 7.执行字符串: eval() exec()

 

 8.反射：getattr() setattr() delattr() hasattr()

 

 9.面向对象的装饰器：classmethod() staticmethod()

 

 10.面向对象的其他：super() globals() locals()

print(globals())

 

def fn():

    a = 10

    b = 20

    def inner(): pass

print(globals())    以字典类型返回当前位置的全部全局变量

    print(locals())     以字典类型返回当前位置的全部局部变量

fn()