Python编程从入门到实践（七）-函数

1 定义函数
下面是一个打印问候语的简单函数，名为greet_user()：

#greeter.py
def greet_user():
     """"显示简单的问候语"""
     print("Hello! ")
greet_user()

输出：
Hello!
1.1 向函数传递信息

#greeter.py
def greet_user(username):
     """"显示简单的问候语"""
     print("Hello! "+username.title()+"!")
greet_user('Scarlett')

输出：
Hello, Scarlett !
1.2 实参和形参
在函数greet_user()的定义中，变量username是一个形参——函数完成其工作所需的一项信息。在代码greet_user('jesse')中，值’jesse’是一个实参。实参是调用函数时传递给函数的信息
2 传递实参
2.1 位置实参
你调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参。
看一个显示宠物信息的函数。这个函数指出一个宠物属于哪种动物以及它叫什么名字，如下所示：

#pets.py
def describe_pet(animal_type,pet_name):
     """"显示宠物信息"""
     print("\n I have a"+animal_type+".")
     print("My "+animal_type+"'s name is "+pet_name.title() )
describe_pet('hamster','harry')

输出描述了一只名为Harry的仓鼠：
I have a hamster.
My hamster's name is Harry.
1．调用函数多次

#pets.py
def describe_pet(animal_type,pet_name):
     """"显示宠物信息"""
     print("\n I have a"+animal_type+".")
     print("My "+animal_type+"'s name is "+pet_name.title() )
describe_pet('hamster','harry')
describe_pet('dog', 'willie')

输出：
I have a hamster.
My hamster's name is Harry.
I have a dog.
My dog's name is Willie.
位置实参的顺序很重要，请确认函数调用中实参的顺序与函数定义中形参的顺序一致。
2.2 关键字实参
关键字实参是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆。

#pets.py
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')

关键字实参的顺序无关紧要，因为Python知道各个值该存储到哪个形参中。下面两个函数调用是等效的：
describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='harry', animal_type='hamster')
2.3 默认值

#pets.py
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='harry')

输出：
I have a dog.
My dog's name is Harry.

注意使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的形参。这让Python依然能够正确地解读位置实参。
2.4 等效的函数调用
鉴于可混合使用位置实参、关键字实参和默认值，通常有多种等效的函数调用方式。请看下面的函数describe_pet()的定义，其中给一个形参提供了默认值：
def describe_pet(pet_name, animal_type='dog'):
基于这种定义，在任何情况下都必须给pet_name提供实参；指定该实参时可以使用位置方式，也可以使用关键字方式。如果要描述的动物不是小狗，还必须在函数调用中给animal_type提供实参；同样，指定该实参时可以使用位置方式，也可以使用关键字方式。
下面对这个函数的所有调用都可行：

#pets.py
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='harry')
# 一条名为Willie的小狗
describe_pet('willie')
describe_pet(pet_name='willie')
# 一只名为Harry的仓鼠
describe_pet('harry', 'hamster')
describe_pet(pet_name='harry', animal_type='hamster')
describe_pet(animal_type='hamster', pet_name='harry')

3 返回值
在函数中，可使用return语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。
3.1 返回简单值
下面来看一个函数，它接受名和姓并返回整洁的姓名：

#formatted_name.py
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
3.2 让实参变成可选的
可使用默认值来让实参变成可选的。
例如，假设我们要扩展函数get_formatted_name()，使其还处理中间名。

#formatted_name.py
def get_formatted_name(first_name,middle_name,last_name):
     """"返回整洁的姓名"""
     full_name=first_name+' '+middle_name+' '+last_name
     return full_name.title()
musician=get_formatted_name('john','lee','hooker')
print(musician)

输出：
John Lee Hooker
然而，并非所有的人都有中间名，但如果你调用这个函数时只提供了名和姓，它将不能正确地运行。为让中间名变成可选的，可给实参middle_name指定一个默认值——空字符串，并将其移到形参列表的末尾,在用户没有提供中间名时不使用这个实参。

