python自学之《Python编程：从入门到实践》——关于函数

>>> def greet_user():
...     print("Hello!")
... 
>>> greet_user()
Hello!
>>> 

8.1.1 向函数传递信息
只需稍作修改，就可以让函数 greet_user() 不仅向用户显示 Hello! ，还将用户的名字用作抬头。为此，可在函数定义 def greet_user() 的括号内添加 username 。通过在这里添加 username ，就可让函数接受你给 username 指定的任何值。现在，这个函数要求你调用它时给 username 指定一个值。调用 greet_user() 时，可将一个名字传递给它，如下所示：

>>> def greet_user(username):
...     print("Hello, " + username.title() + "!")
... 
>>> greet_user('jesse')
Hello, Jesse!
>>> 

8.1.2 实参和形参
(1)前面定义函数 greet_user() 时，要求给变量 username 指定一个值。调用这个函数并提供这种信息（人名）时，它将打印相应的问候语。

(2)在函数 greet_user() 的定义中，变量 username 是一个形参 —— 函数完成其工作所需的一项信息。在代码greet_user(‘jesse’) 中，值 ‘jesse’ 是一个实参 。实参是调用函数时传递给函数的信息。我们调用函数时，将要让函数使用的信息放在括号内。在 greet_user(‘jesse’) 中，将实参 ‘jesse’ 传递给了函数 greet_user() ，这个值被存储在形参 username 中。

(3)注意:大家有时候会形参、实参不分，因此如果你看到有人将函数定义中的变量称为实参或将函数调用中的变量称为形参，不要大惊小怪。

8.2 传递实参
鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。向函数传递实参的方式很多，可使用位置实参 ，这要求实参的顺序与形参的顺序相同；也可使用关键字实参 ，其中每个实参都由变量名和值组成；还可使用列表和字典。下面来依次介绍这些方式。
8.2.1 位置实参
你调用函数时， Python 必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参 。

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

I have a hamster.
My hamster's name is Harry.
>>> 

>>> 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!
>>> 

8.4.1 在函数中修改列表
将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。

>>> unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
>>> completed_models = []
>>> while unprinted_designs:
...     current_design = unprinted_designs.pop()
...     print("Printing model:" + current_design)
...     completed_models.append(current_design)
... 
Printing model:dodecahedron
Printing model:robot pendant
Printing model:iphone case
>>> print("\nThe following models have been printed:")

The following models have been printed:
>>> for completed_model in completed_models:
...     print(completed_model)
... 
dodecahedron
robot pendant
iphone case
>>> 

>>> 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_deisgns = ['iphone case','robot pendant','dodecahedron']
>>> completed_models =[]
>>> print_models(unprinted_designs, completed_models)
>>> show_completed_models(compelted_models)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'compelted_models' is not defined
>>> show_completed_models(compeleted_models)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'compeleted_models' is not defined
>>> show_completed_models(completed_models)

The following models have been printed:

>>> 

8.5 传递任意数量的实参
(1)有时候，你预先不知道函数需要接受多少个实参，好在 Python 允许函数从调用语句中收集任意数量的实参。
(2)形参名 *toppings 中的星号让 Python 创建一个名为 toppings 的空元组，并将收到的所有值都封装到这个元组中。函数体内的 print 语句通过生成输出来证明 Python 能够处理使用一个值调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意， Python 将实参封装到一个元组中，即便函数只收到一个值也如此：

>>> def make_pizza(*toppings):
...     print(toppings)
... 
>>> make_pizza('pepperoni')
('pepperoni',)
>>> make_pizza('mushrooms', 'green peppers', 'extra cheese')
('mushrooms', 'green peppers', 'extra cheese')
>>> 

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

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

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

8.5.2 使用任意数量的关键字实参
(1)有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键 — 值对 —— 调用语句提供了多少就接受多少。一个这样的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。在下面的示例中，函数 build_profile() 接受名和姓，同时还接受任意数量的关键字实参：

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

8.6 将函数存储在模块中
(1)函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块> 的独立文件中， 再将模块导入 到主程序中。 import 语句允许在当前运行的程序文件中使用模块中的代码。
(2)通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后，可与其他程> 序员共享这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。
(3) 导入模块的方法有多种，下面对每种都作简要的介绍。
(4)8.6.1 导入整个模块
要让函数是可导入的，得先创建模块。模块 是扩展名为 .py 的文件，包含要导入到程序中的代码。下面来创建一个包含函数 make_pizza() 的模块。为此，我们将文件 pizza.py 中除函数 make_pizza() 之外的其他代码都删除：




PEP 8 （ https://www.python.org/dev/peps/pep-0008/ ）建议代码行的长度不要超过 79 字符，这样只要编辑器窗口适中，就能看到整行代码。如果形参很多，导致函数定义的长度超过了79 字符，可在函数定义中输入左括号后按回车键，并在下一行按两次 Tab 键，从而将形参列表和只缩进一层的函数体区分开来。

8.8 小结
(1) 在本章中，你学习了：如何编写函数，以及如何传递实参，让函数能够访问完成其工作所需的信息；如何使用位置实参和关键字实参，以及如何接受任意数量的实参；显示输出的函数和返回值的函数；如何将函数同列表、字典、 if 语句和 while 循环结合起来使用。
(2)你还知道了如何将函数存储在被称为模块 的独立文件中，让程序文件更简单、更易于理解。最后，你学习了函数编写指南，遵循这些指南可让程序始终结构良好，并对你和其他人来说易于阅读。
(3)程序员的目标之一是，编写简单的代码来完成任务，而函数有助于你实现这样的目标。它们让你编写好代码块并确定其能够正确运行后，就可置之不理。确定函数能够正确地完成其工作后，你就可以接着投身于下一个编码任务。
(4)函数让你编写代码一次后，想重用它们多少次就重用多少次。需要运行函数中的代码时，只需编写一行函数调用代码，就可让函数完成其工作。需要修改函数的行为时，只需修改一个代码块，而所做的修改将影响调用这个函数的每个地方。
(5)使用函数让程序更容易阅读，而良好的函数名概述了程序各个部分的作用。相对于阅读一系列的代码块，阅读一系列函数调用让你能够更快地明白程序的作用。
(6)函数还让代码更容易测试和调试。如果程序使用一系列的函数来完成其任务，而其中的每个函数都完成一项具体的工作，测试和维护起来将容易得多：你可编写分别调用每个函数的程序，并测试每个函数是否在它可能遇到的各种情形下都能正确地运行。经过这样的测试后你就能信心满满，深信你每次调用这些函数时，它们都将正确地运行。
(7)在第 9 章，你将学习编写类。类将函数和数据整洁地封装起来，让你能够灵活而高效地使用它们。