python函數(shù)是帶名字的代碼塊，用于完成具體的工作。
要執(zhí)行函數(shù)定義的特定任務，可調(diào)用該函數(shù)。需要在程序中多次執(zhí)行同一項任務時，你無需反復編寫完成該任務的代碼，而只需調(diào)用執(zhí)行該任務的函數(shù)，讓Python運行 其中的代碼。通過使用函數(shù)，程序的編寫、閱讀、測試和修復都將更容易。

#! /usr/bin/env python
# -*- coding:utf-8 -*-

'''
@Author:gcan
@Email:1528667112@qq.com
@Site:http://www.gcan.top
@File:function.py
@Software:PyCharm
@Date:2018-04-22 13:32:08
@Version:1.0.0
'''

# 定義函數(shù)
# 下面是一個打印問候語的簡單函數(shù)
# def greet_user():
#     """顯示簡單的問候語"""
#     print("Hello!")
# greet_user()

# 這個是最簡單的函數(shù)結(jié)構(gòu)。使用關鍵字def 來告訴Python你要定義一個函數(shù)。這是函數(shù)定義 ，向Python指出了函數(shù)名，還可以在括號內(nèi)指出函數(shù)為完成其任務需要什么樣的信息。
# 在這里，函數(shù)名為greet_user() ，它不需要任何信息就能完成其工作，因此括號是空的(即便如此，括號也必不可少)。最后，定義以冒號結(jié)尾。
# 緊跟在def greet_user(): 后面的所有縮進行構(gòu)成了函數(shù)體。三引號處的文本是被稱為文檔字符串 (docstring)的注釋，描述了函數(shù)是做什么的。文檔字符串用三引號括起，Python使用它們來生成有關程序中函數(shù)的文檔。
# 代碼行print("Hello!") 是函數(shù)體內(nèi)的唯一的一行代碼，greet_user() 只做一項工作，打印Hello! 。
# 要使用這個函數(shù)，可調(diào)用它。函數(shù)調(diào)用讓Python執(zhí)行函數(shù)的代碼。要調(diào)用函數(shù)，可依次指定函數(shù)名以及用括號括起的必要信息。由于這個函數(shù)不需要任何信息，因此調(diào)用它時只需輸入greet_user() 即可。


# 向函數(shù)傳遞信息
# 只需稍作修改，就可以讓函數(shù)greet_user()不僅向用戶顯示Hello!，還將用戶的名字用作抬頭。為此，可在函數(shù)定義def greet_user()的括號內(nèi)添加username。通 過在這里添加username ，就可讓函數(shù)接受你給username 指定的任何值。現(xiàn)在，這個函數(shù)要求你調(diào)用它時給username 指定一個值。調(diào)用greet_user() 時，可將一個名字 傳遞給它

def greet_user(username='gcan'):
    """顯示簡單的問候語"""
    print("Hello, " + username.title() + "!")
# greet_user('gcan')

# greet_user('gcan')
# greet_user()
# 不傳值，打印默認值


# 傳遞實參
# 鑒于函數(shù)定義中可能包含多個形參，因此函數(shù)調(diào)用中也可能包含多個實參。向函數(shù)傳遞實參的方式很多，可使用位置實參 ，這要求實參的順序與形參的順序相同;也可使用關鍵
# 字實參 ，其中每個實參都由變量名和值組成;還可使用列表和字典

# 位置實參
# 你調(diào)用函數(shù)時，Python必須將函數(shù)調(diào)用中的每個實參都關聯(lián)到函數(shù)定義中的一個形參。為此，最簡單的關聯(lián)方式是基于實參的順序。這種關聯(lián)方式被稱為位置實參
def describe_pet(animal_type, pet_name):
    """顯示寵物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
# describe_pet('hamster', 'harry')
# describe_pet('pig', 'bill')

# 這個函數(shù)的定義表明，它需要一種動物類型和一個名字。調(diào)用describe_pet() 時，需要按順序提供一種動物類型和一個名字。例如，在前面的函數(shù)調(diào)用中，
# 實參'hamster' 存儲在形參animal_type 中，而實參'harry' 存儲在形參pet_name 中。在函數(shù)體內(nèi)，使用了這兩個形參來顯示寵物的信息

# 關鍵字實參
# 關鍵字實參 是傳遞給函數(shù)的名稱—值對。你直接在實參中將名稱和值關聯(lián)起來了，因此向函數(shù)傳遞實參時不會混淆(不會得到名為Hamster的harry這樣的結(jié)果)。關鍵字實參讓 你無需考慮函數(shù)調(diào)用中的實參順序，還清楚地指出了函數(shù)調(diào)用中各個值的用途

def describe_pet(animal_type, pet_name):
    """顯示寵物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
