python遞迴 及 物件導向初識及編程思想

標籤：類的方法   表示   情況   str   執行個體名   演算法   sof   函數調用   mes   

一、遞迴

1、定義：

　　在函數內部，可以調用其他函數。如果一個函數在內部調用自身本身，這個函數就是遞迴函式。

　　（1）遞迴就是在過程或函數裡調用自身；
　　（2）在使用遞迴策略時，必須有一個明確的遞迴結束條件，稱為遞迴出口。

1 def age(n):2     if n ==1:   #條件判定3         return 10  #返回一個結果4     else:5         return age(n-1)+2  #重複調用函數本身，系統會將運算的結果存放到棧，然後再依次的進行取值調用。6 print(age(5))   #列印結果

　執行結果：18

2、優缺點：　　

　　遞迴函式的優點是定義簡單，邏輯清晰。理論上，所有的遞迴函式都可以寫成迴圈的方式，但迴圈的邏輯不如遞迴清晰。

　　遞迴的缺點：遞迴演算法解題的運行效率較低。在遞迴調用的過程當中系統為每一層的返回點、局部量等開闢了棧來儲存。遞迴次數過多容易造成棧溢出等。

def func():    print("*******")    func()func()#執行結果 [Previous line repeated 993 more times]*******  File "F:/py_fullstack_s4/day26/遞迴.py", line 8, in func*******    print("*******")*******RecursionError: maximum recursion depth exceeded while calling a Python object

3、遞迴編程的注意點：

　　1. 必須有一個明確的結束條件。

　　2. 每次進入更深一層遞迴時，問題規模相比上次遞迴都應有所減少。

　　3.遞迴效率不高，遞迴層次過多會導致棧溢出（在電腦中，函數調用是通過棧（stack）這種資料結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以，遞迴調用的次數過多，會導致棧溢出）。

4、此處引出一個新的知識點：二分法

　　二分法，是一種快速尋找的方法，時間複雜度低，邏輯簡單易懂，總的來說就是不斷的除以2除以2...

　　他主要應用於有序序列中，原理是每次尋找都將原序列折半，逐漸縮小尋找範圍的一種演算法。應用於遞迴，迴圈之中，直到找到結果。

#運用 遞迴 和 二分法 的運算方式，尋找列表中的某個值data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]num = int(input("please input your want to find number:"))def search(num,data):    if len(data) > 1:      #排除清單分割，僅剩一個元素的情況         #二分法#        a = int(len(data)//2)   #將計算資料行表的長度，除以2  取整數        mid_value = data[a]     #取當前中間的值        if num > mid_value:     #要找的值 大於 中間的值            data = data[a:]     #將原列表從中間值往後，取出來，構建一個新列表            search(num,data)    #遞迴判斷        elif num < mid_value:   #要找的值 小於 中間的值            data = data[:a]     #將原列表開始到中間值，取出來，構建一個新列表            search(num,data)    #遞迴判斷        else:                   #正好是這個值            print("find it!!",num)            return          #列印    else:                         #判斷列表分割，僅剩一個元素的情況        if data[0] == num:            print(‘find it!! %s‘%data[0])        else:                     #列表中沒有這個值            print(‘not this num %s‘%num)search(num,data)#執行結果：please input your want to find number:18find it!! 18

二、函數式編程介紹

1、用def模仿數學中函數的方式，傳一個值，就得一個結果。不會修改外部的狀態。
2、代碼非常的精簡，直接導致可讀性非常差。

三、物件導向的程式設計

1、前提鋪墊：

　　python中一切皆為對象，python 3統一了類與類型的概念，類型即是類。例如：int，str，list，等等……

　　程式設計語言中，是先有了類，然後再產生一個個對象。而現實生活中正好相反。

　　明確一點：物件導向編程是一種編程方式，此編程方式的功能需要使用 “類” 和 “對象” 來實現，所以，物件導向編程其實就是對 “類” 和 “對象” 的使用。

　　類就是一個模板，模板裡可以包含建立多個函數，函數裡實現自訂的功能

　　對象則是根據模板建立的執行個體，通過執行個體(對象)可以執行類中定義的函數

2、文法：

