Python_面向对象_递归

Posted 2020-12-25 bling-bling-star

--递归本质
　　函数调用是通过栈(stack)这种数据结构实现的
　　每当进入一个函数调用,栈区就会加一层栈帧,
　　每当函数返回,栈区就会减一层栈帧,但栈区空间有限,要注意防止栈溢出

# 递归函数：在函数内部，自己调用其自身即是递归函数
# 递归最简易的原型

"""
　　递归非常占用内存空间，使用递归如果层级过大 不建议使用，内存容易溢出
　　递归每一层调用的函数空间必须都执行完毕才算结束
　　不能无限递归，需要给递归限制跳出的条件
"""

 

def digui(n):
　　print(n)
　　if n>0:
　　　　digui(n-1)
　　　　print(n)
digui(5)

 

def jiecheng(n):
　　if n == 1:
　　　　return 1
　　return n * jiecheng(n-1)

res2 = jiecheng(5)
print(res2)

--尾递归
　　尾递归:在函数返回的时候，调用其本身，并且，return语句不包含表达式。(简单来说是递归函数,且只调用自己非表达式)
　　尾递归意义:使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况.(需要Python解释器支持)

 

def fact(n):
　　return fact_iter(n, 1)

def fact_iter(num, product):
　　if num == 1:
　　　　return product
　　return fact_iter(num - 1, num * product)

res = fact(5)
print(res)

 

　　***了解内容--start--***
　　　　栈:后进先出的一种数据结构
　　　　堆:排序后的一种树状数据结构

　　--内存中的栈区 : 自动分配 自动释放
　　　　栈区:按照后进先出的数据结构(栈),无论创建或销毁都是自动为数据分配内存,释放内存(系统自动做的)
　　--内存中的堆区 : 手动分配 手动释放
　　　　堆区:按照排序后的树状数据结构(堆),可优先取出必要数据,无论创建或销毁都是手动分配内存,释放内存(程序员手动做的)

　　运行程序时在内存中执行,会因为数据类型的不同而在内存的不同区域运行
　　因不同语言对内存划分的机制不一,但大体来讲,有如下四大区域
　　　　栈区: 分配局部变量空间.
　　　　堆区: 是用于手动分配程序员申请的内存空间.
　　　　静态区(全局栈区): 分配静态变量，全局变量空间.
　　　　代码区(只读区,常量区): 分配常量和程序代码空间的.

　　　　栈区 堆区 静态区 代码区 都是内存中的一段空间
　　***了解内容--end--***

--匿名函数:lambda表达式

"""
　　lambda语法：lambda 参数 : 返回值
　　不带参数的写法 #案例 lambda : 10
　　带参数的写法 案例：lambda a,b： a+b
　　条件分支的写法 lambda n : "偶数" if n % 2==0 else "奇数"
"""
# 案例1 不带参数
def niminghanshu():
　　return 10

res = lambda : 10
print(res())

# 案例2 带上参数
def niminghanshu2(a,b):
　　return a+b

func = lambda a,b : a+b
res = func(5,6)
print(res)

# 案例3 条件分支写法
def niminghanshu3(n):
　　if n % 2 == 0:
　　　　return "偶数"
　　else:
　　　　return "奇数"

func = lambda n : "偶数" if n % 2==0 else "奇数"
res = func(11)
print(res)

# 迭代器:可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator 迭代器是对象)
# 迭代器是一种惰性序列,它通过计算把值依次的返回,而不是一次性的得到所有数据放到内存中

# 迭代器
for i in range(1,10):
　　print(i)

from collections import Iterable,Iterator
res1 = isinstance(range(1,10), Iterable) #判断是否是
# 可迭代的 可迭代的对象
res2 = isinstance(range(1,10),Iterator)
print(res1)
print(res2)

# 用iter 函数 把具有可迭代性的数据 转换成 迭代器
res3 = iter(range(1,10))
print(res3)
res4 = isinstance(res3,Iterator)
print(res4)
"""
res5 = range(1,10)
next(res5)
"""
print("<==>")
res6 = iter(range(1,5))

print("<==123==>")

print(res6)
res7 = next(res6)
res8 = next(res6)
res9 = next(res6)
res10 = next(res6)

"""

# Iterable可迭代的 Iterator迭代器
from collections import Iterable,Iterator
res1 = isinstance(range(1,10), Iterable) #判断是否是可迭代的
res2 = isinstance(iter(range(1,10)), Iterator) #判断是否是迭代器
res3 = list(range(1,10)) #list可以强转具有迭代性的数据或者迭代器
print(res1)
print(res2)
print(res3)

"""
# 首先获得Iterator对象: 通过iter把可迭代对象 转换成 迭代器
it = iter([1, 2, 3, 4, 5])

　　　　***了解内容--start--***
　　　　# 循环:
　　　　while True:
　　　　　　try:
　　　　　　　　# 获得下一个值:
　　　　　　　　x = next(it)
　　　　　　except StopIteration:
　　　　　　　　# 遇到StopIteration就退出循环
　　　　　　　　break
　　　　***了解内容--end--***

惰性序列:没有一次性的把所有数据都放在序列中,而是遍历一个放一个,这样的序列
range 是 可迭代对象
range 和 迭代器 能够产生惰性序列