函数的啥调用是一个函数直接或间接地调用它自身

Posted 2023-03-20

在调用一个函数的过程中可以直接或间接的调用该函数,这种调用称为（递归 ）调用。该函数称为（递归 ）函数。 参考技术A 一个函数直接或间接地调用自身，这样的调用称为递归调用。

函数5

一. 递归函数

1. 定义：特殊的嵌套调用，在调用一个函数的过程中，又直接或间接地调用了它自身。

2. 直接调用和间接调用

• 直接调用

def story():
    s = """
    从前有个山，山里有座庙，庙里老和尚讲故事，
    讲的什么呢？
    """
    print(s)
    story()
            
story()
        

 

• 间接调用

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

 

3. 执行递归函数的两个阶段

1. 递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小。

2. 回溯：递归必须有一个明确的结束条件，在满足条件下一层层回溯。

4. 递归函数求年龄

    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 
    age(1) = 26  # n=1
    ‘‘‘
    
    
    def age(n):
        if n == 1:
            return 26
        res = age(n-1) + 2
        return res
    
    
    print(f"age(5): age(5)")
    
    输出：
    age(5): 34

 

二. 几种新的内置函数

• bytes（解码字符）

res = ‘你好‘.encode(‘utf8‘)
print(res1)

res = bytes(‘你好‘, encoding=‘utf8‘)
print(res2)

print(res1)
print(res2)

输出：
b‘\xe4\xbd\xa0\xe5\xa5\xbd‘
b‘\xe4\xbd\xa0\xe5\xa5\xbd‘

 

• chr（参考ASCII码表将数字转成对应字符），ord（将字符转换成对应的数字）

print(chr(65))
print(ord(‘A‘))
    
输出：
A
65

 

• divmod（取整取余，返回元组）

print(divmod(10, 3))

输出：
(3, 1)

 

• enumerate（带有索引的迭代）

l = [‘a‘, ‘b‘, ‘c‘]
for i in enumerate(l):
    print(i)
    
输出：
(0, ‘a‘)
(1, ‘b‘)
(2, ‘c‘)

 

• eval（把字符串翻译成数据类型）

lis = ‘[1,2,3]‘
lis_eval = eval(lis)
print(lis_eval)
    
输出：
[1, 2, 3]

 

• hash（是否可哈希）

print(hash(1))
    
输出：
1

 

 

三. 匿名函数

1. 格式

   函数名 = lambda 参数 : 返回值

2. 特点

• 参数可以有多个，用逗号隔开

• 匿名函数不管逻辑多复杂，只能写一行，逻辑执行结束后的内容就是返回值。

• 返回值和正常函数一样可以是任意数据类型

3. 匿名函数与内置函数的联用

• max（）取出字典中薪资最高的人

salary_dict = 
    ‘a‘: 12000,
    ‘b‘: 13000,
    ‘c‘: 10000,
    ‘d‘: 14000

        
def func(k):
    return salary_dict[k]
print(max(salary_dict, key=func))
        
print(max(salary_dict, key=lambda name: salary_dict[name]))
        
输出：
‘d‘
‘d‘

 

• sorted（）将字典中的人按照薪资从大到小排序

salary_dict = 
    ‘a‘: 3000,
    ‘b‘: 100000,
    ‘c‘: 5000,
    ‘d‘: 2000

                
print(sorted(salary_dict, key=lambda name: salary_dict[name]))
        
输出：
[‘d‘, ‘a‘, ‘c‘, ‘b‘]

 

1. • map（）将列表中每个元素加上‘aaa’后缀

name_list = [‘a‘, ‘b‘, ‘c‘, ‘d‘]
        
res = (map(lambda name: f‘name 123‘, name_list))
print(list(res))
        
输出
[‘a 123‘, ‘b 123‘, ‘c 123‘, ‘d 123‘]

 

• filter（）去除列表中不是尾部123结尾的元素

name_list = [‘a‘, ‘b123‘, ‘c123‘, ‘d123‘]
        
filter_res = filter(lambda name: name.endswith(‘123‘), name_list)
print(list(filter_res))
        
输出：
[‘b123‘, ‘c123‘, ‘d123‘]