Python 函式應用遞迴與 Lambda

Python 函式的應用不僅限於程式碼封裝，遞迴和 Lambda 函式更能提升程式設計的彈性。遞迴函式能有效處理階乘、費波那契數列等問題，Lambda 函式則簡化了匿名函式的定義。結合兩者，開發者能更有效率地處理複雜的計算邏輯，例如複利計算的實作。此外，理解字串處理的技巧，包含字串的建立、存取、修改、運算元以及內建函式，對於程式開發也至關重要。掌握這些技巧，能讓開發者更有效率地處理字串相關的任務。

函式進階應用：遞迴與 Lambda 函式

在 Python 程式設計中，函式不僅可以用來封裝重複使用的程式碼，還能透過遞迴和 Lambda 函式實作更靈活的程式邏輯。本章節將探討遞迴函式的應用、Lambda 函式的特性，以及如何利用函式實作複雜的計算邏輯，如計算複利。

遞迴函式的實作與應用

遞迴是一種重要的程式設計技巧，函式透過呼叫自身來解決問題。以下是一個經典範例：計算一個數的階乘。

程式 6.22：使用遞迴計算階乘

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

print(factorial(5))

輸出結果：

內容解密：

factorial 函式接受一個引數 n，當 n 為 0 時，傳回 1（遞迴的基礎情況）。
當 n 不為 0 時，函式傳回 n 與 factorial(n-1) 的乘積。
遞迴過程會持續呼叫 factorial 直到 n 為 0，然後逐步傳回結果並計算最終的階乘值。

另一個常見的遞迴範例是計算費波那契數列。

程式 6.23：使用遞迴計算費波那契數列

def fib(n):
    if n == 0 or n == 1:
        return 1
    return fib(n-1) + fib(n-2)

print("The Value of 8th Fibonacci number =", fib(8))

輸出結果：

The Value of 8th Fibonacci number = 34

內容解密：

費波那契數列定義為：Fib(0) = 1、Fib(1) = 1，以及 Fib(n) = Fib(n-1) + Fib(n-2)。
fib 函式透過遞迴實作費波那契數列的計算。
當 n 為 0 或 1 時，直接傳回 1；否則，傳回前兩個費波那契數的和。

Lambda 函式：匿名函式的應用

Lambda 函式是一種簡潔的匿名函式定義方式，用於建立簡單的函式物件。其語法如下：

名稱 = lambda (變數): 程式碼

範例：使用 Lambda 函式計算立方

cube = lambda x: x*x*x
print(cube(2))

輸出結果：

內容解密：

cube 是定義的 Lambda 函式，接受一個引數 x 並傳回其立方值。
相較於傳統函式定義，Lambda 函式更加簡潔，適合用於簡單的運算邏輯。

複利計算小專案

本文透過一個實際案例展示如何利用函式實作複利計算，並進行年度利息分析。

複利計算公式

複利是指在初始本金上計算利息，並且將前一期的利息加入下一期的本金中。計算公式如下： [ CI = P \left(1 + \frac{r}{t}\right)^{nt} - P ] 其中：

(P) 為本金。
(r) 為年利率。
(n) 為投資年數。
(t) 為每年複利次數。

程式實作：複利計算與年度分析

def Calculate_Compound_Interest(p, n, r):
    print('Start Balance\t\tInterest\t\tEnding Balance')
    total = 0
    x = r / 100
    tot = 0
    for i in range(1, n+1):
        z_new = p*(1 + x)**i - p
        z_old = p*(1 + x)**(i-1) - p
        tot = tot + (z_new - z_old)
        if i == 1:
            print('{0:.2f}\t\t'.format(p), end='')
            print('\t{0:.2f}\t\t'.format(z_new - z_old), end='')
            print('\t\t{0:.2f}\t\t'.format(z_new+p))
        else:
            print('{0:.2f}\t\t'.format(p+z_old), end='')
            print('\t{0:.2f}\t\t'.format(z_new - z_old), end='')
            print('\t\t{0:.2f}\t\t'.format(z_new+p))
    print('Total Interest Deposited: Rs {0:.2f}'.format(tot))

p = int(input('Enter the Principal amount: '))
r = int(input('Enter the rate of interest: '))
n = int(input('Enter number of years: '))
Calculate_Compound_Interest(p, n, r)

