【Python学习】七、函数

7.1 定义函数 

def greet_user():
    """向用户问好"""
    print("Hello user!")

greet_user()

第一行的代码行使用关键字def 来告诉Python你要定义一个函数。

这是函数定义 ，向Python指出了函数名， 还可能在括号内指出函数为完成其任务需要什么样的信息。在这里，函数名为greet_user() ，它不需要任何信息就能完成其工作，因此括号是空的（即便如此，括号也必不可少）。最后，定义以冒号结尾。

第二行的文本是被称为文档字符串 （docstring）的注释，描述了函数是做什么的。文档字符串用三引号括起，Python使用它们来生成有关程序中函数的文档。

第三行代码行是函数体内的唯一一行代码

要使用这个函数，可调用它。函数调用让Python执行函数的代码。要调用函数，可依次指定函数名以及用括号括起的必要信息，如第四行。

 7.1.1 向函数传递信息

以上一个函数为例，为了向函数传递信息，只需在括号内添加一个变量username，就可让函数接 受你给username指定的任何值。

def greet_user(username):
    """向用户问好"""
    print("Hello " + username.title() + ".")

greet_user('alice')

7.1.2 形参和实参

在函数greet_user() 的定义中，变量username 是一个形参 ——函数完成其工作所需的一项信息。

在代码greet_user('alice') 中， 值'alice'是一个实参 。实参是调用函数时传递给函数的信息。

在greet_user('alice') 中，将实参'alice' 传递给了函 数greet_user() ，这个值被存储在形参username 中。

7.2 传递实参

7.2.1 位置实参

你调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参 。

def describe_pet(pet_kind, pet_name):
    """描述一个动物的类型和名称"""
    print("I have a " + pet_kind + " called " + pet_name +".")

describe_pet('dog', 'Tom')

 位置实参的位置特别重要！如果不按照次序对应，则会出现离谱的结果。

7.2.2 关键字实参

关键字实参是传递给函数的名称—值对。

你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Hamster 的harry这样的结果）。

关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

def describe_pet(pet_kind, pet_name):
    """描述一个动物的类型和名称"""
    print("I have a " + pet_kind + " called " + pet_name +".")

describe_pet('dog', 'Tom')
describe_pet(pet_kind='cat', pet_name='Bob')

 关键字实参的顺序无关紧要，因为Python知道各个值该存储到哪个形参中。

7.2.3 默认值

编写函数时，可给每个形参指定默认值 。

在调用函数中给形参提供了实参时，Python将使用指定的实参值；

否则，将使用形参的默认值。

因此，给形参指定默认值后，可在函数调用中省略相应的实参。

使用默认值可简化函数调用，还可清楚地指出函数的典型用法。

def describe_pet(pet_name, pet_kind='dog'):
    """描述一个动物的类型和名称"""
    print("I have a " + pet_kind + " called " + pet_name +".")

describe_pet('Frank')

这里修改了函数describe_pet() 的定义，在其中给形参pet_kind指定了默认值'dog' 。这样，调用这个函数时，如果没有给pet_kind指定值，Python将把这个形参设置为'dog' 

请注意，在这个函数的定义中，修改了形参的排列顺序。由于给 pet_kind指定了默认值，无需通过实参来指定动物类型，因此在 函数调用中只包含一个实参——宠物的名字。然而，Python依然将这个实参视为位置实参，因此如果函数调用中只包含宠物的名字，这个实参 将关联到函数定义中的第一个形参。这就是需要将pet_name放在形参列表开头的原因所在。 

def describe_pet(pet_name, pet_kind='dog'):
    """描述一个动物的类型和名称"""
    print("I have a " + pet_kind + " called " + pet_name +".")

describe_pet('Frank')
describe_pet("Frank", "cat")

注意 :使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。这让Python依然能够正确地解读位置实参。

7.3 返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值 。在函数中，可使用return 语句将值返回到调用函数的代码行。

7.3.1 返回简单返回值

def get_formatted_name(first_name, last_name):
    full_name = first_name.title() + ' ' + last_name.title()
    return full_name

name = get_formatted_name('chow', 'runfat')
print(name)

7.3.2 让参数变成可选的

有时候，需要让实参变成可选的，这样使用函数的人就只需在必要时才 提供额外的信息。可使用默认值来让实参变成可选的。

def get_formatted_name(first_name, last_name, middle_name = ' '):
    full_name = (first_name + " " + middle_name + " " + last_name).title()
    return full_name

name = get_formatted_name('chow', 'fat', 'run')
print(name)
name = get_formatted_name('wu', 'ke')
print(name)

这个修改后的版本适用于只有名和姓的人，也适用于还有中间名的人。

7.3.3 返回词典

函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。例 如，下面的函数接受姓名的组成部分，并返回一个表示人的字典.

