摘要：函數(shù)名應(yīng)盡量只有小寫字母和下劃線。傳遞參數(shù)位置參數(shù)必選參數(shù)這就是要求實(shí)參的順序和形參的順序相同。比如上述函數(shù)如果給形參指定默認(rèn)值，則可以看出這個(gè)函數(shù)主要是用來(lái)描述狗這種寵物的。在的函數(shù)中，使用語(yǔ)句來(lái)返回值。

《Python編程：從入門到實(shí)踐》筆記。
本章主要介紹Python中函數(shù)的操作，包括函數(shù)的概念，定義，如何傳參等，最后還有小部分模塊的概念。

函數(shù)是帶名字的代碼塊，該代碼塊是完成特定工作的固定代碼序列。如果程序中多次出現(xiàn)相同或相似的代碼塊，則應(yīng)將這段代碼提取出來(lái)，編寫成函數(shù)，然后多次調(diào)用。通過(guò)編寫函數(shù)可以避免重復(fù)工作，使程序的編寫、閱讀、測(cè)試和修復(fù)更容易。請(qǐng)使用描述性的函數(shù)名來(lái)命名函數(shù)，以大致表明函數(shù)的功能，這樣即使沒(méi)有注釋也能容易理解。函數(shù)名應(yīng)盡量只有小寫字母和下劃線。以下是兩個(gè)最基本的函數(shù)，有參數(shù)與無(wú)參函數(shù)：

# 定義無(wú)參函數(shù)
def greet_user1():
    """顯示簡(jiǎn)單的問(wèn)候語(yǔ)"""
    print("Hello!")

# 定義有參函數(shù)
def greet_user2(username):
    """顯示簡(jiǎn)單的問(wèn)候語(yǔ)"""
    print("Hello, " + username.title() + "!")

# 調(diào)用函數(shù)
greet_user1()
greet_user2("jesse")

# 結(jié)果：
Hello!
Hello, Jesse!

在調(diào)用函數(shù)前，必須先定義函數(shù)！即函數(shù)的定義部分必須在調(diào)用語(yǔ)句之前。
上述代碼中的三引號(hào)字符串叫做文檔字符串，他們既可以被用作代碼注釋，也可用于自動(dòng)生成有關(guān)程序中函數(shù)的文檔。

實(shí)參和形參
這兩個(gè)概念經(jīng)常被搞混，函數(shù)定義中的參數(shù)叫做形參，比如上述函數(shù)greet_user2(username)中的username就是形參；傳遞給函數(shù)的參數(shù)叫做實(shí)參，比如在調(diào)用greet_user2("jesse")時(shí)的"jesse"就是實(shí)參。

如果想定義一個(gè)什么都不做的函數(shù)，可以使用pass語(yǔ)句

def do_nothing():
    pass

如果為了讓程序能跑起來(lái)，但暫時(shí)又不寫這個(gè)函數(shù)，可以使用pass語(yǔ)句。這里pass用作占位符。

這就是要求實(shí)參的順序和形參的順序相同。