# describe_pet(animal_type='hamster', pet_name='harry')
# describe_pet(pet_name='harry',animal_type='hamster',)

# 這兩種調(diào)用方式是等效的


# 默認值
# 編寫函數(shù)時，可給每個形參指定默認值 。在調(diào)用函數(shù)中給形參提供了實參時，Python將使用指定的實參值;否則，將使用形參的默認值。因此，給形參指定默認值后，可在函數(shù) 調(diào)用中省略相應的實參。使用默認值可簡化函數(shù)調(diào)用，還可清楚地指出函數(shù)的典型用法。
# 例如，如果你發(fā)現(xiàn)調(diào)用describe_pet() 時，描述的大都是小狗，就可將形參animal_type 的默認值設置為'dog' 。這樣，調(diào)用describe_pet() 來描述小狗時，就可不 提供這種信息:

def describe_pet(pet_name, animal_type='dog'):
    """顯示寵物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
# describe_pet(pet_name='willie')


# 避免實參錯誤
# 開始使用函數(shù)后，如果遇到實參不匹配錯誤，不要大驚小怪。你提供的實參多于或少于函數(shù)完成其工作所需的信息時，將出現(xiàn)實參不匹配錯誤。
# 例如，如果調(diào)用函數(shù)describe_pet() 時沒有指定任何實參，結(jié)果將如何呢?
def describe_pet(animal_type, pet_name):
    """顯示寵物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
# describe_pet()
# 會報如下錯誤提示
# TypeError: describe_pet() missing 2 required positional arguments: 'animal_type' and 'pet_name'

# 返回值
# 函數(shù)并非總是直接顯示輸出，相反，它可以處理一些數(shù)據(jù)，并返回一個或一組值。函數(shù)返回的值被稱為返回值 。在函數(shù)中，可使用return 語句將值返回到調(diào)用函數(shù)的代碼行。
# 返回值讓你能夠?qū)⒊绦虻拇蟛糠址敝毓ぷ饕频胶瘮?shù)中去完成，從而簡化主程序。

# 返回簡單值
# 下面來看一個函數(shù)，它接受名和姓并返回整潔的姓名:
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)

# 函數(shù)get_formatted_name() 的定義通過形參接受名和姓。它將姓和名合而為一，在它們之間加上一個空格，并將結(jié)果存儲在變量full_name 中。
# 然后， 將full_name 的值轉(zhuǎn)換為首字母大寫格式，并將結(jié)果返回。
# 調(diào)用返回值的函數(shù)時，需要提供一個變量，用于存儲返回的值。在這里，將返回值存儲在了變量musician 中，輸出為整潔的姓名。

# 讓實參變成可選的
# 有時候，需要讓實參變成可選的，這樣使用函數(shù)的人就只需在必要時才提供額外的信息?？墒褂媚J值來讓實參變成可選的。


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)

# 返回字典
# 函數(shù)可返回任何類型的值，包括列表和字典等較復雜的數(shù)據(jù)結(jié)構(gòu)。例如，下面的函數(shù)接受姓名的組成部分，并返回一個表示人的字典:
def build_person(first_name, last_name):
    """返回一個字典，其中包含有關一個人的信息"""
    person = {'first': first_name, 'last': last_name}
    return person
musician = build_person('jimi', 'hendrix')
# print(musician)


# 結(jié)合使用函數(shù)和while 循環(huán)
# 下面將結(jié)合使用函數(shù)get_formatted_name() 和while 循環(huán)，以更正規(guī)的方式問候用戶。下面嘗試使用名
# 和姓跟用戶打招呼
#
# def get_formatted_name(first_name, last_name):
#     """返回整潔的姓名"""
#     full_name = first_name + ' ' + last_name
#     return full_name.title()
# # 這是一個無限循環(huán)!
# while True:
#     print("\nPlease tell me your name:")
#     f_name = input("First name: ")
#     l_name = input("Last name: ")
#     formatted_name = get_formatted_name(f_name, l_name)
#     print("\nHello, " + formatted_name + "!")


# 下面是可以中斷循環(huán)的
# 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 + "!")