def build_person(first_name, last_name):
    person = {'first' : first_name.title(), 'last' : last_name.title()}
    return  person

p1 = build_person('chow', 'runfat')
print(p1)

你可以轻松地扩展这个函数，使其接受可选值，如中间名、年龄、职业或你要存储的其他任何信 息。例如，下面的修改让你还能存储年龄:

def build_person(first_name, last_name, age = ''):
    person = {'first' : first_name.title(), 'last' : last_name.title()}
    if age:
        person['age'] = age
    return person

p1 = build_person('chow', 'runfat', str(32))
print(p1)

 7.3.4 结合while循环

可将函数同本书前面介绍的任何Python结构结合起来使用。例如，下面 将结合使用函数get_formatted_name() 和while 循环，以更正规的方式问候用户。

def get_formatted_name(first_name, last_name, middle_name=' '):
    full_name = (first_name + " " + middle_name + " " + last_name).title()
    return full_name

while True:
    print("please key in your first name and last name:")
    print('\n key in quit to exit.')
    f_name = input("please key in your first name:")
    if f_name == 'q':
        break
    l_name = input('please key in your last name:')
    if l_name == 'q':
        break
    name = get_formatted_name(f_name, l_name)
    print('Hello ' + name + "!")

7.4 传递列表

你经常会发现，向函数传递列表很有用，这种列表包含的可能是名字、 数字或更复杂的对象（如字典）。将列表传递给函数后，函数就能直接访问其内容。下面使用函数来提高处理列表的效率。

def greet_users(names):
    for name in names:
        print("Hello " + name.title() + '!')

user_names = ['alice', 'bob', 'carol', 'dave']
greet_users(user_names)

 7.4.1 在函数中修改列表

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

# 首先创建一个列表，其中包含一些要打印的设计
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)

 为重新组织这些代码，我们可编写两个函数，每个都做一件具体的工 作。大部分代码都与原来相同，只是效率更高。第一个函数将负责处理打印设计的工作，而第二个将概述打印了哪些设计

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

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

up_designs = ['apple', 'bmw', 'huawei']
cp_designs = []
print_design(up_designs, cp_designs)
already_design(cp_designs)

这个程序的输出与未使用函数的版本相同，但组织更为有序。完成大部 分工作的代码都移到了两个函数中，让主程序更容易理解。

7.4.2 禁止函数修改列表

有时候，需要禁止函数修改列表，为此可以向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

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

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

up_designs = ['apple', 'bmw', 'huawei']
cp_designs = []
print_design(up_designs[:], cp_designs)
already_design(cp_designs)

print("\n")
for up_design in up_designs:
    print(up_design)

8.5 传递任意数量的实参

有时候，你预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。

下面的函数只有一个形参*toppings ，但不管调用语句提供了多少实参，这个形参都将它们统统收入囊中：

def pizza(*toppings):
        print(toppings)

pizza('apple')
pizza('apple', 'banana', 'orange')

def pizza(*toppings):
    print("我们将在披萨中加如下配料:")
    for topping in toppings:
        print(topping)

pizza('apple')
pizza('apple', 'banana', 'orange')

7.5.1 结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

def pizza(size, *toppings):
    print("我们要制作一个" + str(size) +"寸大小的披萨。")
    print("我们将在披萨中加如下配料:")
    for topping in toppings:
        print(topping)

pizza(5, 'apple')
pizza(12, 'apple', 'banana', 'orange')

 7.5.2 使用任意数量的关键字实参

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什 么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接受多少。

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

user1 = build_profile('chung', 'runfate', home = 'hongkong', school = 'PKU')
print(user1)

调用这个函数时，不管额外提供了多少个键—值对，它都能正确地处理。 

7.6 将函数存储在模块中

函数的优点之一是，使用它们可将代码块与主程序分离。

你还可以更进一步，将函数 存储在被称为模块的独立文件中，再将模块导入到主程序中。

import 语句允许在当前运行的程序文件中使用模块中的代码。

7.6.1 导入整个模块

要让函数是可导入的，得先创建模块。

模块是扩展名为.py的文件，包含要导入到程序中的代码。

# pizza.py
def make_pizza(size, *toppings):
    print("我们将要制作" + str(size) + "寸的披萨。")
    for topping in toppings:
        print("我们将要在披萨里增加" + topping + "配料.")
# 主程序
import pizza

pizza.make_pizza(12, 'apple', 'orange', 'beef', 'meat')

代码行import pizza 让Python打开文件 pizza.py，并将其中的所有函数都复制到这个程序中。

要调用被导入的模块中的函数，可指定导入的模块的名称pizza 和函数名make_pizza() ，并用句点分隔它们。

7.6.2 导入特定的函数 

你还可以导入模块中的特定函数，这种导入方法的语法如下

from module_name import function_name
from module_name import function_0, function_1, function_2