# 代碼：
def describe_pet(animal_type, pet_name):
    """顯示寵物的信息"""
    print("
I have a " + animal_type + ".")
    print("My " + animal_type + ""s name is " + pet_name.title() + ".")

describe_pet("hamster", "harry")
describe_pet("dog", "willie")

# 結(jié)果：
I have a hamster.
My hamster"s name is Harry.

I have a dog.
My dog"s name is Willie.

對(duì)于位置參數(shù)，應(yīng)該注意實(shí)參的傳遞順序，如果順序不對(duì)，結(jié)果會(huì)出乎意料：有可能報(bào)錯(cuò)，如果不報(bào)錯(cuò)，函數(shù)所要表達(dá)的意思可能改變。

# 代碼：
describe_pet("willie", "dog")

# 結(jié)果：
I have a willie.           # 尷尬
My willie"s name is Dog.

如果函數(shù)的形參過(guò)多，則很難記住每個(gè)位置的參數(shù)是用來(lái)干什么的，如果用鍵值對(duì)的方式傳遞實(shí)參，這個(gè)問(wèn)題就能迎刃而解，這就是關(guān)鍵字參數(shù)。在傳遞參數(shù)時(shí)，直接將形參與實(shí)參關(guān)聯(lián)，這樣就不用在意實(shí)參的位置，依然以上述代碼為例，函數(shù)定義不變：

# 代碼：
describe_pet(animal_type="hamster", pet_name="harry")
describe_pet(pet_name="harry", animal_type="hamster")

# 結(jié)果：
I have a hamster.
My hamster"s name is Harry.

I have a hamster.
My hamster"s name is Harry.

請(qǐng)注意，這是一種傳遞參數(shù)的方法！在調(diào)用函數(shù)時(shí)使用！

編寫函數(shù)時(shí)可以為每個(gè)形參指定默認(rèn)值，給形參指定了默認(rèn)值之后，在調(diào)用函數(shù)時(shí)可以省略相應(yīng)的實(shí)參。使用默認(rèn)值可以簡(jiǎn)化函數(shù)調(diào)用，也可清楚地指出函數(shù)的典型用法。比如上述describe_pet()函數(shù)如果給形參animal_type指定默認(rèn)值“dog”，則可以看出這個(gè)函數(shù)主要是用來(lái)描述狗這種寵物的。

# 代碼：
def describe_pet(pet_name, animal_type="dog"):
    """顯示寵物的信息"""
    print("
I have a " + animal_type + ".")
    print("My " + animal_type + ""s name is " + pet_name.title() + ".")


describe_pet(pet_name="willie")
describe_pet("happy")
describe_pet("lili", "cat")

# 結(jié)果：
I have a dog.
My dog"s name is Willie.

I have a dog.
My dog"s name is Happy.

I have a cat.
My cat"s name is Lili.

在函數(shù)調(diào)用時(shí)，如果給形參提供了實(shí)參，Python將使用指定的實(shí)參；否則將使用形參的默認(rèn)值。
注意：默認(rèn)參數(shù)是在函數(shù)定義時(shí)使用！在定義函數(shù)時(shí)帶有默認(rèn)值的形參必須在沒(méi)有默認(rèn)值的形參后面！

還有一點(diǎn)值得注意：默認(rèn)參數(shù)必須指向不變對(duì)象！請(qǐng)看以下代碼：

# 代碼：
def add_end(temp=[]):
    """在傳入的列表最后添加“end”"""
    temp.append("end")
    return temp


print(add_end([1, 2, 3]))
print(add_end(["a", "b", "c"]))
print(add_end())
print(add_end())
print(add_end())

# 結(jié)果：
[1, 2, 3, "end"]
["a", "b", "c", "end"]
["end"]
["end", "end"]
["end", "end", "end"]

當(dāng)給這個(gè)函數(shù)傳遞了參數(shù)時(shí)，結(jié)果是正確的，而且，在沒(méi)有傳遞參數(shù)且第一次調(diào)用時(shí)，返回結(jié)果也是正確的，然而，沒(méi)有傳遞參數(shù)且第二次、第三次調(diào)用時(shí)，結(jié)果則成了問(wèn)題。這是因?yàn)?，Python在函數(shù)定義的時(shí)候，默認(rèn)參數(shù)的值就被計(jì)算了出來(lái)，形參只要不指向新的值，它就會(huì)一直指向這個(gè)默認(rèn)值，但如果這個(gè)默認(rèn)值是個(gè)可變對(duì)象，就會(huì)出現(xiàn)上述情況。
要修正上述例子，可以使用None，str之類的不變對(duì)象。如下：

def add_end(temp=None):
    """在傳入的列表最后添加“end”"""
    if temp is None:
        temp = []
    temp.append("end")
    return temp

print(add_end())
print(add_end())

# 結(jié)果：
["end"]
["end"]

補(bǔ)充--設(shè)計(jì)不變對(duì)象的原因：
①對(duì)象一旦創(chuàng)建則不可修改，可以減少因修改數(shù)據(jù)而產(chǎn)生的錯(cuò)誤；
②由于對(duì)象不可修改，在多任務(wù)環(huán)境下不需要加鎖，同時(shí)讀不會(huì)出錯(cuò)。所以，我們?cè)谠O(shè)計(jì)一個(gè)對(duì)象時(shí)，能設(shè)計(jì)成不變對(duì)象則設(shè)計(jì)成不變對(duì)象。

函數(shù)并非總是直接顯示輸出，它可以處理一些數(shù)據(jù)并返回一個(gè)或一組值。在Python的函數(shù)中，使用return語(yǔ)句來(lái)返回值。以下是一個(gè)參數(shù)可選的帶有返回值的函數(shù)例子：

# 代碼：
def get_formatted_name(first_name, last_name, middel_name=""):
    """返回標(biāo)準(zhǔn)格式的姓名"""
    if middel_name:
        full_name = first_name + " " + middel_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)

# 結(jié)果：
Jimi Hendrix
John Lee Hooker

Python函數(shù)可以返回任何類型的值，包括列表和字典等復(fù)雜的數(shù)據(jù)結(jié)構(gòu)。

# 代碼：
def build_person(first_name, las_name, age=""):
    """返回一個(gè)字典，其中包含一個(gè)人的信息"""
    person = {"first": first_name, "last": las_name}
    if age:
        person["age"] = age
    return person


musician = build_person("jimi", "hendrix", age=27)
print(musician)

# 結(jié)果：
{"first": "jimi", "last": "hendrix", "age": 27}

return語(yǔ)句后面用逗號(hào)分隔多個(gè)值，則可返回多個(gè)值：

# 代碼：
def return_mult():
    return 1, 2

a, b = return_mult()
print("a = " + str(a) + "
b = " + str(b))

# 結(jié)果：
a = 1
b = 2

但其實(shí)這是個(gè)假象，其實(shí)函數(shù)返回的是一個(gè)元組（Tuple），只是最后對(duì)元組進(jìn)行了解包，然后對(duì)a，b進(jìn)行了平行賦值。

# 代碼：
print(return_mult())

# 結(jié)果：
(1, 2)

如果函數(shù)返回多個(gè)值，但有些值并不想要，則這些位置的值可以用下劃線_進(jìn)行接收：

def return_mult():
    return 1, 2, 3
    
a, _, _ = return_mult()

將列表傳遞給函數(shù)，函數(shù)可以直接訪問(wèn)其內(nèi)容或?qū)ζ溥M(jìn)行修改。用函數(shù)處理列表可以提高效率。
以下代碼是一個(gè)打印程序，將未打印的設(shè)計(jì)在打印后轉(zhuǎn)移到另一個(gè)列表中，此代碼中未使用函數(shù)：

# 代碼:
# 未打印列表
unprinted_designs = ["iphone case", "robot pendant", "dodecahedron"]
completed_models = []

# 模擬打印過(guò)程，知道沒(méi)有未打印的設(shè)計(jì)為止，并將已打印的設(shè)計(jì)移動(dòng)到“完成列表”
while unprinted_designs:
    current_design = unprinted_designs.pop()

    # 模擬打印過(guò)程
    print("Printing model: " + current_design)
    completed_models.append(current_design)

print("
The following models have been printed:")
for completed_model in completed_models:
    print(completed_model)

# 結(jié)果：
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case

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

現(xiàn)在用兩個(gè)函數(shù)來(lái)重組這些代碼：

# 兩個(gè)函數(shù)：
def print_models(unprinted_designs, completed_models):
    """模擬打印過(guò)程，知道沒(méi)有未打印的設(shè)計(jì)為止，并將已打印的設(shè)計(jì)移動(dòng)到“完成列表”"""
    while unprinted_designs:
        current_design = unprinted_designs.pop()

        # 模擬打印過(guò)程
        print("Printing model: " + current_design)
        completed_models.append(current_design)


def show_completed_models(completed_models):
    print("
The 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)

從以上代碼可以看出，使用了函數(shù)后，主程序變?yōu)榱硕潭趟男小?br>相比于沒(méi)有使用函數(shù)的代碼，使用了函數(shù)后代碼更易讀也更容易維護(hù)。
在編寫函數(shù)時(shí)，盡量每個(gè)函數(shù)只負(fù)責(zé)一項(xiàng)功能，如果一個(gè)函數(shù)負(fù)責(zé)的功能太多，應(yīng)將其分成多個(gè)函數(shù)。同時(shí)，函數(shù)里面還能調(diào)用另一個(gè)函數(shù)；函數(shù)里也能再定義函數(shù)！

禁止函數(shù)修改列表：
有時(shí)候需要禁止函數(shù)修改列表，以上述代碼為例，print_models()函數(shù)在執(zhí)行完成后清空了未打印列表unprinted_design，但有時(shí)我們并不希望這個(gè)列表被清空，而是留作備案。為解決此問(wèn)題，可以向函數(shù)傳遞副本而不是原件，如下：

# 不用改變函數(shù)定義，在函數(shù)調(diào)用時(shí)使用切片操作：
print_models(unprinted_designs[:], completed_models)

如果從C/C++的角度來(lái)看（沒(méi)有研究過(guò)Python底層代碼，這里僅是猜測(cè)），實(shí)參unprinted_designs是一個(gè)指針，當(dāng)他傳遞給函數(shù)時(shí)，形參得到了這個(gè)變量的一個(gè)拷貝，形參也指向了內(nèi)存中的那片區(qū)域，所以能直接修改。而當(dāng)使用切片傳遞拷貝時(shí)，Python先在內(nèi)存中復(fù)制一遍實(shí)參unprinted_designs指向的數(shù)據(jù)，并給這片數(shù)據(jù)的地址賦給一個(gè)臨時(shí)的變量，然后再將這個(gè)臨時(shí)變量傳遞給形參。

有時(shí)候你并不知道要向函數(shù)傳遞多少個(gè)參數(shù)，比如制作披薩，你不知道顧客要多少種配料，此時(shí)使用帶一個(gè)星號(hào)*的形參，來(lái)定義函數(shù)：

# 代碼：
def make_pizza(*toppings):
    """打印顧客點(diǎn)的所有配料"""
    print(toppings)
    
make_pizza()    # 不傳參數(shù)
make_pizza("pepperoni")
make_pizza("mushrooms", "green peppers", "extra cheese")

# 結(jié)果：
()
("pepperoni",)
("mushrooms", "green peppers", "extra cheese")

從結(jié)果可以看出，以可變參數(shù)的方式傳入值時(shí)，Python將值封裝成了一個(gè)元組，即使是只傳入了一個(gè)值。

補(bǔ)充：多個(gè)參數(shù)都在一個(gè)列表里面，如果一個(gè)元素一個(gè)元素的傳遞，則代碼會(huì)很難看，可以使用如下方式傳遞參數(shù)，任以上述make_pizza()函數(shù)為例：

toppings = ["mushrooms", "green peppers", "extra cheese"]
make_pizza(*toppings)    # 這里是在執(zhí)行函數(shù)，而不是在定義函數(shù)！

在后面的“任意關(guān)鍵字參數(shù)”小節(jié)中，也可用這種方式傳值，只不過(guò)得用雙星號(hào)**。

注意：如果要讓函數(shù)接收不同類型的參數(shù)，必須將可變參數(shù)放在最后，因?yàn)镻ython先匹配位置參數(shù)和關(guān)鍵字參數(shù)，再將剩余的參數(shù)封裝到最后一個(gè)可變參數(shù)中。