# 傳遞列表
# 你經(jīng)常會發(fā)現(xiàn)，向函數(shù)傳遞列表很有用，這種列表包含的可能是名字、數(shù)字或更復雜的對象(如字典)。將列表傳遞給函數(shù)后，函數(shù)就能直接訪問其內(nèi)容。下面使用函數(shù)來提高
# 處理列表的效率。
# 假設有一個用戶列表，我們要問候其中的每位用戶。下面的示例將一個名字列表傳遞給一個名為greet_users() 的函數(shù)，這個函數(shù)問候列表中的每個人: gree
def greet_users(names):
    """向列表中的每位用戶都發(fā)出簡單的問候"""
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)
usernames = ['hannah', 'ty', 'margot']
# greet_users(usernames)


# 在函數(shù)中修改列表
# 將列表傳遞給函數(shù)后，函數(shù)就可對其進行修改。在函數(shù)中對這個列表所做的任何修改都是永久性的，這讓你能夠高效地處理大量的數(shù)據(jù)。 來看一家為用戶提交的設計制作3D打印模型的公司。需要打印的設計存儲在一個列表中，打印后移到另一個列表中

def print_models(unprinted_designs, completed_models):
    """
    模擬打印每個設計，直到?jīng)]有未打印的設計為止 打印每個設計后，都將其移到列表completed_models中
    """
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        # 模擬根據(jù)設計制作3D打印模型的過程
        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)

# 定義函數(shù)print_models() ，它包含兩個形參:一個需要打印的設計列表和一個打印好的模型列表。給定這兩個列表，這個函數(shù)模擬打印每個設計的過程:將 設計逐個地從未打印的設計列表中取出，并加入到打印好的模型列表中。
# 定義函數(shù)show_completed_models() ，它包含一個形參:打印好的模型列表。給定 這個列表，函數(shù)show_completed_models() 顯示打印出來的每個模型的名稱。



# 禁止函數(shù)修改列表
# 有時候，需要禁止函數(shù)修改列表。例如，假設像前一個示例那樣，你有一個未打印的設計列表，并編寫了一個將這些設計移到打印好的模型列表中的函數(shù)。你可能會做出這樣的 決定:即便打印所有設計后，也要保留原來的未打印的設計列表，以供備案。但由于你將所有的設計都移出了unprinted_designs ，這個列表變成了空的，原來的列表沒有 了。為解決這個問題，可向函數(shù)傳遞列表的副本而不是原件;這樣函數(shù)所做的任何修改都只影響副本，而絲毫不影響原件。
# 要將列表的副本傳遞給函數(shù)，可以像下面這樣做:
# function_name(list_name[:])
# 切片表示法[:] 創(chuàng)建列表的副本。在print_models.py中，如果不想清空未打印的設計列表，可像下面這樣調(diào)用print_models() :
# print_models(unprinted_designs[:], completed_models)
# 這樣函數(shù)print_models() 依然能夠完成其工作，因為它獲得了所有未打印的設計的名稱，但它使用的是列表unprinted_designs 的副本，而不是列 表unprinted_designs 本身。像以前一樣，列表completed_models 也將包含打印好的模型的名稱，但函數(shù)所做的修改不會影響到列表unprinted_designs 。
# 雖然向函數(shù)傳遞列表的副本可保留原始列表的內(nèi)容，但除非有充分的理由需要傳遞副本，否則還是應該將原始列表傳遞給函數(shù)，因為讓函數(shù)使用現(xiàn)成列表可避免花時間和內(nèi)存創(chuàng) 建副本，從而提高效率，在處理大型列表時尤其如此。


# 傳遞任意數(shù)量的實參
# 有時候，你預先不知道函數(shù)需要接受多少個實參，好在Python允許函數(shù)從調(diào)用語句中收集任意數(shù)量的實參。
# 例如，來看一個制作比薩的函數(shù)，它需要接受很多配料，但你無法預先確定顧客要多少種配料。
# 下面的函數(shù)只有一個形參*toppings ，但不管調(diào)用語句提供了多少實參，這個 形參都將它們統(tǒng)統(tǒng)收入囊中:
def make_pizza(*toppings):
    """打印顧客點的所有配料"""
    print(toppings)
# make_pizza('pepperoni')
# make_pizza('mushrooms', 'green peppers', 'extra cheese')


# 形參名*toppings 中的星號讓Python創(chuàng)建一個名為toppings 的空元組，并將收到的所有值都封裝到這個元組中。
# 函數(shù)體內(nèi)的print 語句通過生成輸出來證明Python能夠處理 使用一個值調(diào)用函數(shù)的情形，也能處理使用三個值來調(diào)用函數(shù)的情形。
# 它以類似的方式處理不同的調(diào)用，注意，Python將實參封裝到一個元組中，即便函數(shù)只收到一個值也如此