輸出範例：

Enter the Principal amount: 10000
Enter the rate of interest: 5
Enter number of years: 7
Start Balance           Interest          Ending Balance
10000.00                500.00              10500.00
10500.00                525.00              11025.00
11025.00                551.25              11576.25
11576.25                578.81              12155.06
12155.06                607.75              12762.82
12762.82                638.14              13400.96
13400.96                670.05              14071.00
Total Interest Deposited: Rs 4071.00

#### 內容解密：

程式首先讀取使用者輸入的本金、利率和投資年數。
Calculate_Compound_Interest 函式根據複利公式逐年計算利息，並輸出每年的期初餘額、當年利息和期末餘額。
總利息透過累計每年利息得出，並在最後輸出總利息金額。

Python 函式詳解：定義、引數傳遞與應使用案例項

在 Python 程式設計中，函式（Function）扮演著至關重要的角色。函式是一種可重複使用的程式碼區塊，用於執行特定的任務。本文將探討 Python 函式的定義、引數傳遞、變數範圍以及遞迴等概念，並提供豐富的例項幫助讀者更好地理解和應用。

函式的定義與基本語法

Python 中的函式定義以 def 關鍵字開頭，後接函式名稱、引數列表及函式體。函式的引數列表可以包含零個或多個引數，這些引數在函式被呼叫時傳入具體的值。

def greet(name):
    """簡單的問候函式"""
    print(f"你好，{name}！")

# 呼叫函式
greet("玄貓")

#### 內容解密：
1. `def` 是定義函式的關鍵字。
2. `greet` 是函式名稱，代表了該函式的功能。
3. `(name)` 是引數列表，本例中只有一個引數 `name`。
4. 函式體內使用 `print` 輸出問候陳述式。
5. 當呼叫 `greet("玄貓")` 時，字串 `"玄貓"` 被傳遞給 `name` 引數。

引數傳遞：位置引數與關鍵字引數

Python 支援兩種主要的引數傳遞方式：位置引數（Positional Arguments）和關鍵字引數（Keyword Arguments）。

def add(a, b):
    return a + b

# 使用位置引數
result1 = add(3, 5)
print(result1)  # 輸出：8

# 使用關鍵字引數
result2 = add(a=3, b=5)
print(result2)  # 輸出：8

#### 內容解密：
1. `add` 函式接受兩個引數 `a` 和 `b`。
2. 使用位置引數時，依照引數定義順序傳入值。
3. 使用關鍵字引數時，直接指定引數名稱和對應的值。
4. 兩種方式都能正確計算並傳回結果。

變數範圍：區域性變數與全域變數

在 Python 中，變數的作用範圍分為區域性（Local）和全域（Global）。區域性變數定義在函式內部，只能在該函式記憶體取；全域變數則定義在函式外部，可被程式中的任何部分存取。

x = 10  # 全域變數

def test():
    y = 20  # 區域性變數
    print(f"函式內：x = {x}, y = {y}")

test()
print(f"函式外：x = {x}")
try:
    print(y)  # 試圖存取區域性變數 y，將引發錯誤
except NameError as e:
    print(e)

#### 內容解密：
1. `x` 是全域變數，在函式內外皆可存取。
2. `y` 是區域性變數，僅能在 `test` 函式內部存取。
3. 試圖在函式外部存取 `y` 將引發 `NameError`。

遞迴函式

遞迴是一種特殊的函式呼叫方式，即函式在其內部呼叫自身。遞迴必須有明確的終止條件，以避免無限遞迴導致的錯誤。

def factorial(n):
    """計算 n 的階乘"""
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))  # 輸出：120

#### 內容解密：
1. `factorial` 函式接受一個正整數 `n`。
2. 當 `n` 為 0 或 1 時，傳回 1（遞迴的基底情況）。
3. 對其他正整數，傳回 `n` 與 `factorial(n-1)` 的乘積。
4. 該遞迴過程持續直到 `n` 為 1，開始回溯並計算最終結果。

常見問題與解答

問：如何判斷一個變數是區域性還是全域變數？
答：在 Python 中，如果變數在函式內被指定，則預設為區域性變數，除非使用 global 或 nonlocal 陳述式明確宣告為全域或非區域性變數。