# 代碼：
def make_pizza(size, *toppings):
    """概述要制作的披薩"""
    print("
Making 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")

# 結(jié)果：
Making a 16-inch pizza with the following toppings:
- pepperoni

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

有時(shí)候需要傳入任意數(shù)量的參數(shù)，并且還要知道這些參數(shù)是用來(lái)干什么的，此時(shí)函數(shù)需要能夠接受任意數(shù)量的關(guān)鍵字參數(shù)，這里使用雙星號(hào)**來(lái)實(shí)現(xiàn)：

# 代碼：
def build_profile(first, last, **user_info):
    print(user_info)

    """創(chuàng)建一個(gè)字典，其中包含我們知道的有關(guān)用戶的一切"""
    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)

# 結(jié)果：
{"location": "princeton", "field": "physics"}
{"first_name": "albert", "last_name": "einstein", "location": "princeton", "field": physics"}

從上述結(jié)果可以看出，Python將任意關(guān)鍵字參數(shù)封裝成一個(gè)字典。這里也要注意，指示任意關(guān)鍵字參數(shù)的形參必須放到最后！

區(qū)分---命名關(guān)鍵字參數(shù)（也叫命名參數(shù)）：
上述代碼可以傳遞任意數(shù)量的關(guān)鍵字參數(shù)，但有時(shí)需要限制傳入的關(guān)鍵字參數(shù)，比如上述build_profile()函數(shù)除了傳入first和last這兩個(gè)必選參數(shù)之外，還必須且只能傳入age和country這兩個(gè)參數(shù)（一個(gè)不多，一個(gè)不少）時(shí)，則需要用到命名關(guān)鍵字參數(shù)，它使用一個(gè)星號(hào)分隔必選參數(shù)和命名關(guān)鍵字參數(shù)，如下：

# 代碼：
# 星號(hào)后面的為命名關(guān)鍵字參數(shù)
def build_profile(first, last, *, age, country="China"):
    """創(chuàng)建一個(gè)字典，其中包含我們知道的有關(guān)用戶的一切"""
    profile = {}
    profile["first_name"] = first
    profile["last_name"] = last
    profile["age"] = age
    profile["country"] = country
    return profile


print(build_profile("albert", "einstein", country="USA", age=20))
print(build_profile("albert", "einstein", age=20))
print(build_profile(age=20, country="USA", first="albert", last="einstein"))
# print(build_profile("albert", "einstein"))

# 結(jié)果：
# 如果不看最后一個(gè)print()，則代碼的執(zhí)行結(jié)果如下：
{"first_name": "albert", "last_name": "einstein", "age": 20, "country": "USA"}
{"first_name": "albert", "last_name": "einstein", "age": 20, "country": "China"}
{"first_name": "albert", "last_name": "einstein", "age": 20, "country": "USA"}

# 如果將最后一個(gè)print()的注釋去掉，則代碼會(huì)報(bào)錯(cuò)

從以上結(jié)果可以看出命名關(guān)鍵字參數(shù)必須每個(gè)都賦值，可以有默認(rèn)值，有默認(rèn)值的可以不用再賦值；命名關(guān)鍵字之間可以交換順序，如果要和前面的必選參數(shù)也交換順序，則必須使用關(guān)鍵字參數(shù)的方式傳遞實(shí)參。

為什么有命名關(guān)鍵字參數(shù)：
（網(wǎng)上搜的答案，個(gè)人暫時(shí)認(rèn)為這種參數(shù)可以被位置參數(shù)給替換掉）命名參數(shù)配合默認(rèn)參數(shù)使用可以簡(jiǎn)化代碼，比如在寫類的構(gòu)造函數(shù)時(shí)，有10個(gè)參數(shù)，8個(gè)有合理的默認(rèn)值，那么可以將這8個(gè)定義為命名關(guān)鍵字參數(shù)，前兩個(gè)就是必須賦值的位置參數(shù)。這樣，在后面生成對(duì)象時(shí)，如果要替換默認(rèn)值：
①要么按順序給后面8個(gè)參數(shù)替換默認(rèn)值（C++做法）；
②要么用關(guān)鍵字參數(shù)的傳值方式給這8個(gè)關(guān)鍵字不一定按順序來(lái)賦值（Python做法）；
③要么混合①②的做法，不過(guò)容易混淆。（也就是全用必選參數(shù)，前面一部分按順序賦值，后面一部分用關(guān)鍵字參數(shù)賦值）

一點(diǎn)感想：但如果是筆者自己寫代碼，暫時(shí)更偏向于全用必選參數(shù)，帶默認(rèn)值，即如下定義形式：

def func(a, b, c="test1", d="test2", e="test3", f="test4", g="test5"):
    pass

而不是如下形式：

def func(a, b, *, c="test1", d="test2", e="test3", f="test4", g="test5"):
    pass

可能筆者才疏學(xué)淺，暫時(shí)還沒(méi)領(lǐng)會(huì)到這種方式的精髓之處。
不過(guò)上述是沒(méi)有可變參數(shù)的情況，如果是以如下形式定義函數(shù)：

def func(a, b="test", c="test2", *args):
    pass

在以如下形式調(diào)用時(shí)則會(huì)報(bào)錯(cuò)：

func("test1", c="test3", b="test2", "test4")

# 結(jié)果：
SyntaxError: positional argument follows keyword argument

可以看出，Python在這里將test4解釋為了位置參數(shù)，但筆者是想將其作為可變參數(shù)。所以筆者推測(cè)，在以下情況時(shí)，使用命名關(guān)鍵字參數(shù)比較好：
必選參數(shù)數(shù)量不少（其中有些參數(shù)的默認(rèn)值不常變動(dòng)），后面又跟有可變參數(shù)，由于必選參數(shù)很多，不容易記住位置，如果不用命名參數(shù)，按照上述關(guān)鍵字方式調(diào)用函數(shù)則會(huì)出錯(cuò)，所以此時(shí)將這些有合理默認(rèn)值的必選參數(shù)變?yōu)槊P(guān)鍵字參數(shù)，則可以使用關(guān)鍵字參數(shù)不按順序傳值。但如果沒(méi)有可變參數(shù)時(shí)，筆者還是傾向于使用帶默認(rèn)值的必選參數(shù)。