from pizza import make_pizza

make_pizza(12, 'apple', 'orange', 'beef', 'meat')

 7.6.3 使用as给函数指定别名

如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名——函数的另一个名称，类似于外号。

要给函数指定这种特殊外号，需要在导入它时这样做。

from pizza import make_pizza as mp

mp(12, 'apple', 'orange', 'beef', 'meat')

 指定别名的通用语法如下：

from module_name import function_name as fn

7.6.4 使用as 给模块指定别名

你还可以给模块指定别名。通过给模块指定简短的别名

import module_name as mn

import pizza as p

p.make_pizza(12, 'apple', 'orange', 'beef', 'meat')

 7.6.5 导入模块中的所有函数

使用星号（* ）运算符可让Python导入模块中的所有函数

from pizza import *
make_pizza(12, 'apple', 'orange', 'beef', 'meat')

import 语句中的星号让Python将模块pizza中的每个函数都复制到这个程序文件中。

由于导入了每个函数，可通过名称来调用每个函数，而无需使用句点表示法。

然而，使用并非自己编写的大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名 称相同，可能导致意想不到的结果：Python可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有的函数。

最佳的做法是，要么只导入你需要使用的函数，要么导入整个模块并使 用句点表示法。这能让代码更清晰，更容易阅读和理解。

7.7 练习

7-1 消息 ：编写一个名为display_message() 的函数，它打印一 个句子，指出你在本章学的是什么。调用这个函数，确认显示的消息正确无误。

# 7-1
def display_message():
    print("今天我们学习函数。")

display_message()

7-2 喜欢的图书 ：编写一个名为favorite_book() 的函数，其中 包含一个名为title的形参。这个函数打印一条消息，如One of my favorite books is Alice in Wonderland 。调用这个函 数，并将一本图书的名称作为实参传递给它。

# 7-2
def favourite_book(title):
    print("One of my favorite books is " + title.title() + ".")

favourite_book('the three kingdoms')

7-3 T恤 ：编写一个名为make_shirt() 的函数，它接受一个尺码以及要印到T恤上的字样。这个函数应打印一个句子，概要地说明T恤的尺码和字样。

# 7-3
def make_shirt(size, pattern):
    print("印制一款" + str(size) + '尺寸并且有' + pattern + "图案的T恤。")

make_shirt(12, 'pku')
make_shirt(size=12, pattern='pku')

7-4 大号T恤 ：修改函数make_shirt() ，使其在默认情况下制作 一件印有字样“I love Python”的大号T恤。调用这个函数来制作如下T恤：一件印有默认字样的大号T恤、一件印有默认字样的中号T恤 和一件印有其他字样的T恤（尺码无关紧要）。

# 7-4
def make_shirt(size, pattern='I love python!'):
    print("印制一款" + str(size) + '尺寸并且有' + pattern + "图案的T恤。")

make_shirt('大号', )
make_shirt('中号', )
make_shirt('中号', 'China')

7-5 城市 ：编写一个名为describe_city() 的函数，它接受一座城市的名字以及该城市所属的国家。这个函数应打印一个简单的句子，如Reykjavik is in Iceland 。给用于存储国家的形参指定默认值。为三座不同的城市调用这个函数，且其中至少有一座城市不属于默认国家。

# 7-5
def describe_city(city='Reykjavik', country='Iceland'):
    print(city.title() + " is in " + country.title() + '.')

describe_city('taipei', 'china')
describe_city('hongkong', 'china')
describe_city('london', 'britain')

7-6 城市名 ：编写一个名为city_country() 的函数，它接受城市 的名称及其所属的国家。

# 7-6
def city_country(city, country):
    message = city.title() + ',' + country.title()
    return message

print(city_country('taipei', 'china'))
print(city_country('jinan', 'china'))
print(city_country('tokyo', 'japan'))

7-7 专辑 ：编写一个名为make_album() 的函数，它创建一个描述音乐专辑的字典。这个函数应接受歌手的名字和专辑名，并返回一个包含这两项信息的字典。使用这个函数创建三个表示不同专辑的字典，并打印每个返回的值，以核实字典正确地存储了专辑的信息。

给函数make_album() 添加一个可选形参，以便能够存储专辑包含的歌曲数。如果调用这个函数时指定了歌曲数，就将这个值添加到表示专辑的字典中。调用这个函数，并至少在一次调用中指定专辑包含的歌曲数。

# 7-7
def make_album(singer, album):
    dict = {'singer': singer, 'albunm': album}
    return dict

print(make_album('Jay chow', 'Qi Li Xiang'))
print(make_album('Zheng Zhihua', 'Xing Xing Dian Deng'))
print(make_album('Ren Xian Qi', 'Tian Ya'))

def make_album(singer, album, number =''):
    dict = {'singer': singer, 'albunm': album}
    if number:
        dict['number'] = number
    return dict