問： Python 中的函式能否傳回多個值？
答：可以。Python 的函式可以透過傳回一個元組（Tuple）來實作傳回多個值的效果。

def get_user_info():
    name = "玄貓"
    age = 25
    return name, age

username, userage = get_user_info()
print(f"使用者名稱：{username}，年齡：{userage}")

#### 內容解密：
1. `get_user_info` 傳回兩個值：`name` 和 `age`。
2. 在呼叫時，使用多個變數接收傳回值，Python 自動解封裝元組指定給這些變數。

字串處理與操作

字串是Python程式設計中的基本元素，瞭解如何建立、存取及操作字串對於開發者而言至關重要。本章節將探討Python中字串的各種操作及其相關函式。

7.1 字串簡介

字串是由一系列字元組成的單元。在Python中，字串被視為str類別的物件，而非單純的字元陣列。這使得字串具備豐富的操作方法。

7.2 str類別

建立字串物件有多種方式：

S1 = str()  # 建立空字串物件
S2 = str("Hello")  # 建立包含"Hello"的字串物件

或者直接指定：

S1 = ""  # 建立空字串
S2 = "Hello"  # 等同於 S2 = str("Hello")

內容解密：

使用str()建構函式可以建立字串物件。
直接指定是建立字串的另一種常見方式。
Python中的字串是物件，具有多種內建方法。

7.3 基本內建函式

Python提供多種內建函式來處理字串，例如：

>>> a = "PYTHON"
>>> len(a)  # 計算字串長度
6
>>> min(a)  # 找出最小字元
'H'
>>> max(a)  # 找出最大字元
'Y'

內容解密：

len()函式傳回字串的字元數量。
min()和max()函式根據ASCII值比較字元大小。

7.4 索引運算元[index]

字串中的每個字元都可透過索引存取，索引從0開始：

>>> S1 = "Python"
>>> S1[0]  # 存取第一個字元
'P'
>>> S1[5]  # 存取最後一個字元
'n'

內容解密：

索引運算元[]用於存取特定位置的字元。
索引超出範圍會引發IndexError。

7.4.1 負索引存取

Python支援負索引，從字串尾端開始計數：

>>> S = "PYTHON"
>>> S[-1]  # 存取最後一個字元
'N'
>>> S[-6]  # 存取第一個字元
'P'

內容解密：

負索引從-1開始，對應最後一個字元。
S[-n]等同於S[len(S)-n]。

7.5 使用迴圈遍歷字串

可使用for或while迴圈來遍歷字串中的所有字元。

使用for迴圈：

S = "India"
for ch in S:
    print(ch, end="")

輸出：India

使用while迴圈：

S = "India"
index = 0
while index < len(S):
    print(S[index], end="")
    index += 1

輸出：India

內容解密：

for迴圈直接迭代字串中的每個字元。
while迴圈透過索引來存取字元，需手動管理索引變數。

7.6 不可變字串

Python中的字串是不可變的，嘗試修改字串內容會導致錯誤：

Str1 = "I Love Python"
Str1[0] = "U"  # 嘗試修改第一個字元

錯誤訊息：TypeError: 'str' object does not support item assignment

內容解密：

字串的不可變性保證了資料的安全性。
若需修改字串，需建立新的字串物件。

字串操作與處理

在Python中，字串是一種基本且重要的資料型別，用於表示文字資訊。字串操作包括了對字串的修改、擷取、比較等功能，這些操作在程式設計中非常常見。

修改字串

雖然字串本身是不可變的，但我們可以透過建立新的字串來達到修改的效果。例如：

Str1 = "I Love Python"
Str2 = "U" + Str1[1:]
print(Str2)

輸出結果為：

U Love Python

內容解密：

Str1 初始被指定為 "I Love Python"。
Str2 透過將 "U" 與 Str1 從索引1開始的子字串拼接而成。
Str1[1:] 表示從 Str1 的第二個字元開始到結束的子字串，即 " Love Python"。
因此，Str2 成為 "U Love Python"。

字串物件與記憶體管理

Python對於內容相同的字串會使用同一個物件，以節省記憶體。例如：

Str1 = "Hello"
Str2 = "Hello"
print(id(Str1) == id(Str2))  # True