還有一點(diǎn)值得注意：命名關(guān)鍵字參數(shù)可以和可變參數(shù)（*args）混用，此時(shí)語(yǔ)法如下：

def func(a, b, *agrs, c, d):
    pass

這里c，d為命名關(guān)鍵字參數(shù)，并且前面也不用加單個(gè)星號(hào)進(jìn)行區(qū)分了，但是，如果和可變數(shù)量關(guān)鍵字參數(shù)（**kw）進(jìn)行混用，命名關(guān)鍵字不能在可變數(shù)量關(guān)鍵字參數(shù)之前，即不存在如下函數(shù)定義形式：

def func(a, b, **kw, c, d):
    pass

如果這樣定義，Pycharm會(huì)標(biāo)紅（其他IDE沒(méi)用過(guò)，不知道提不提示）。

綜上所述：Python中一共有五中參數(shù)類型，即必選參數(shù)（位置參數(shù)），默認(rèn)參數(shù)（帶默認(rèn)值的參數(shù)），可變參數(shù)（args），命名關(guān)鍵字參數(shù)和關(guān)鍵字參數(shù)（數(shù)量可變，*kw），這五種可以同時(shí)混用，但是必須遵照如下順序：
（從左到右）必選參數(shù)、默認(rèn)參數(shù)、可變參數(shù)、命名關(guān)鍵字參數(shù)和關(guān)鍵字參數(shù)。以下是這兩個(gè)參數(shù)混用的幾個(gè)例子：