print(make_album('Ren Xian Qi', 'Tianya', 9))

 7-8 用户的专辑 ：在为完成练习8-7编写的程序中，编写一个while循环，让用户输入一个专辑的歌手和名称。获取这些信息后，使用它们来调用函数make_album() ，并将创建的字典打印出来。在这 个while 循环中，务必要提供退出途径。

# 7-8

def make_album(singer, album, number =''):
    dict = {'singer': singer, 'albunm': album}
    if number:
        dict['number'] = number
    return dict

active = True
while active:
    singer = input("请输入歌手名，退出请按q。")
    if singer == 'q':
        break
    album = input('请输入专辑名，退出请按q。')
    if album == 'q':
        break
    number = input("（可选）请输入数目，退出请按q。")
    if number == 'q':
        break
    print(make_album(singer, album, number))

7-9 魔术师 ：创建一个包含魔术师名字的列表，并将其传递给一个 名为show_magicians() 的函数，这个函数打印列表中每个魔术师的名字。

# 7-9
def show_magicians(*names):
    for name in names:
        print(name)

show_magicians('zsc', 'ltt', 'zm', 'dq', 'zcl', 'ygz')

 7-10 了不起的魔术师 ：在你为完成练习8-9而编写的程序中，编写一个名为make_great() 的函数，对魔术师列表进行修改，在每个魔术师的名字中都加入字样“the Great”。调用函数show_magicians() ，确认魔术师列表确实变了。

# 7-10
def show_magicians(names):
    for name in names:
        print(name)

def make_great(names):
    modified_names = []
    while names:
        current_name = "The Great " +names.pop()
        modified_names.append(current_name)
    return modified_names

names = ['zsc', 'ltt', 'zm', 'dq', 'zcl', 'ygz']
show_magicians(names)
names = make_great(names)
show_magicians(names)

 7-11 不变的魔术师 ：修改你为完成练习8-10而编写的程序，在调 用函数make_great() 时，向它传递魔术师列表的副本。由于不想 修改原始列表，请返回修改后的列表，并将其存储到另一个列表 中。分别使用这两个列表来调用show_magicians() ，确认一个列 表包含的是原来的魔术师名字，而另一个列表包含的是添加了字 样“the Great”的魔术师名字。

def show_magicians(names):
    for name in names:
        print(name)

def make_great(names):
    modified_names = []
    while names:
        current_name = "The Great " +names.pop()
        modified_names.append(current_name)
    return modified_names

names =  ['zsc', 'ltt', 'zm', 'dq', 'zcl', 'ygz']
show_magicians(names)
print("\n")
names_new = make_great(names[:])
show_magicians(names)
print('\n')
show_magicians(names_new)
print('\n')

 7-12 三明治 ：编写一个函数，它接受顾客要在三明治中添加的一系列食材。这个函数只有一个形参（它收集函数调用中提供的所有 食材），并打印一条消息，对顾客点的三明治进行概述。调用这个函数三次，每次都提供不同数量的实参。

# 7-12
def make_sandwich(*toppings):
    for topping in toppings:
        print(topping)

make_sandwich('apple')
print("\n")
make_sandwich('apple', 'banana')
print("\n")
make_sandwich('apple','banana', 'orange')
print("\n")

7-13 用户简介 ：复制前面的程序user_profile.py，在其中调 用build_profile() 来创建有关你的简介；调用这个函数时，指 定你的名和姓，以及三个描述你的键-值对。

# 7-13
def build_profile(first, last, **info):
    profile = {}
    profile['first name'] = first
    profile['last name'] = last
    for key, value in info.items():
        profile[key] = value
    return profile

my_info = build_profile("Lee", "Ming",home='Beijing', age='34', school="PKU")

print(my_info)

7-14 汽车 ：编写一个函数，将一辆汽车的信息存储在一个字典 中。这个函数总是接受制造商和型号，还接受任意数量的关键字实参。这样调用这个函数：提供必不可少的信息，以及两个名称—值 对，如颜色和选装配件。

# 7-14
def car_infos(brand, number, **infos):
    car = {}
    car['brand'] = brand
    car['number'] = number
    for key, value in infos.items():
        car[key] = value
    return car

car1 = car_infos('BMW', 'Z7', color='white', country='China', age=3)
print(car1)

 

 7-16 导入 ：选择一个你编写的且只包含一个函数的程序，并将这 个函数放在另一个文件中。在主程序文件中，使用下述各种方法导 入这个函数，再调用它：

# add.py
def add2(num1, num2):
    return  num1 + num2
# main

import add
print(add.add2(1,3))

from add import add2
print(add2(1,3))

import add as ad
print(ad.add2(1,3))

from add import add2 as a2
print(a2(1,3))

from add import  *
print(add2(1,3))