# 現(xiàn)在，我們可以將這條print 語句替換為一個循環(huán)，對配料列表進行遍歷，并對顧客點的比薩進行描述
def make_pizza(*toppings):
    """概述要制作的比薩"""
    print("\nMaking a pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)
# make_pizza('pepperoni')
# make_pizza('mushrooms', 'green peppers', 'extra cheese')

# 不管函數(shù)收到的實參是多少個，這種語法都管用


# 結(jié)合使用位置實參和任意數(shù)量實參
# 如果要讓函數(shù)接受不同類型的實參，必須在函數(shù)定義中將接納任意數(shù)量實參的形參放在最后。Python先匹配位置實參和關鍵字實參，再將余下的實參都收集到最后一個形參中。 例如，如果前面的函數(shù)還需要一個表示比薩尺寸的實參，必須將該形參放在形參*toppings 的前面:
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')
# 基于上述函數(shù)定義，Python將收到的第一個值存儲在形參size 中，并將其他的所有值都存儲在元組toppings 中。在函數(shù)調(diào)用中，首先指定表示比薩尺寸的實參，然后根據(jù)需要 指定任意數(shù)量的配料。
# 現(xiàn)在，每個比薩都有了尺寸和一系列配料，這些信息按正確的順序打印出來了——首先是尺寸，然后是配料:

# 使用任意數(shù)量的關鍵字實參
# 有時候，需要接受任意數(shù)量的實參，但預先不知道傳遞給函數(shù)的會是什么樣的信息。
# 在這種情況下，可將函數(shù)編寫成能夠接受任意數(shù)量的鍵—值對——調(diào)用語句提供了多少就接受多少。
# 一個這樣的示例是創(chuàng)建用戶簡介:你知道你將收到有關用戶的信息，但不確定會是什么樣的信息。
# 在下面的示例中，函數(shù)build_profile() 接受名和姓，同時還接受任意數(shù)量的關鍵字實參


def build_profile(first, last, **user_info):
    """創(chuàng)建一個字典，其中包含我們知道的有關用戶的一切"""
    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)


# 函數(shù)build_profile() 的定義要求提供名和姓，同時允許用戶根據(jù)需要提供任意數(shù)量的名稱—值對。
# 形參**user_info 中的兩個星號讓Python創(chuàng)建一個名為user_info 的 空字典，并將收到的所有名稱—值對都封裝到這個字典中。
# 在這個函數(shù)中，可以像訪問其他字典那樣訪問user_info 中的名稱—值對。
# 在build_profile() 的函數(shù)體內(nèi)，我們創(chuàng)建了一個名為profile 的空字典，用于存儲用戶簡介。我們將名和姓加入到這個字典中，因為我們總是會從用戶那里收到這兩項信息。
# 我們遍歷字典user_info 中的鍵—值對，并將每個鍵—值對都加入到字典profile 中。最后，我們將字典profile 返回。
# 我們調(diào)用build_profile() ，向它傳遞名('albert' )、姓('einstein' )和兩個鍵—值對(location='princeton' 和field='physics' )，并將返回 的profile 存儲在變量user_profile 中，再打印這個變量
#
# 在這里，返回的字典包含用戶的名和姓，還有求學的地方和所學專業(yè)。調(diào)用這個函數(shù)時，不管額外提供了多少個鍵—值對，它都能正確地處理。

# 函數(shù)存儲在模塊中 函數(shù)的優(yōu)點之一是，使用它們可將代碼塊與主程序分離。通過給函數(shù)指定描述性名稱，可讓主程序容易理解得多。你還可以更進一步，將函數(shù)存儲在被稱為模塊 的獨立文件中，
# 再將模塊導入 到主程序中。import 語句允許在當前運行的程序文件中使用模塊中的代碼。 通過將函數(shù)存儲在獨立的文件中，可隱藏程序代碼的細節(jié)，將重點放在程序的高層邏輯上。這還能讓你在眾多不同的程序中重用函數(shù)。將函數(shù)存儲在獨立文件中后，可與其他程
# 序員共享這些文件而不是整個程序。知道如何導入函數(shù)還能讓你使用其他程序員編寫的函數(shù)庫。
# 導入模塊的方法有多種，下面對每種都作簡要的介紹。