def func1(a, b, *, c, d, **kw):
    """
    a, b 為必選參數(shù)
    c, d 為命名關(guān)鍵字參數(shù)
    kw 為關(guān)鍵字參數(shù)，可包含多對(duì)
    """
    pass


def func2(a, b="test", *args, c, d="test2", **kw):
    """
    :param a: 必選參數(shù)
    :param b: 帶默認(rèn)值的必選參數(shù)
    :param args: 可變參數(shù)
    :param c: 命名關(guān)鍵字參數(shù)
    :param d: 帶默認(rèn)值的命名關(guān)鍵字參數(shù)
    :param kw: 關(guān)鍵字參數(shù)，可包含多對(duì) 
    """
    pass

常用的包含任意數(shù)量關(guān)鍵字，且不區(qū)分參數(shù)類型的函數(shù)定義方式如下：

def func(*args, **kw):
    pass

def func(*args, **kwargs):
    pass

在python中，一個(gè).py文件就是一個(gè)模塊。使用模塊的最大好處就是提高了代碼的可維護(hù)性。其次，代碼不用從零開(kāi)始編寫，一個(gè)模塊編寫完成后，可以在其他地方被調(diào)用。再次，可以避免函數(shù)名和變量名沖突，不同模塊可以有相同的函數(shù)名和變量名。

