函数03&模块01

1 递归调用

1.1 递归

1.1.1 简介

• 函数递归调用:在调用一个函数的过程中又调用了自己

• 本质:循环的过程-->用函数来实现循环

• 注意点:

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

  Ⅱ python不是函数式编程语言，无法对递归进行尾递归优化

1.1.2 递归的两个阶段

Ⅰ 回溯---->一层层向下挖

Ⅱ 递推---->一层层往上爬

1.1.3 使用

def f1():
    print(111)
    print(222)
    print(333)
    f1()
f1()  # 先递归执行，超过最大限制后报错RecursionError

# 可以修改最大限制
import sys
print(sys.getrecursionlimit())  # 默认1000
sys.setrecursionlimit(2000)  # 修改为2000
print(sys,getrecursionlimit())  # 2000

# 示例(求5的年龄)
# age(5)=age(4)+10
# age(4)=age(3)+10
# age(3)=age(2)+10
# age(2)=age(1)+10
# age(1)=18
# 求5的年龄
# n>1 age(n)=age(n-1)+10
# n=1 age(1)=18

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

res = age(5)
print(res)  # 58

# 示例二
l = [1,[2,[3,[4,[5,[6,[7]]]]]]]
def func(l):
    for x in l:
        if type(x) is not list:
            # x不是列表
            print(x)
        else:
            # x是列表
            # 重新调用本段代码，传入一个新列表x
            func(x)

func(l)  # 1 2 3 4 5 6 7

1.2 二分法

nums = [-3,4,7,13,17,21,98,102,108]
find_num = 98

def choose(find_num,nums):
    if len(nums) == 0:
        print('no search')
        return
    mid_num = len(nums) // 2
    if find_num > nums[mid_num]:
        # in the right
        new_num = nums[mid_num + 1:]
        choose(find_num,new_num)
    elif find_num < nums[mid_num]:
        # in the right
        new_num = nums[:mid_nums]
        choose(find_num,new_num)
    else:
        print('find it')

choose(102,nums)
choose(22,nums)

2 内置函数补充

1、filter 过滤
names = ['egon','lxx_sb','hxx_sb']
res = filter(lambda name: name.endswith("sb"),names)
print(list(res))  # ['lxx_sb','hxx_sb']

names = ['egon','hxx_sb']
res = (name for name in names if name.endswith("sb"))
print(list(res))  # ['lxx_sb','hxx_sb']


2、map 映射
names = ["egon","lxx","hxx"]
res = map(lambda name:name if name == "egon" else name+"_sb",names)
print(res)  # <map object at 0x0000020E897D5B50>
print(list(res))  # ['egon','hxx_sb']

names = ["egon","hxx"]
res = [name if name == "egon" else name+"_sb" for name in names]
print(res)  # ['egon','hxx_sb']


3、reduce
from functools import reduce
res = reduce(lambda x,y: x+y,"hello","xxx")
print(res)  # xxxhello

from functools import reduce
res = reduce(lambda x,[1,2,3],100)
print(res)  # 106


lambda


4、set可变集合/frozenset不可变集合
s = frozenset({1,3})  # 不可变
s1 = set({1,3})  # 可变
s1.add(4)
print(s1)  # {1,3,4}

5、locals局部变量/globals全局变量
x = 3333333
def func():
    x = 1
    y = 2
    print(locals())
    print(globals())


func()  # {'x': 1,'y': 2}
        # {'__name__': '__main__',...}
a = 2222211
print(locals())  # {'__name__': '__main__',...}
print(globals())  # {'__name__': '__main__',...}
print(locals() is globals())  # True


6、hash返回散列值
print(hash("asaasdf"))  # -9196404338305892359


7、pow(base**exp % mod)
res = pow(10,3)  # 10 ** 3 % 3
print(res)  # 1


8、reversed 反序
res = reversed([11,333,222,77])
print(list(res))  # [77,11]


9、round 四舍五入
print(round(3.5))  # 4


10、slice 切片
l = [11,22,33,44,55,66,77,88,99]
s = slice(0,2)
res1 = l[s]
print(res1)  # [11,77]

res2 = l[0: 7: 2]
print(res2)  # [11,77]


11、zip 拉链
s1 = "hello"
l = [11,66]
res1 = zip(s1,l)
print(list(res1))  # [('h',11),('e',22),('l',33),44),('o',55)]
res2 = zip(l,s1)
print(list(res2))  # [(11,'h'),(22,'e'),(33,'l'),(44,(55,'o')]

3 模块01

3.1 模块简介

1、什么是模块
    模块就是一系列功能的集合体
2、模块四种通用的类型
    Ⅰ 一个python文件就是一个模块，文件名test.py，模块名为test
    Ⅱ 盛放有多个py文件的文件夹也是一个功能的集合体，也是一种模块
        相当于一个超级模块，称之为包
    Ⅲ 已被编译为共享库或DLL的C或C++扩展
    Ⅳ 使用C编写并链接到python解释器的内置模块
3、模块的三种来源
    Ⅰ 自带的模块
        ①内置模块
        ②标准库
    Ⅱ 第三方模块
        pip3 install requests
    Ⅲ 自定义模块
4、为何要采用模块
    Ⅰ 自带以及第三方模块->拿来主义，提升开发效率
    Ⅱ 自定义模块->减少代码冗余

3.2 模块导入方式

3.2.1 import

# 首次导入模块会发生的事
# 1、会触发模块文件的运行，产生一个模块的名称空间
#    运行模块文件过程中产生的名字都丢到模块的名称空间
# 2、在当前名称空间中产生一个名字spam，该名字执行模块的名称空间
# 后续的导入，模块名会直接引用首次导入创造好的名称空间

• 首先自定义一个模块spam.py

# spam.py
print("from the spam.py")

money = 1000

def change():
    global money
    money = 0

def func1():
    print("----->%s" % money)

def func2():
    print('=====>')
    func1()

• 调用

import spam  # from the spam.py
print(spam.func1)  # <function func1 at 0x000001DBFAE58280>
print(spam.func2)  # <function func2 at 0x000001DBFAE588B0>
print(spam.change)  # <function change at 0x000001DBFAC38700>
print(spam.money)  # 1000
spam.func1()  # ----->1000
spam.func2()  # =====>
spam.change()  # ----->1000


import spam
money = 2000
spam.func1()  # ----->1000

def func1():
    print(222221)
spam.func1()  # ----->1000
func1()  # 222221

3.2.2 from ... import ...

• 优势:使用起来更方便
• 劣势:容易与当前执行文件中的名字冲突

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!