#formatted_name.py
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
3.3 返回字典
函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。例如，下面的函数接受姓名的组成部分，并返回一个表示人的字典：

#person.py
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'}
可以轻松地扩展这个函数，使其接受可选值，如中间名、年龄、职业或你要存储的其他任何信息。例如，下面的修改让你还能存储年龄：

#person.py
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)
musician = build_person('jimi','hendrix')
print(musician)

3.4 结合使用函数和while循环
下面尝试使用名和姓跟用户打招呼：

#greeter.py
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:")
    f_name = input("First name: ")
    l_name = input("Last name: ")
    formatted_name = get_formatted_name(f_name, l_name)
    print("\nHello, " + formatted_name + "! ")

下面我们要让用户能够尽可能容易地退出，因此每次提示用户输入时，都应提供退出途径。每次提示用户输入时，都使用break语句提供了退出循环的简单途径：

#greeter.py
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 + "! ")

输出：

4 传递列表
假设有一个用户列表，我们要问候其中的每位用户。下面的示例将一个名字列表传递给一个名为greet_users()的函数，这个函数问候列表中的每个人：

#greet_user.py
def greet_user(names):
     """"向列表中每位用户都发出简单问候"""
     for name in names:
         msg = "Hello,"+name.title()+"!"
         print(msg)
usernames=['hannah','ty','margot']
greet_user(usernames)

输出：
Hello, Hannah!
Hello, Ty!
Hello, Margot!
4.1 在函数中修改列表
来看一家为用户提交的设计制作3D打印模型的公司。需要打印的设计存储在一个列表中，打印后移到另一个列表中。下面是在不使用函数的情况下模拟这个过程的代码：

#printing_models.py
# 首先创建一个列表，其中包含一些要打印的设计
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
# 模拟打印每个设计，直到没有未打印的设计为止#  打印每个设计后，都将其移到列表completed_models中
while unprinted_designs:
    current_design = unprinted_designs.pop()
    #模拟根据设计制作3D打印模型的过程  
    print("Printing model: " + current_design)
    completed_models.append(current_design)
# 显示打印好的所有模型
print("\nThe following models have been printed:")
for completed_model in completed_models:
    print(completed_model)

输出：
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case
The following models have been printed:
dodecahedron
robot pendant
iphone case
为重新组织这些代码，我们可编写两个函数，每个都做一件具体的工作。大部分代码都与原来相同，只是效率更高。第一个函数将负责处理打印设计的工作，而第二个将概述打印了哪些设计：

#printing_models.py
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)

这个程序还演示了这样一种理念，即每个函数都应只负责一项具体的工作。第一个函数打印每个设计，而第二个显示打印好的模型；这优于使用一个函数来完成两项工作。编写函数时，如果你发现它执行的任务太多，请尝试将这些代码划分到两个函数中。别忘了，总是可以在一个函数中调用另一个函数，这有助于将复杂的任务划分成一系列的步骤。
4.2 禁止函数修改列表
有时候，需要禁止函数修改列表。例如，假设像前一个示例那样，你有一个未打印的设计列表，并编写了一个将这些设计移到打印好的模型列表中的函数。你可能会做出这样的决定：即便打印所有设计后，也要保留原来的未打印的设计列表，以供备案。但由于你将所有的设计都移出了unprinted_designs，这个列表变成了空的，原来的列表没有了。为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

function_name(list_name[:])
切片表示法[:]创建列表的副本。

在print_models.py中，如果不想清空未打印的设计列表，可像下面这样调用

print_models()：
print_models(unprinted_designs[:], completed_models)

