python的函数递归‘匿名函数’内置函数

一、函数递归

1 什么是函数递归
    函数递归调用（是一种特殊的嵌套调用）：在调用一个函数的过程中，又直接或间接地调用了该函数本身

    递归必须要有两个明确的阶段：
        递推：一层一层递归调用下去,强调每进入下一层递归问题的规模都必须有所减少
        回溯：递归必须要有一个明确的结束条件，在满足该条件时结束递推
            开始一层一层回溯

    递归的精髓在于通过不断地重复逼近一个最终的结果

2、为什么要用函数递归


3、如何用



import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(3000)
def foo(n):
    print('from foo',n)
    foo(n+1)
foo(0)

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

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

foo()

age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 26

age(n) = age(n-1) + 2 #n > 1
age(1) = 26           #n = 1


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

print(age(5))


l=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]

def tell(l):
    for item in l:
        if type(item) is list:
            #继续进入下一层递归
            tell(item)
        else:
            print(item)

tell(l)

有一个从小到大排列的整型数字列表
nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]
10 in nums
for item in nums:
    if item == 10:
        print('find it')
        break
else:
    print('not exists')
二分法应用
nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]
def search(search_num,nums):
    print(nums)
    if len(nums) == 0:
        print('not exists')
        return
    mid_index=len(nums) // 2
    if search_num > nums[mid_index]:
        # in the right
        nums=nums[mid_index+1:]
        search(search_num,nums)
    elif search_num < nums[mid_index]:
        # in the left
        nums=nums[:mid_index]
        search(search_num,nums)
    else:
        print('find it')

search(31,nums)

二、匿名函数

有名函数：基于函数名重复使用
def func():
    print('from func')

func()
func()
func()


匿名函数:没有绑定名字的下场是用一次就回收了
def func(x,y): #func=函数的内存地址
    return x + y

res=(lambda x,y:x+y)(1,2)
print(res)

f=lambda x,y:x+y
print(f)
print(f(1,2))

max min map filter sorted
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

max的工作原理
1 首先将可迭代对象变成迭代器对象
2 res=next(可迭代器对象),将res当作参数传给key指定的函数,然后将该函数的返回值当作判断依据
def func(k):
    return salaries[k]

print(max(salaries,key=func)) #next(iter_s)
'egon', v1=func('egon')
'alex', v2=func('alex')
'wupeiqi', v3=func('wupeiqi')
'yuanhao', v4=func('yuanhao')



salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
print(max(salaries,key=lambda k:salaries[k])) #next(iter_s)
print(min(salaries,key=lambda k:salaries[k])) #next(iter_s)


l=[10,1,3,-9,22]
l1=sorted(l,reverse=False)
print(l1)

l2=sorted(l,reverse=True)
print(l2)

salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

names=['张明言','刘华强','苍井空','alex']

map的工作原理
1 首先将可迭代对象变成迭代器对象
2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后将该函数的返回值当作map的结果之一
aaa=map(lambda x:x+"_SB",names)
print(aaa)
print(list(aaa))

print([name+"_SB" for name in names])

filter的工作原理
1 首先将可迭代对象变成迭代器对象
2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res
names=['alexSB','egon','wxxSB','OLDBOYSB']

# print([name for name in names if name.endswith('SB')])

aaa=filter(lambda x:x.endswith('SB'),names)
print(aaa)
print(list(aaa)

三.内置函数

掌握
res='你好'.encode('utf-8')
print(res)

res=bytes('你好',encoding='utf-8')
print(res)

参考ASCII表将数字转成对应的字符
print(chr(65))
print(chr(90))
参考ASCII表将字符转成对应的数字
print(ord('A'))

print(divmod(10,3))输出商和余数放在元祖里


l=['a','b','c']
for item in enumerate(l):
    print(item)按索引取出值

l='[1,2,3]'
l1=eval(l)
print(l1,type(l1))将字符串的列表转换成列表
print(l1[0])

with open('a.txt',encoding='utf-8') as f:
    data=f.read()
    print(data,type(data))
    dic=eval(data)
    print(dic['sex'])将文件中的字典拿出

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

print(round(3.3))四舍五入

print(sum(range(101)))取和


module=input('请输入你要导入的模块名>>: ').strip() #module='asdfsadf'
m=__import__(module)
print(m.time())方便用户输入，用户输入为字符串赋予m以time的功能




# 面向对象里的重点
classmethod
staticmethod
property

delattr
hasattr
getattr
setattr

isinstance
issubclass

object

super


了解
print(abs(-13))负变正
print(all([1,2,3,]))全部为真则为真，[]也为真

print(all([]))

print(any([0,None,'',1]))一个为真则为真
print(any([0,None,'',0]))
print(any([]))

print(bin(3)) #11十进制转二进制
print(oct(9)) #1十进制转八进制
print(hex(17)) #11十六进制转十进制

print(callable(len))判断是否是迭代器对象

import time
print(dir(time)) #列举出所有:time.名字


s=frozenset({1,2,3}) # 不可变集合
s1=set({1,2,3}) # 可变集合

a=1111111111111111111111111111111111111111111111
# print(globals())查看全局作用域名字
# print(locals())查看局部作用域名字
def func():
    x=222222222
    # print(globals())
    print(locals())
func()

hash([1,2,3])不变类型为可hash

def func():
    """
    文档注释
    :return:
    """
    pass

print(help(func))func函数当中的文档注释

l=['a','b','c','d','e']
s=slice(1,4,2)
print(l[1:4:2])
print(l[s])跟切片一样

print(vars())无参跟locals一样用