　　1）建立類：class是關鍵字，表示類 class *** #建立類
　　2）建立對象：類名稱後加括弧 將結果賦給一個變數 即可 x = ***() #建立對象

 

 1 class hello:  #任意定義一個類 2     camp = ‘hello world‘ 3     def f(self): 4         print("f") 5 h = hello() # 類執行個體化 6 print(h) #列印 7  8 #執行結果： 9 10 <__main__.hello object at 0x00000000026C9630>

3、類與對象

1）什麼是對象：
　　以遊戲舉例：英雄聯盟，每個玩家選一個英雄，每個英雄都有自己的特徵和和技能，特徵即資料屬性，技能即方法屬性，特徵與技能的結合體就一個對象。

2）什麼是類：
　　從一組對象中提取對象共同的 特徵，技能，構成一個類。類也是特徵與技能的結合體，特徵即資料並且是所有對象共用的資料，技能即函數屬性並且是所有對象共用的函數屬性。　

　　①優點：解決了程式的擴充性，對某個對象進行修改，會立刻反映到整個體系中
　　②缺點：可控性差，無法預測最終的結果。
　　物件導向的程式設計並不是程式全部。對於軟體品質來說，物件導向的程式設計只是用來解決擴充性的問題。

def 或是 class 都是在定義一個函數名。class 定義 類 　　 camp 陣營 　　 attack(self) 技能 　　 nickname暱稱 　　 init 開始，初始

3）如何使用類：
　一、執行個體化

　　類的執行個體化就會產生一個執行個體（對象）。 可以理解為類加()把虛擬東西執行個體化，得到具體存在的值，叫做類的執行個體化。

class Garen:  #定義一個類    camp = ‘Demacia‘def attack(self):    print(‘attack‘)g1 = Garen() #類的執行個體化，產生一個對象，可以調用類內包括的所有特徵（共性）。print(g1)  #列印#執行結果：<__main__.Garen object at 0x00000000028C9CC0>

　二、類通過.（點）的方式引用特徵（類的變數）和技能（類的函數（類內部還是定義的函數，調用的話還是需要傳入參數））

class Garen:    camp=‘Demacia‘    def attack(self):        print(‘attack‘)print(Garen.camp)  #查看campprint(Garen.attack)   #列印資料類型Garen.attack(‘nihao‘) #由於是調用有參函數，需要傳值#執行結果：Demacia<function Garen.attack at 0x000000000229C950>attack

2、對象之間也有不同，及除了同性也有特性。例如暱稱！

class Garen:    camp=‘Demacia‘    def __init__(self,nickname):        self.nick=nickname  #給執行個體自己定義一個別名，由外部傳入 #g1.nick = ‘草叢倫‘    def attack(self,enemy):        # print(‘---------->‘,self.nick) #g1.nick        print(‘%s attack %s‘ %(self.nick,enemy))g1=Garen(‘草叢倫‘) #類執行個體化，類Garen觸發調用_init_ #Garen._init_(self,‘NB‘)g2=Garen(‘劉下‘)print(g1.nick)g1.attack(‘alex‘)#執行結果：草叢倫草叢倫 attack alex

self 指自己。

注意：類的執行個體化就會自動觸發類內_init_函數的執行。

3、怎麼調用類的特徵與技能

注意：類與對象之間的Binder 方法。調用Binder 方法，python 會自動傳值，會將調用者本身當作參數傳給self，第一值。
print(gi.attack) #調用Binder 方法，類綁定給g1
print(Garen.attack) #函數

class Garen:    camp=‘Demacia‘    def __init__(self,nickname):        self.nick=nickname  #給執行個體自己定義一個別名，由外部傳入 #g1.nick = ‘草叢倫‘    def attack(self,enemy):        # print(‘---------->‘,self.nick) #g1.nick        print(‘%s attack %s‘ %(self.nick,enemy))g1=Garen(‘草叢倫‘) #類執行個體化，類Garen觸發調用_init_ #Garen._init_(self,‘NB‘)g2=Garen(‘劉下‘)print(g1.nick)  #暱稱print(g1.camp)  #陣營print(g1.attack)  #列印 查看Binder 方法print(Garen.attack)  # 列印 函數#執行結果：草叢倫Demacia<bound method Garen.attack of <__main__.Garen object at 0x0000000002299D68>><function Garen.attack at 0x000000000229C9D8>

Garen.attack(參數)# 調用的是函數，需要傳參
g1.attack(‘alex‘) #self = g1；enemy = ‘alex‘若是函數有多個值，就在賦值的時候，傳入其他的參數。

