递归，匿名函数，内置函数

Posted 2021-11-26 komorebi

带参装饰器 ：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()