要讓函數(shù)是可以導(dǎo)入的，得先創(chuàng)建模塊。以上述make_pizza()函數(shù)為例，將其余代碼刪掉，只保留這一個(gè)函數(shù)，然后再在當(dāng)前目錄中創(chuàng)建一個(gè)making_pizzas.py的文件，執(zhí)行如下代碼以導(dǎo)入整個(gè)模塊：

# making_pizzas.py文件：
import pizza

pizza.make_pizza(12, "mushromms", "green peppers", "extra cheese")
pizza.make_pizza(16, "pepperoni")

# 結(jié)果：
Making a 12-inch pizza with the following toppings:
- mushromms
- green peppers
- extra cheese

Making a 16-inch pizza with the following toppings:
- pepperoni

以這種方式導(dǎo)入模塊時(shí)，按如下方式調(diào)用函數(shù)：

module_name.function_name()

語(yǔ)法結(jié)構(gòu)為：

# 導(dǎo)入一個(gè)函數(shù)
from module_name import function_name

# 導(dǎo)入多個(gè)函數(shù)，逗號(hào)分隔
from module_name import func1, func2, func3

# 以此方式導(dǎo)入模塊式，直接以函數(shù)名調(diào)用函數(shù)，前面不用加模塊名

仍以上述pizza.py為例：