# 導入整個模塊
# 要讓函數(shù)是可導入的，得先創(chuàng)建模塊。模塊 是擴展名為.py的文件，包含要導入到程序中的代碼。下面來創(chuàng)建一個包含函數(shù)make_pizza() 的模塊。
# File:pizza.py 內(nèi)容如下：
# def make_pizza(size, *toppings):
#     """概述要制作的比薩"""
#     print("\nMaking a " + str(size) + "-inch pizza with the following toppings:")
#     for topping in toppings:
#         print("- " + topping)


# import pizza
# pizza.make_pizza(16, 'pepperoni')
# pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')


# Python讀取這個文件時，代碼行import pizza讓Python打開文件pizza.py，并將其中的所有函數(shù)都復制到這個程序中。
# 你看不到復制的代碼，因為這個程序運行時，Python在幕 后復制這些代碼。你只需知道，在making_pizzas.py中，可以使用pizza.py中定義的所有函數(shù)。
# 要調(diào)用被導入的模塊中的函數(shù)，可指定導入的模塊的名稱pizza 和函數(shù)名make_pizza() ，并用句點分隔它們


# 這就是一種導入方法:只需編寫一條import 語句并在其中指定模塊名，就可在程序中使用該模塊中的所有函數(shù)。
# 如果你使用這種import 語句導入了名為module_name.py 的整個模塊，就可使用下面的語法來使用其中任何一個函數(shù):
# module_name.function_name()

# 導入特定的函數(shù)
# 你還可以導入模塊中的特定函數(shù)，這種導入方法的語法如下:
# from module_name import function_name
# 通過用逗號分隔函數(shù)名，可根據(jù)需要從模塊中導入任意數(shù)量的函數(shù):
# from module_name import function_0, function_1, function_2

# 如果只想導入要使用的函數(shù)，代碼將類似于下面這樣:
# from pizza import make_pizza
# make_pizza(16, 'pepperoni')
# make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 若使用這種語法，調(diào)用函數(shù)時就無需使用句點。由于我們在import 語句中顯式地導入了函數(shù)make_pizza() ，因此調(diào)用它時只需指定其名稱。

# 使用as 給函數(shù)指定別名
# 如果要導入的函數(shù)的名稱可能與程序中現(xiàn)有的名稱沖突，或者函數(shù)的名稱太長，可指定簡短而獨一無二的別名 ——函數(shù)的另一個名稱，類似于外號。要給函數(shù)指定這種特殊外 號，需要在導入它時這樣做。
# 下面給函數(shù)make_pizza()指定了別名mp()。這是在import語句中使用make_pizza as mp實現(xiàn)的，關鍵字as將函數(shù)重命名為你提供的別名:
# from pizza import make_pizza as mp
# mp(16, 'pepperoni')
# mp(12, 'mushrooms', 'green peppers', 'extra cheese')
# 上面的import 語句將函數(shù)make_pizza() 重命名為mp() ;
# 在這個程序中，每當需要調(diào)用make_pizza() 時，都可簡寫成mp() ，而Python將運行make_pizza() 中的代 碼，這可避免與這個程序可能包含的函數(shù)make_pizza() 混淆。
# 指定別名的通用語法如下:
# from module_name import function_name as fn

# 使用as 給模塊指定別名
# 你還可以給模塊指定別名。通過給模塊指定簡短的別名(如給模塊pizza 指定別名p )，讓你能夠更輕松地調(diào)用模塊中的函數(shù)。相比于pizza.make_pizza()
# ，p.make_pizza() 更為簡潔

# import pizza as p
# p.make_pizza(16, 'pepperoni')
# p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 上述import 語句給模塊pizza 指定了別名p ，但該模塊中所有函數(shù)的名稱都沒變。
# 調(diào)用函數(shù)make_pizza() 時，可編寫代碼p.make_pizza() 而不 是pizza.make_pizza() ，這樣不僅能使代碼更簡潔，還可以讓你不再關注模塊名，而專注于描述性的函數(shù)名。
# 這些函數(shù)名明確地指出了函數(shù)的功能，對理解代碼而言，它們 比模塊名更重要。
# 給模塊指定別名的通用語法如下:
# import module_name as mn


# 導入模塊中的所有函數(shù)
# 使用星號(* )運算符可讓Python導入模塊中的所有函數(shù):

