模块递归函数

 

剩余的内置函数

map： 映射

map（函数地址，可迭代对象） ---> map对象

map回将可迭代对象中的每一个值进行修改，然后映射一个map对象中

可以再将map对象转换成列表/元组

注意：只能转一次

 

def func():

    pass

    map(func)

 

 

# 姓名列表

 

 

 

 

name_list = ['egon', 'jason', 'sean', '大饼', 'tank']

map_obj = map(lambda name: name + '喜欢吃生蚝' if name == 'tank' else name + 'DJB', name_list)

print(map_obj)     # map_obj ---> list/tuple

print(tuple(map_obj))

 

 

<map object at 0x000001A31078A848>

('egonDJB', 'jasonDJB', 'seanDJB', '大饼DJB', 'tank喜欢吃生蚝')

 

reduce：合并

reduce（函数地址，可迭代对象，默认为0）

reduce（函数地址，可迭代对象，初始值）

reduce

from functools import reduce

每次从可迭代对象中获取两个值进行合并，

初始值：执行reduce函数时，都时从初始值开始合并

reduce（lambda x, y: x + y, range(1, 101), 0）

需求：求1-100的和

普通方式:

 

init = 0

for line in range(1, 101):

    init += line

print(init)

 

 

5050

reduce求值：

 

from functools import reduce

res = reduce(lambda x, y: x + y, range(1, 101), 0)

print(res)

 

 

5050

 

filter：过滤

filter（函数地址，可迭代对象）---> filter 对象

 

# filter

name_list = ['egon_dsb', 'jason_dsb', 'sean_dsb', '大饼_dsb', 'tank']

filter_obj = filter(lambda x: x, name_list)

# 将后缀为_dsb的名字“过滤出来”

# filter会将函数中返回的结果为True 对应的参数值“过滤出来”

# 过滤出来的值会添加到filter对象中

filter_obj = filter(lambda name: name.endswith('_dsb'), name_list)

print(filter_obj)

print(list(filter_obj))

 

 

<filter object at 0x0000026CAE153348>

['egon_dsb', 'jason_dsb', 'sean_dsb', '大饼_dsb']

 

递归函数：

函数递归指的是重复“直接调用或间接调用”函数本身

这是一种函数嵌套调用的表现形式

直接调用：指得是在函数内置，直接调用函数本身

间接调用：两个函数之间相互调用间接造成递归

需要知道：面试可能会问：

python中有递归默认深度：限制递归次数

998， 1000

ps：但是在每一台操作系统中都会根据硬盘来设置默认递归深度

获取递归深度：

sys.getrecursionlimit()

设置递归深度：

sys.setrecursionlimit(深度值)

注意：单纯的递归调用时没有任何意义的

 

def fucn():

    print('from func')

    fucn()

fucn()

 

 

from func

from func

from func

from func

Traceback (most recent call last):

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 37, in <module>

    fucn()

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 36, in fucn

    fucn()

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 36, in fucn

    fucn()

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 36, in fucn

    fucn()

  [Previous line repeated 993 more times]

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 35, in fucn

    print('from func')

RecursionError: maximum recursion depth exceeded while calling a Python object

 

print(sys.getrecursionlimit())  # 打印系统默认递归深度

 

 

1000

 

import sys  # 获取操作系统资源的模块

sys.setrecursionlimit(2000)     # 设置递归深度

print(sys.getrecursionlimit())

 

 

2000

查看当前可以承受的递归深度

 

num = 1

def func():

    global num

    print("from func", num)

    num += 1

    func()

func()

 

 

 

 

from func 994

from func 995

from func 996

Traceback (most recent call last):

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 56, in <module>

    func()

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 55, in func

    func()

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 55, in func

    func()

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 55, in func

    func()

  [Previous line repeated 993 more times]

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 53, in func

    print("from func", num)

RecursionError: maximum recursion depth exceeded while calling a Python object

 

交叉循环

 

def foo():

    print('from foo')

    goo()

 

 

 

 

def goo():

    print('from goo')

    foo()

 

 

foo()

 

 

 

 

from foo

from goo

Traceback (most recent call last):

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 69, in <module>

    foo()

  File "C:/Users/ever/PycharmProjects/untitled/oldboy/正式开班/day14/剩余内置函数.py", line 62, in foo

    goo()

 

想要递归有意义，必须遵循两个条件：

回溯：

指得是重复的执行，每一次执行都要拿到一个更接近于结果的结果

回溯必须有一个终止条件

递推：

当回溯找到一个终止条件后，开始一步一步往上递推

age5 == age4 + 2

age4 == age3 + 2

age3 == age2 + 2

age2 == age1 + 2

age == 18 # 回溯终止得结果result = age(n -1) + 2

 

def age(n):

    if n == 1:

        return 18

    return age(n - 1) + 2

 

 

 

 

res = age(5)

 

 

 

 

26

 

模块

什么是包？

包指得是内部包含 _init._py的文件夹

包的作用：

存放模板，包可以更好的管理模板

什么是模块？

模块是一系列功能的结合体

#相当于与模块包着一堆函数与代码

模块本质上是一个个的.Py文件

模块的三种来源：

1：python内置的模块：（python解释器的）

比如： sys\time\turtle

2：第三方的模块：(别人写的)

比如：requests

3：自定义的模块：（自己写的）

比如：自己定义的demo.py

模块的四种表现形式：

1：使用python编写的py文件

2：编译后的共享库DLL或者是c或者c++库

3：包下面带有init.py的一组py文件

py_demo

init___.py

demo.py

demo2.py

4:python解释器下的py文件

python解释器下的文件夹

一个个的py文件

二 为什么要使用模块？

模块可以帮我们更好的管理功能代码，比如：函数

可以将项目拆分成一个个的功能，分别存放在不同的py文件（模块）中

三 如果创建，编写模块，并使用模块

鼠标右键创建py文件

在py文件编写python代码

在一个文件中，通过import关键字导入模块

import 模块名

注意：import 模块时，模块不能加.py后缀

在使用模块阶段，必须要注意，谁在执行文件，谁是被导入文件（被导入的模块）

模块在首次导入时，就已经固定好了，当前文件查找的顺序是先从内存中查找

模块在导入时发生的事情

1：会先执行当前执行文件，并产生执行文件中的名称空间

2：会执行到导入模块的代码时，被导入的模块会产生一个模块的名称空间

3：会将被导入的模块的名称空间加载到内存中

给模块起别名as

import 模块 as 模块的别名

模块的导入方式

import 模块

在执行文件中直接import导入

from 包/模块 import 模块/(函数名、变量名、类名）

在执行文件中直接import导入

循环导入问题：

model1.py

from model2 import name

name = 'jason'

model2.py2

from model1 import name

name = 'tank'

解决循环导入问题：

1：需要查找的名字放在导入模块的上方

2：在函数内部导入，将模块变成函数名称空间中的名字

软件开发目录规范：

conf：

用于存放配置文件的文件夹

core：

核心业务代码 .py

interface：

接口，接口内写获取数据前的逻辑代码，通过后踩能获取数据

db：

用于存放文件数据

lib：

存放公告功能文件

log：

用于存放日志文件，日志用于记录

bin：

里面存放启动文件 / 启动文件

readme.txt：

项目说明书，告诉用户使用者项目的操作