from pizza import make_pizza

make_pizza(12, "mushromms", "green peppers", "extra cheese")
make_pizza(16, "pepperoni")

別名：
當(dāng)函數(shù)名發(fā)生沖突，或者函數(shù)名、模塊名太長(zhǎng)時(shí)，可以取一個(gè)簡(jiǎn)短的名稱，類似“外號(hào)”，以上述代碼為例：

# 函數(shù)取別名
from pizza import make_pizza as mp

mp(12, "mushromms", "green peppers", "extra cheese")
mp(16, "pepperoni")

# -------------------- 另一個(gè)文件 ------------------------------
# 模塊取別名
import pizza as p
p.make_pizza(12, "mushromms", "green peppers", "extra cheese")
p.make_pizza(16, "pepperoni")

導(dǎo)入模塊中的所有函數(shù)：
例如導(dǎo)入pizza模塊中的所有函數(shù)：

from pizza import *

make_pizza(12, "mushromms", "green peppers", "extra cheese")
make_pizza(16, "pepperoni")

然而，使用并非自己編寫的大型模塊時(shí)，最好不要采用這種導(dǎo)入方法，因?yàn)槿绻K中有函數(shù)或變量和你自己寫的函數(shù)、變量同名，結(jié)果將有問(wèn)題。所以，一般的做法是要么只導(dǎo)入你需要的函數(shù)，要么導(dǎo)入整個(gè)模塊并用句點(diǎn)表示法。

包：
Python中的包就是一個(gè)文件夾，但這個(gè)文件夾下面必須包含名為__init__.py的文件（前后都是雙下劃線），包中可以放多個(gè)模塊，組織結(jié)構(gòu)與Java包類似。

迎大家關(guān)注我的微信公眾號(hào)"代碼港" & 個(gè)人網(wǎng)站 www.vpointer.net ~