print(g1.nick)

只要是對象觸發的，調用的時候就會自動給調用的函數傳值，將自身傳到第一個參數self。若是函數有多個值，就在賦值的時候，對應的傳入其他的參數。

class Garen:    camp=‘Demacia‘    def __init__(self,nickname):        self.nick=nickname  #給執行個體自己定義一個別名，由外部傳入 #g1.nick = ‘草叢倫‘    def attack(self,enemy):        # print(‘---------->‘,self.nick) #g1.nick        print(‘%s attack %s‘ %(self.nick,enemy))g1=Garen(‘草叢倫‘) #類執行個體化，類Garen觸發調用_init_ #Garen._init_(self,‘NB‘)g2=Garen(‘劉下‘)print(g2.nick)print(g2.camp)#執行結果：劉下Demacia

三、總結：
1、類：一：執行個體化，二：引用名字（類名.變數名，類名.函數名） 得到一個記憶體位址，加()就能運行。

2、執行個體（對象）：引用名字(執行個體名.類的變數，執行個體名.Binder 方法，執行個體名.執行個體自己的變數名)

3、類：
　優點：解決了程式的擴充性，對某個對象進行修改，會立刻反映到整個體系中
　缺點：可控性差，無法預測最終的結果。
　　物件導向的程式設計並不是全部。對於軟體品質來說，物件導向的程式設計只是用來解決擴充性的問題。

在python中，用變數表示特徵，用函數表示方法，因而類是變數與函數的結合體，對象是變數與方法（指向類的函數）的結合體

4、類屬性：特徵（變數）和方法（函數）

5、類有兩種方法：1.類的執行個體化；2.屬性引用
　　1.執行個體化：
　　　　類名加括弧就是執行個體化，會自動觸發__init__函數的運行，可以用它來為每個執行個體定製自己的特徵
　　2.屬性引用：
　　　　類名.方法

6、對象也稱為執行個體

　　對象的屬性：對象本身就自有特徵（變數）

　　對象的只有一種用法：屬性引用

7、類的名稱空間和對象的名稱空間

建立一個類，就會建立一個類的名稱空間，存放類中定義的屬性：特徵（資料）和方法（函數）
建立一個對象，及類的執行個體化，就會建立一個類的名稱空間，存放對象的屬性。

注意：對象就是類的執行個體化，類完成執行個體化的操作就已經將類的方法綁定到對象上，對象調用方法會現在自己的名稱空間去找，找不到會去類的名稱空間去找，再找不到會拋異常。它不會去找全域的定義。

查看類的名稱空間 類名._dict_
查看對象的名稱空間 對象名._dict_

Binder 方法的核心在於‘綁定’，唯一綁定到一個確定的對象

可以調用：查
print(Garen.camp) #查

可以更改：改
Garen.camp=‘aaaaaa‘ #改
print(Garen.camp)

可以刪除： 刪
del Garen.camp #刪除
print(Garen.camp)

可以添加： 增
Garen.x=1 #增加特徵
print(Garen.x)

關於對象（執行個體）

可以調用： 查
g1=Garen(‘alex‘)
print(g1.nick) #查

可以更改： 改
g1.nick=‘asb‘ #改
print(g1.nick)

可以刪除： 刪
del g1.nick
print(g1.nick) #刪

可以增加： 增
g1.sex=‘female‘
print(g1.sex) #增加

四、物件導向的軟體開發：

分為五部：

1、物件導向分析（object oriented analysis,OOA）：
產品經理調研市場，考察，明確軟體的用途和應用情境。
2、物件導向設計（object oriented design,OOD）：
根據需求，對每一部分進行具體的設計，例如：類的設計
3、物件導向編程（object oriented programming,OOP）：
將設計編程成代碼
4、物件導向測試（object oriented test,OOT）：
對寫好的代碼進行測試，發現錯誤並改正。物件導向的測試是用物件導向的方法進行測試，以類為測試的基本單元。
5、物件導向維護（object oriented soft maintenance,OOSM）：
解決使用者使用產品過程中出現的問題，或是增加新的功能。

物件導向編程思想：
1、設計的時候，一定要明確應用情境

2、由對象分析定義類的時候，找不到共同特徵和技能不用強求

 

python遞迴 及 物件導向初識及編程思想