第八章（二）

3、返回值

函數返回的值被稱為返回值。在函數中，可使用return語句將值返回到調用函數的代碼行。返回值可以將程序中大部分繁重的工作移到函數中去完成，從而簡化程序。

（1）返回簡單值

def get_formatted_name(first_name, last_name):
    full_name = first_name + ' ' + last_name
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
# 輸出：
Jimi Hendrix

這個函數將接收到的姓名整潔地重新輸出。

（2）讓實參變成可選的

讓實參變成可選的，可以讓使用函數的人只有在必要時才提供額外的信息。可使用默認值來讓實參變成可選的。

def get_formatted_name(first_name, last_name, middle_name=''):
    if middle_name:
        full_name = first_name + ' ' + middle_name + ' ' + last_name
    else:
        full_name = first_name + ' ' + last_name
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)
# 輸出：
Jimi Hendrix
John Lee Hooker

在上面的函數中添加了一個中間名，若沒有給定默認值，調用時只提供名和姓，Python會報錯。而給它一個空字符串作為默認值就不會報錯。給了默認值的參數必須移到沒有默認值的參數后面。在調用函數的時候，有默認值的形參是否傳遞實參，完全在于調用的人是否需要。可選值讓函數能夠處理各種不同的情形的同時，確保函數調用盡可能簡單。

（3）返回字典

函數可返回任何類型的值，包括列表和字典等較為復雜的的數據結構。

def build_person(first_name, last_name):
    person = {'first': first_name, 'last': last_name}
    return person
musician = build_person('jimi', 'hendrix')
print(musician)
# 輸出：
{'first': 'jimi', 'last': 'hendrix'}

在這個函數中，你可以輕松的擴展這個函數，使其接收可選值。

def build_person(first_name, last_name, age=''):
    person = {'first': first_name, 'last': last_name}
    if age:
        person['age'] = age
    return person
musician = build_person('jimi', 'hendrix', age=27)
print(musician)
# 輸出：
{'first': 'jimi', 'last': 'hendrix', 'age': 27}

在這里新增了一個可選的形參age。同理也可以進行其他信息的擴展。

（4）結合使用函數和while循環

def get_formatted_name(first_name, last_name):
    full_name = first_name + ' ' + last_name
    return full_name.title()
while True:
    print("\nPlease tell me your name:")
    print("(enter 'q' at any time to quit)")
    f_name = input("First name: ")
    if f_name == 'q':
        break
    l_name = input("Last name: ")
    if l_name == 'q':
        break
    formatted_name = get_formatted_name(f_name, l_name)
    print("\nHello, " + formatted_name + "!")
# 輸出：
Please tell me your name:
(enter 'q' at any time to quit)
First name: eric
Last name: matthes

Hello, Eric Matthes!

Please tell me your name:
(enter 'q' at any time to quit)
First name: q

4、傳遞列表

將列表傳遞給函數后，函數就能直接訪問其內容。用函數訪問列表中的每個人：

def greet_users(names):
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)
# 輸出：
Hello, Hannah!
Hello, Ty!
Hello, Margot!

（1）在函數中修改列表

將列表傳遞給函數后，函數就可對其進行修改。在函數中對這個列表所做的任何修改都是永久的。

def print_models(unprinted_designs, completed_models):
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print("Printing model: " + current_design)
        completed_models.append(current_design)

