--遞歸本質
　　函數調用是通過棧(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 和 迭代器 能夠產生惰性序列

?

轉載于:https://www.cnblogs.com/bling-bling-star/p/9382688.html

總結

以上是生活随笔為你收集整理的Python_面向对象_递归的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。