递归

递归的定义

函数的递归调用：是函数嵌套调用的一种特殊形式
具体是指：在调用一个函数的过程中又直接或者间接地调用到本身

直接调用本身

直接调用本身
def f1():
    print('是我是我还是我')
    f1()
f1()

间接接调用本身

def f1():
    print('===>f1')
    f2()

def f2():
    print('===>f2')
    f1()

f1()

一段代码的循环运行的方案有两种
方式一：while、for循环

while True:
    print(1111)
    print(2222)
    print(3333)

方式二：递归的本质就是循环：

def f1():
    print(1111)
    print(2222)
    print(3333)
    f1()
f1()

需要强调的的一点是：

递归调用不应该无限地调用下去，必须在满足某种条件下结束递归调用

while n < 10:
    print(n)
    n+=1

def f1(n):
    if n == 10:
        return
    print(n)
    n+=1
    f1(n)

f1(0)

递归的两个阶段

回溯：一层一层调用下去
递推：满足某种结束条件，结束递归调用，然后一层一层返回

age(5) = age(4) + 10
age(4) = age(3) + 10
age(3) = age(2) + 10
age(2) = age(1) + 10
age(1) = 18

def age(n):
    if n == 1:
        return 18
    return age(n-1) + 10


res=age(5)
print(res)

递归的应用

l=[1,2,[3,[4,[5,[6,[7,[8,[9,10,11,[12,[13,]]]]]]]]]]

def f1(list1):
    for x in list1:
        if type(x) is list:
            # 如果是列表，应该再循环、再判断,即重新运行本身的代码
            f1(x)
        else:
            print(x)

f1(l)

二分法

算法：是高效解决问题的办法
算法之二分法
需求：有一个按照从小到大顺序排列的数字列表
需要从该数字列表中找到我们想要的那个一个数字
如何做更高效

nums=[-3,4,7,10,13,21,43,77,89]
find_num=10

nums=[-3,4,13,10,-2,7,89]
nums.sort()
print(nums)

方案一：整体遍历效率太低

for num in nums:
    if num == find_num:
        print('find it')
        break

方案二：二分法

def binary_search(find_num,列表):
    mid_val=找列表中间的值
    if find_num > mid_val:
        # 接下来的查找应该是在列表的右半部分
        列表=列表切片右半部分
        binary_search(find_num,列表)
    elif find_num < mid_val:
        # 接下来的查找应该是在列表的左半部分
        列表=列表切片左半部分
        binary_search(find_num,列表)
    else:
        print('find it')

nums=[-3,4,7,10,13,21,43,77,89]
find_num=8
def binary_search(find_num,l):
    print(l)
    if len(l) == 0:
        print('找的值不存在')
        return
    mid_index=len(l) // 2

    if find_num > l[mid_index]:
        # 接下来的查找应该是在列表的右半部分
        l=l[mid_index+1:]
        binary_search(find_num,l)
    elif find_num < l[mid_index]:
        # 接下来的查找应该是在列表的左半部分
        l=l[:mid_index]
        binary_search(find_num,l)
    else:
        print('find it')
binary_search(find_num,nums)

匿名函数

1、def用于定义有名函数

func=函数的内存地址
def func(x,y):
    return x+y
print(func)

2、lamdab用于定义匿名函数

print(lambda x,y:x+y)

3、调用匿名函数
方式一：

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

方式二：

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

4、匿名用于临时调用一次的场景：更多的是将匿名与其他函数配合使用

应用

需求：找出薪资最高的那个人

salaries={
    'siry':3000,
    'tom':7000,
    'lili':10000,
    'jack':2000

def func(k):
    return salaries[k]

========================max的应用
res=max(salaries,key=func) # 返回值=func('siry')
print(res)

res=max(salaries,key=lambda k:salaries[k])
print(res)

========================min的应用
res=min(salaries,key=lambda k:salaries[k])
print(res)

模块

1、什么是模块？
模块就是一系列功能的集合体,分为三大类
I：内置的模块
II：第三方的模块
III：自定义的模块
一个python文件本身就一个模块，文件名m.py，模块名叫m
ps：模块有四种形式
　　1 使用python编写的.py文件
　　2 已被编译为共享库或DLL的C或C++扩展
　　3 把一系列模块组织到一起的文件夹（注：文件夹下有一个init.py文件，该文件夹称之为包)
　　4 使用C编写并链接到python解释器的内置模块
2、为何有用模块
I:内置与第三的模块拿来就用，无需定义，这种拿来主义，可以极大地提升自己的开发效率
II:自定义的模块
可以将程序的各部分功能提取出来放到一模块中为大家共享使用
好处是减少了代码冗余，程序组织结构更加清晰

3、如何用模块
'''
y=333
z=444
import foo

 1、首次导入模块会发生3件事
 1、执行foo.py
2、产生foo.py的名称空间，将foo.py运行过程中产生的名字都丢到foo的名称空间中
 3、在当前文件中产生的有一个名字foo，该名字指向2中产生的名称空间
 之后的导入，都是直接引用首次导入产生的foo.py名称空间,不会重复执行代码

import foo
import foo
import foo
import foo

2、引用：

print(foo.x)
print(foo.get)
print(foo.change)

 强调1：模块名.名字，是指名道姓地问某一个模块要名字对应的值，不会与当前名称空间中的名字发生冲突

x=1111111111111
print(x)
print(foo.x)

 强调2：无论是查看还是修改操作的都是模块本身，与调用位置无关

import foo
x=3333333333
foo.get()
foo.change()
print(x)
print(foo.x)
foo.get()

3、可以以逗号为分隔符在一行导入多个模块
 建议如下所示导入多个模块

import time
import foo
import m

 不建议在一行同时导入多个模块

import time,foo,m

 4、导入模块的规范
I. python内置模块
II. 第三方模块
III. 程序员自定义模块
 import time
 import sys
 import 第三方1
 import 第三方2
 import 自定义模块1
 import 自定义模块2
 import 自定义模块3
 5、import 。。。 as 。。。

import foo as f # f=foo
f.get()
import abcdefgadfadfas
abcdefgadfadfas.f1
abcdefgadfadfas.f2
abcdefgadfadfas.f3
import abcdefgadfadfas as mmm
mmm.f1
mmm.f2
mmm.f3

递归函数