內容解密：

Str1 和 Str2 被指定為相同的字串 "Hello"。
由於Python的記憶體管理機制，內容相同的字串會被儲存在同一個記憶體地址，因此 id(Str1) 和 id(Str2) 相同。

字串運算元

Python提供了豐富的字串運算元，包括切片運算元、連線運算元、重複運算元等。

切片運算元 `[start:end]`

用於擷取字串的一部分。

S = "IIT-BOMBAY"
print(S[4:10])  # 'BOMBAY'

內容解密：

S[4:10] 表示從索引4開始到索引9（因為結束索引是10，但實際取到的是10-1）的子字串。
因此輸出結果為 'BOMBAY'。

切片運算元帶步長 `[start:end:step]`

可用於每隔一定步長擷取字元。

S = "IIT-BOMBAY"
print(S[0:len(S):2])  # 'ITBMA'

內容解密：

S[0:len(S):2] 表示從索引0開始到字串結束，每隔一個字元取一個字元。
因此輸出結果為 'ITBMA'。

連線運算元 `+`

用於連線兩個字串。

S1 = "IIT "
S2 = "Delhi"
print(S1 + S2)  # 'IIT Delhi'

內容解密：

S1 + S2 將 S1 和 S2 的內容連線起來，形成新的字串。

重複運算元 `*`

用於重複一個字串多次。

S1 = "Hello"
S2 = 3 * S1
print(S2)  # 'HelloHelloHello'

內容解密：

3 * S1 表示將 S1 重複3次。

成員運算元 `in` 和 `not in`

用於檢查一個字串是否包含在另一個字串中。

S1 = "Information Technology"
print("Technology" in S1)  # True
print("Engineering" in S1) # False

內容解密：

"Technology" in S1 檢查 "Technology" 是否是 S1 的子字串。
"Engineering" in S1 檢查 "Engineering" 是否是 S1 的子字串。

字串比較

Python中可以使用比較運算元來比較字串，比較的依據是字元的ASCII值。

S1 = "abcd"
S2 = "ABCD"
print(S1 > S2)  # True

內容解密：

S1 > S2 比較的是 S1 和 S2 的ASCII值，由於 'a' 的ASCII值大於 'A'，因此傳回 True。

`.format()` 方法

用於格式化字串。

print("My Name is {} and I am from {}".format("JHON", "USA"))
# 'My Name is JHON and I am from USA'

內容解密：

{} 是佔位符，將被 .format() 中的引數依次替換。

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。

Python 函式應用 遞迴與 Lambda

函式進階應用：遞迴與 Lambda 函式

遞迴函式的實作與應用

程式 6.22：使用遞迴計算階乘

內容解密：

程式 6.23：使用遞迴計算費波那契數列

內容解密：

Lambda 函式：匿名函式的應用

範例：使用 Lambda 函式計算立方

內容解密：

複利計算小專案

複利計算公式

程式實作：複利計算與年度分析

#### 內容解密：

Python 函式詳解：定義、引數傳遞與應使用案例項

函式的定義與基本語法

引數傳遞：位置引數與關鍵字引數

變數範圍：區域性變數與全域變數

遞迴函式

常見問題與解答

字串處理與操作

7.1 字串簡介

7.2 str類別

內容解密：

7.3 基本內建函式

內容解密：

7.4 索引運算元[index]

內容解密：

7.4.1 負索引存取

內容解密：

7.5 使用迴圈遍歷字串

使用for迴圈：

使用while迴圈：

內容解密：

7.6 不可變字串

內容解密：

字串操作與處理

修改字串

內容解密：

字串物件與記憶體管理

內容解密：

字串運算元

切片運算元 [start:end]

內容解密：

切片運算元帶步長 [start:end:step]

內容解密：

更多切片範例

內容解密：

連線運算元 +

內容解密：

重複運算元 *

內容解密：

成員運算元 in 和 not in

內容解密：

字串比較

內容解密：

.format() 方法

內容解密：

玄貓 BlackCat

Python 函式應用遞迴與 Lambda

切片運算元 `[start:end]`

切片運算元帶步長 `[start:end:step]`

連線運算元 `+`

重複運算元 `*`

成員運算元 `in` 和 `not in`

`.format()` 方法