def show_completed_models(completed_models):
    print("\nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
# 輸出：
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case

The following models have been printed:
dodecahedron
robot pendant
iphone case

這個例子演示了一種理念，即每個函數都應只負責一項具體的工作。編寫函數時，如果你發現它執行的任務太多，可以嘗試將它分到兩個函數中，而且總是可以在一個函數中調用另一個函數，這有助于將復雜的任務劃分成一系列的步驟。

（2）禁止函數修改列表

當你執行修改列表后，還需要使用未修改之前的列表時，可以將傳遞給函數的列表改為列表的副本而不是原件，這樣函數所做的任何修改都只影響副本，而絲毫不影響原件。
用切片表示法[:]創建列表的副本。如：

print_models(unprinted_designs[:], completed_models)

雖然向函數傳遞列表的副本可保留原始列表的內容，但除非有充分的理由需要傳遞副本，否則還是應該將原始列表傳遞給函數，因為讓函數使用現成列表可避免花時間和內存創建副本，從而提高效率，在處理大型列表時尤其如此。

5、傳遞任意數量的實參

Python允許函數從調用語句中收集任意數量的實參。

def make_pizza(*toppings):
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')
# 輸出：
('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

形參名*toppings中的星號讓Python創建一個名為toppings的空元組，并將收到的所有值都封裝在這個元組中，即使只收到一個值也是封裝在元組中。上述例子的第一條輸出就是如此，只有一個元素的元組用小括號括起來，并在元素的后面添加一個逗號。

（1）結合使用位置實參和任意數量實參

如果要讓函數接收不同類型的實參，必須在函數定義中將接納任意數量實參的形參放在最后。Python先匹配位置實參和關鍵字實參，再將余下的實參都收集到一個形參中。

def make_pizza(size, *toppings):
    print("\nMaking a " + str(size) +
            "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 輸出：
Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

（2）使用任意數量的關鍵字實參

需要接收任意數量的實參，但預先不知道傳遞給函數的會是什么樣的信息。這時候可將函數編寫成能夠接收任意數量的鍵-值對——調用語句提供了多少就接收多少。

def build_profile(first, last, **user_info):
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile

user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                             field='physics')
print(user_profile)
# 輸出：
{'first_name': 'albert', 'last_name': 'einstein', 
'location': 'princeton', 'field': 'physics'}

形參**user_info中的兩個星號讓Python創建一個名為user_info的空字典，并將收到的所有名稱-值對都封裝到這個字典中。
編寫函數時，可以以各種方式混合使用位置實參、關鍵字實參和任意數量的實參。

6、將函數存儲在模塊中

函數的優點之一是，使用它們可將代碼塊與主程序分離。通過給函數指定描述性名稱，可讓主程序容易理解得多。還可以將函數存儲在被稱為模塊的獨立文件中，再將模塊導入到主程序中。import語句允許在當前運行的程序文件中使用模塊中的代碼。
通過將函數存儲在獨立的文件中，可隱藏程序代碼的細節，將重點放在程序的高層邏輯上。這可以在眾多不同的程序中重用函數。將函數存儲在獨立文件中后，可與其他程序員共享這些文件而不是整個程序。

（1）導入整個模塊

要讓函數是可導入的，得先創建模塊。模塊是擴展名為.py的文件，包含要導入到程序中的代碼。
將前面make_pizza函數放在一個名為pizza.py的文件中，然后再創建一個名為making_pizzas.py的文件，在文件的開頭添加import pizza，然后在下面寫入調用函數的語句運行即可。程序運行時，import會將pizza文件中的所有函數復制到程序中。
要調用被導入的模塊中的函數，可指定導入的模塊的名稱pizza和函數名make_pizza()，并用句點分隔它們。如：

pizza.make_pizza(16, 'pepperoni')

只需編寫一條import語句并在其中指定模塊名，就可以在程序中使用該模塊中的所有函數。

module_name.function_name()

（2）導入特定的函數

導入模塊中的特定函數：

from module_name import function_name

通過用逗號分隔函數名，可根據需要從模塊中導入任意數量的函數：

from module_name import function_0, function_1, function_2

使用這種方法導入函數后，調用函數時就不需要使用句點。因為已經在import語句中顯示地導入了函數，所以調用時指定其名稱即可。

（3）使用as給函數指定別名

如果要導入的函數的名稱可能與程序中現有的名稱沖突，或者函數的名稱太長，可指定簡短而獨一無二的別名——類似于給函數起一個外號。若要這么做，就要在導入它時就要做。
在import語句中使用關鍵字as將函數重命名為你想要的別名：

from pizza import make_pizza as mp

因為有了一個別名，所以調用函數時可以直接用別名來調用。

（4）使用as給模塊指定別名

給模塊指定別名，能使代碼更簡潔，而且不再關注模塊名，而專注于描述性的函數名，對理解代碼更好。

import module_name as mn

（5）代入模塊中的所有函數

使用星號（*）運算符可讓Python導入模塊中的所有函數。由于導入了每個函數，可通過名稱來調用每個函數，而無需使用句點表示法。然而，使用并非自己編寫的大型模塊時，最好不要采用這種導入方法：如果模塊中有函數的名稱與你的項目中使用的名稱相同，可能導致意想不到的結果：Python可能遇到多個名稱相同的函數或變量，進而覆蓋函數，而不是分別導入所有函數。
最佳的做法是，要么只導入你需要使用的函數，要么導入整個模塊并使用句點表示法。

from module_name import *

7、函數編寫指南

應給函數指定描述性名稱，且只在其中使用小寫字母和下劃線。給模塊命名時也應遵循上述約定。
每個函數都應包含簡要地闡述其功能的注釋，該注釋緊跟在函數定義后面，并采用文檔字符串格式。
給形參指定默認值時，等號兩邊不要有空格。對于函數調用中的關鍵字實參，也應遵循這種約定。
如果函數的形參很多，導致函數定義的長度超過了79字符，可在函數定義中輸入左括號后按回車鍵，并在下一行按兩次Tab鍵，從而將形參列表和只縮進一層的函數體區分開來。
如果程序或模塊包含多個函數，可使用兩個空行將相鄰的函數分開，這樣將更容易知道前一個函數在什么地方結束，下一個函數在什么地方開始。
所有的import語句都應放在文件開頭，唯一例外的情形是，在文件開頭使用了注釋來描述整個程序。