虽然向函数传递列表的副本可保留原始列表的内容，但除非有充分的理由需要传递副本，否则还是应该将原始列表传递给函数，因为让函数使用现成列表可避免花时间和内存创建副本，从而提高效率，在处理大型列表时尤其如此。
5 传递任意数量的实参
有时候，你预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。
例如，来看一个制作比萨的函数，它需要接受很多配料，但你无法预先确定顾客要多少种配料。下面的函数只有一个形参*toppings，但不管调用语句提供了多少实参，这个形参都将它们统统收入囊中：

#pizza.py
def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。注意，Python将实参封装到一个元组中，即便函数只收到一个值也如此：
('pepperoni', )
('mushrooms', 'green peppers', 'extra cheese')
现在，我们可以将这条print语句替换为一个循环，对配料列表进行遍历，并对顾客点的比萨进行描述：

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')

输出：
Making a pizza with the following toppings:
- pepperoni
Making a pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese
不管函数收到的实参是多少个，这种语法都管用。
5.1 结合使用位置实参和任意数量实参
如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。
例如，如果前面的函数还需要一个表示比萨尺寸的实参，必须将该形参放在形参*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')

输出：
Making a 16-inch pizza with the following toppings:
- pepperoni
Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese
5.2 使用任意数量的关键字实参
有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接受多少。一个这样的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。在下面的示例中，函数build_profile()接受名和姓，同时还接受任意数量的关键字实参：

#user_profile.py
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'}

6 将函数存储在模块中
6.1 导入整个模块
要让函数是可导入的，得先创建模块。模块是扩展名为．py的文件，包含要导入到程序中的代码。下面来创建一个包含函数make_pizza()的模块：

#pizza.py
def make_pizza(size, *toppings):
    """概述要制作的比萨"""
    print("\nMaking a " + str(size) +"-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

接下来，我们在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件，这个文件导入刚创建的模块，再调用make_pizza()两次：

#making_pizzas.py
import pizza
pizza.make_pizza(16, 'pepperoni')
pizza.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
这就是一种导入方法：只需编写一条import语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。如果你使用这种import语句导入了名为module_name.py的整个模块，就可使用下面的语法来使用其中任何一个函数：
module_name.function_name()
6.2 导入特定的函数
你还可以导入模块中的特定函数，这种导入方法的语法如下：
from module_name import function_name
通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：
from module_name import function_0, function_1, function_2
对于前面的making_pizzas.py示例，如果只想导入要使用的函数，代码将类似于下面这样：

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

6.3 使用as给函数指定别名

from pizza import make_pizza as mp
mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

指定别名的通用语法如下：
from module_name import function_name as fn
6.4 使用as给模块指定别名
 

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

给模块指定别名的通用语法如下：
import module_name as mn
6.5 导入模块中的所有函数
使用星号（*）运算符可让Python导入模块中的所有函数：

from pizza import *
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

使用并非自己编写的大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名称相同，可能导致意想不到的结果：Python可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有的函数。
最佳的做法是，要么只导入你需要使用的函数，要么导入整个模块并使用句点表示法。这能让代码更清晰，更容易阅读和理解。
from module_name import *
7 函数编写指南
（1）给形参指定默认值时，等号两边不要有空格：
def function_name(parameter_0, parameter_1='default value')
（2）对于函数调用中的关键字实参，也应遵循这种约定：
function_name(value_0, parameter_1='value')
（3）PEP 8（https://www.python.org/dev/peps/pep-0008/）建议代码行的长度不要超过79字符，这样只要编辑器窗口适中，就能看到整行代码。如果形参很多，导致函数定义的长度超过了79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来。
（4）大多数编辑器都会自动对齐后续参数列表行，使其缩进程度与你给第一个参数列表行指定的缩进程度相同：
def function_name(
        parameter_0, parameter_1, parameter_2,
        parameter_3, parameter_4, parameter_5):
    function body...
（5）如果程序或模块包含多个函数，可使用两个空行将相邻的函数分开，这样将更容易知道前一个函数在什么地方结束，下一个函数从什么地方开始。
（6）所有的import语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释来描述整个程序。