目录

• 递归
  • 什么是递归函数
    • 直接调用
    • 间接调用
  • 为什么要用递归
  • 如何用递归
    • 二分法的应用
• 匿名函数
  • 有名函数
  • 匿名函数
  • 与内置函数联用
• 内置函数
  • 掌握
  • 了解

递归

什么是递归函数

函数的嵌套调用：函数嵌套函数。函数的递归调用：它是一种特殊的嵌套调用，但是它在调用一个函数的过程中，又直接或间接地调用了它自身。

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

# foo()  #进入死循环

如果递归函数不断的调用函数自身，那么这个递归函数将会进入一个死循环，因此我们应该给递归函数一个明确的结束条件。

直接调用

直接调用指的是：直接在函数内部调用函数自身。

import sys

print(f'最大递归层数：{sys.getrecursionlimit()}')

最大递归层数：3000

import sys

# 修改递归层数
sys.setrecursionlimit(10000)

def foo(n):
    print('from foo', n)
    foo(n+1)
# foo(0)

间接调用

间接调用指的是：不在原函数体内调用函数自身，而是通过其他的方法间接调用函数自身。

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

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

# bar()

递归必须要有两个明确的阶段：

1. 递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小。
2. 回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。

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

'''
...
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(6):{age(6)}')

age(6):36

为什么要用递归

递归的本质就是干重复的活，但是仅仅普通的重复，我们使用while循环就可以了。

lis = [1, [2, [3, [4, [5, [6, ]]]]]]

def tell(lis):
    for i in lis:
        if type(i) is list:
            tell(i)
        else:
            print(i)

tell(lis)

1
2
3
4
5
6

如何用递归

二分法的应用

nums = [1, 3, 5, 6, 7, 8, 2, 8, 9, 0, 23, 5, 43]

for i in nums:
    if i == 10:
        print('find it')
        break
else:
    print('not exist')

not exist

当列表数据比较少时，for循环可以实现需求，但是元素非常多时，那就非常复杂，因此我们考虑二分法的思想实现。

from random import randint
nums = [randint(1, 100) for i in range(100)]
nums.sort()
print(nums)

[1, 4, 4, 5, 6, 6, 6, 6, 8, 9, 9, 9, 11, 11, 15, 15, 16, 16, 17, 18, 18, 18, 19, 20, 24, 27, 28, 32, 33, 33, 35, 36, 37, 38, 38, 39, 41, 42, 46, 46, 46, 47, 48, 49, 49, 50, 50, 52, 53, 54, 54, 56, 56, 59, 60, 61, 61, 61, 62, 63, 63, 64, 65, 67, 68, 68, 69, 70, 70, 70, 70, 71, 72, 72, 74, 75, 75, 77, 77, 77, 78, 79, 80, 82, 82, 83, 83, 84, 85, 86, 86, 86, 86, 89, 89, 91, 96, 97, 99, 99]

def search(search_num, nums):
    mid_index = len(nums)//2
    print(nums)
    if len(nums) == 1 and nums[0] != search_num:
        print('not exist')
        return
    if search_num > nums[mid_index]:
        nums = nums[mid_index:]
        search(search_num, nums)
    elif search_num < nums[mid_index]:
        nums = nums[:mid_index]
        search(search_num, nums)
    else:
        print('find it')

search(7, nums)

[1, 4, 4, 5, 6, 6, 6, 6, 8, 9, 9, 9, 11, 11, 15, 15, 16, 16, 17, 18, 18, 18, 19, 20, 24, 27, 28, 32, 33, 33, 35, 36, 37, 38, 38, 39, 41, 42, 46, 46, 46, 47, 48, 49, 49, 50, 50, 52, 53, 54, 54, 56, 56, 59, 60, 61, 61, 61, 62, 63, 63, 64, 65, 67, 68, 68, 69, 70, 70, 70, 70, 71, 72, 72, 74, 75, 75, 77, 77, 77, 78, 79, 80, 82, 82, 83, 83, 84, 85, 86, 86, 86, 86, 89, 89, 91, 96, 97, 99, 99]
[1, 4, 4, 5, 6, 6, 6, 6, 8, 9, 9, 9, 11, 11, 15, 15, 16, 16, 17, 18, 18, 18, 19, 20, 24, 27, 28, 32, 33, 33, 35, 36, 37, 38, 38, 39, 41, 42, 46, 46, 46, 47, 48, 49, 49, 50, 50, 52, 53, 54]
[1, 4, 4, 5, 6, 6, 6, 6, 8, 9, 9, 9, 11, 11, 15, 15, 16, 16, 17, 18, 18, 18, 19, 20, 24]
[1, 4, 4, 5, 6, 6, 6, 6, 8, 9, 9, 9]
[6, 6, 8, 9, 9, 9]
[6, 6, 8]
[6, 8]
[6]
not exist

匿名函数

有名函数

之前定的函数都是有名函数，它是基于函数名使用。

def func():
    print('from func')

func()

from func

匿名函数

匿名函数，它没有绑定名字，使用一次即被收回，加括号即可运行。

lambda x,y :x+y

<function __main__.<lambda>(x, y)>

res = (lambda x,y :x+y)(3,5)
print(res)

8

与内置函数联用

匿名函数通常与max(),sort(),filter(),sorted()方法联用。

salary_dict = {
    'willaim':15000
    'tom':12000
    'jerry':10000
}

1.如果我们想从上述字典中取出薪资最高的人，我们可以使用max()方法，但是max()默认比较的是字典的key。

1. 首先将可迭代对象变成迭代器对象
2. res= next(迭代器对象)，将res当作参数传给key指定的函数，然后将该函数的返回值当作判断依据。

salary_dict = {
    'willaim':15000,
    'tom':12000,
    'jerry':10000,
    'zalexsandra':14000
}

print(f'max(salary-dict):{max(salary_dict)}')

def func(k):
    return salary_dict[k]

print(f'max(salary_dict,key=func):{max(salary_dict,key=func)}')

print(f'max(salary_dict,key=lambda name:salary_dict[name]):{max(salary_dict,key=lambda name:salary_dict[name])}')

max(salary-dict):zalexsandra
max(salary_dict,key=func):willaim
max(salary_dict,key=lambda name:salary_dict[name]):willaim

2.如果想对上述字典中的人，按照薪资从大到小排序，可以使用sorted()方法。

sorted()工作原理：

1. 首先将可迭代对象变成迭代器对象
2. res=next（迭代器对象），将res当作参数传给第二个参数指定的函数，然后将该函数的返回值当作判断依据。

lis = [1,4,2,7,45,9,3]
lis = sorted(lis)
print(f'lis:{lis}')
print(f'sorted(lis,reverse=True):{sorted(lis,reverse=True)}')

lis:[1, 2, 3, 4, 7, 9, 45]
sorted(lis,reverse=True):[45, 9, 7, 4, 3, 2, 1]

salary_dict = {
    'willaim':15000,
    'tom':12000,
    'jerry':10000,
    'zalexsandra':14000
}

print(f'sorted(salary_dict,key=lambda name:salary_dict[name]):{sorted(salary_dict,key=lambda name:salary_dict[name])}')

sorted(salary_dict,key=lambda name:salary_dict[name]):['jerry', 'tom', 'zalexsandra', 'willaim']

3.如果我们想对一个列表中的某个人名做处理，可以使用map()方法。

map()工作原理：

1. 首先将可迭代对象变成迭代器对象
2. res=next（迭代器对象），将res当作参数传给第一个参数指定的函数，然后将该函数的返回值作为map()方法的结果之一。

name_list = ['tom','jerry','sandra']

res = map(lambda name:f'{name} is funny',name_list)
print(list(res))

['tom is funny', 'jerry is funny', 'sandra is funny']

4.如果我们想筛选除名字中含有‘funny‘的名字，我们可以使用filter()方法。

filter()工作原理：

1. 首先将可迭代对象变成迭代器对象
2. res=next（迭代器对象），将res当作参数传给第一个参数指定的函数，然后filter会判断函数返回值的真假，如果为真则留下。

内置函数

掌握

1.bytes()

2.chr()/ord()

3.divmod()

4.enumerate()

5.eval()

6.hash()

# bytes() 解码字符

res = '你好'.encode('utf8')
print(res)

res = bytes('你好',encoding='utf8')
print(res)

b'\xe4\xbd\xa0\xe5\xa5\xbd'
b'\xe4\xbd\xa0\xe5\xa5\xbd'

# chr()参考ASCII码表将数字转换为对应字符；ord()将字符转换为对应数字。
print(chr(65))

print(ord('B'))

A
66

# divmod() 分栏  (x//y,x%y)

print(divmod(10,3))

(3, 1)

# enumerate() 带有索引迭代

lis = ['a','b','c','d']
for i in enumerate(lis):
    print(i)

(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')

# eval() 把字符串翻译成数据内型,''里面必须是数据类型

s = '[1,2,3]'
lis_eval = eval(s)
print(type(s))
print(lis_eval,type(lis_eval))

<class 'str'>
[1, 2, 3] <class 'list'>

# hash() 是否可哈希，可哈希则不可变

print(hash(1))

# print(hash([1,2,3]))  TypeError: unhashable type: 'list'

1

了解

1.abs()

2.all()

3.any()

4.bin()/oct()/hex()

5.dir()

6.frozenset()

7.globals()/locals()

8.pow()

9.round()

10.slice()

11.sum()

12.import()

# abs() 求绝对值

print(abs(-18))

18

# all() 可迭代元素全为真，则返回真。

print(all([0,1,2,3,4]))

print(all([]))

False
True

# any() 可迭代对象中有一元素为真，则为真
print(any([1,0,None]))

print(any([]))

True
False

# bin()/oct()/hex() 二进制、八进制、十六进制

print(bin(17))

print(oct(17))

print(hex(17))

0b10001
0o21
0x11

# dir() 列举模块所有功能

import time

print(dir(time))

['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname']

# frozenset() 集合变为不可更改

s = {1,2,3}
s.add(4)
print(s)
s = frozenset(s)
# s.add(5)  AttributeError: 'frozenset' object has no attribute 'add'
print(s)

{1, 2, 3, 4}
frozenset({1, 2, 3, 4})

# globals()/locals() 查看全局名字；查看局部名字

#print(globals())

#print(locals())

# pow() 

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

1

# round()  四舍五入

print(round(3.5))

print(round(3.4))

4
3

# slice() 

lis = ['a','b','c']
s = slice(1,4,1)
print(lis[s]) # print(lis[1:4:1])

['b', 'c']

# sum()

print(sum(range(1,101)))

5050

# __import__() 通过字符串导入模块

m = __import__('time')
print(m.time())

1559718343.887399

原文地址：https://www.cnblogs.com/WilliamKong94/p/11005382.html