# from pizza import *
# make_pizza(16, 'pepperoni')
# make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# import 語句中的星號讓Python將模塊pizza 中的每個函數(shù)都復制到這個程序文件中。由于導入了每個函數(shù)，可通過名稱來調(diào)用每個函數(shù)，而無需使用句點表示法。
# 然而，使用 并非自己編寫的大型模塊時，最好不要采用這種導入方法:如果模塊中有函數(shù)的名稱與你的項目中使用的名稱相同，可能導致意想不到的結(jié)果:Python可能遇到多個名稱相同的函數(shù)或變量，進而覆蓋函數(shù)，而不是分別導入所有的函數(shù)。
# 最佳的做法是，要么只導入你需要使用的函數(shù)，要么導入整個模塊并使用句點表示法。這能讓代碼更清晰，更容易閱讀和理解。
# 在閱讀別人編寫的代碼時，如果遇到類似于下面的import 語句，希望能夠理解:
# from module_name import *



# 函數(shù)編寫指南
# 編寫函數(shù)時，需要牢記幾個細節(jié)。應給函數(shù)指定描述性名稱，且只在其中使用小寫字母和下劃線。描述性名稱可幫助你和別人明白代碼想要做什么。給模塊命名時也應遵循上述約定。
# 每個函數(shù)都應包含簡要地闡述其功能的注釋，該注釋應緊跟在函數(shù)定義后面，并采用文檔字符串格式。文檔良好的函數(shù)讓其他程序員只需閱讀文檔字符串中的描述就能夠使用它:他們完全可以相信代碼如描述的那樣運行;
# 只要知道函數(shù)的名稱、需要的實參以及返回值的類型，就能在自己的程序中使用它。

# 給形參指定默認值時，等號兩邊不要有空格:
# def function_name(parameter_0, parameter_1='default value')

# 對于函數(shù)調(diào)用中的關鍵字實參，也應遵循這種約定:
# function_name(value_0, parameter_1='value')


# PEP 8(https://www.python.org/dev/peps/pep-0008/ )建議代碼行的長度不要超過79字符，這樣只要編輯器窗口適中，就能看到整行代碼。
# 如果形參很多，導致函數(shù)定義的長度超過了 79字符，可在函數(shù)定義中輸入左括號后按回車鍵，并在下一行按兩次Tab鍵，從而將形參列表和只縮進一層的函數(shù)體區(qū)分開來。
# 大多數(shù)編輯器都會自動對齊后續(xù)參數(shù)列表行，使其縮進程度與你給第一個參數(shù)列表行指定的縮進程度相同:

# 大多數(shù)編輯器都會自動對齊后續(xù)參數(shù)列表行，使其縮進程度與你給第一個參數(shù)列表行指定的縮進程度相同:
# def function_name(
#         parameter_0, parameter_1, parameter_2,
#         parameter_3, parameter_4, parameter_5):
#     function body...

# 如果程序或模塊包含多個函數(shù)，可使用兩個空行將相鄰的函數(shù)分開，這樣將更容易知道前一個函數(shù)在什么地方結(jié)束，下一個函數(shù)從什么地方開始。
# 所有的import 語句都應放在文件開頭，唯一例外的情形是，在文件開頭使用了注釋來描述整個程序。



# 程序員的目標之一是，編寫簡單的代碼來完成任務，而函數(shù)有助于你實現(xiàn)這樣的目標。它們讓你編寫好代碼塊并確定其能夠正確運行后，就可置之不理。
# 確定函數(shù)能夠正確地完 成其工作后，你就可以接著投身于下一個編碼任務。
# 函數(shù)讓你編寫代碼一次后，想重用它們多少次就重用多少次。需要運行函數(shù)中的代碼時，只需編寫一行函數(shù)調(diào)用代碼，就可讓函數(shù)完成其工作。
# 需要修改函數(shù)的行為時，只需修 改一個代碼塊，而所做的修改將影響調(diào)用這個函數(shù)的每個地方。
# 使用函數(shù)讓程序更容易閱讀，而良好的函數(shù)名概述了程序各個部分的作用。相對于閱讀一系列的代碼塊，閱讀一系列函數(shù)調(diào)用讓你能夠更快地明白程序的作用。
# 函數(shù)還讓代碼更容易測試和調(diào)試。如果程序使用一系列的函數(shù)來完成其任務，而其中的每個函數(shù)都完成一項具體的工作，測試和維護起來將容易得多:
# 你可編寫分別調(diào)用每個函數(shù)的程序，并測試每個函數(shù)是否在它可能遇到的各種情形下都能正確地運行。
# 經(jīng)過這樣的測試后你就能信心滿滿，深信你每次調(diào)用這些函數(shù)時，它們都將正確地運行。