Python_函数

定义函数

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

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

greet_user()

Hello!

  这个示例演示了最简单的函数结构。使用关键字def来告诉Python你要定义一个函数。这是函数定义，向Python指出了函数名，还可能在括号内指出函数为完成其任务需要什么样的信息。在这里，函数名为greet_user(),它需要任何信息就能完成工作，因此括号是空的。最后，定义以冒号结尾。
  紧跟在def greet_user():后面的所有缩进构成了函数体。第二行的文本是被称为文档字符串的注释，描述了函数是做什么的。文档字符串是有三引号括起，Python用它们来生成有关程序中函数的文档。
  代码中print(“Hello！”)是函数体唯一一行代码，greet_user（）只做一项工作：打印Hello!.
  要使用这个函数，可调用它。函数调用让Python执行函数的代码。要调用函数，可依次指定函数名以及括号括起的必要信息。由于这个函数不需要任何信息，因此调用它时只需输入greet_user（）即可。

向函数传递信息

  只需稍作修改，就可以让函数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!

  greet_user(‘jesse’)调用函数greet_user(),并向它提供执行print语句所需的信息。这个函数接手你传递给它的名字，并向这个人发出问候。

实参和形参

  前面定义的greet_user()时，要求给变量username指定一个值。调用这个函数并提供这种信息（人名）时，它将打印相应的问候语。
  在函数greet_user()的定义中，变量username是一个形参——函数完成其工作所需的一项信息。在代码greet_user(‘jesse’)中，值‘jesse’是一个实参。实参是调用函数时传递给函数的信息。我们调用函数时，将要调用的函数信息放在括号内。在greet_user(‘jesse’）中，将实参‘jesse’传递给了函数greet_user( ),这个值被存储在形参username中。

传递实参

  鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。向函数传递实参的方式很多，可用位置实参，这要求实参的顺序与形参的循序相同；也可以使用关键字实参，其中每个实参都由变量名和值组成；还可使用列表和字典。

位置实参

  你调用函数时，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.

  这个函数的定义表明，它需要一种动物类型和一个动物名字。调用describe_pet（）时，需要按顺序提供一种动物类型和一个名字。

关键字实参

  关键字实参是传递给函数的名称-值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆。关键字实参让你无需考虑函数调用中的实参顺序,还清楚地指出了函数调用中各个值的用途。

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( )还是原来那样,但调用这个函数时，我们向Python明确地指出了各个实参对应的形参。看到这个函数调用时，Python知道应该将实参‘hamster’和‘harry’分别存储在形参animal_type和pet_name中。输出正确无误。
  关键字实参的顺序无关紧要，因为Python知道各个值该存储到哪个形参中。

默认值

  编写函数时,可给每个形参指定默认值。在调用函数中给形参提供了实参时,Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚的指出函数的典型用法。

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

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

返回值

  函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值。在函数中，可使用return语句将值返回到调用函数的代码行。返回值让你能都将程序的大部分繁重的工作移到函数中去完成,从而简化主程序。

返回简单值

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

  调用返回值的函数时,需要提供一个变量，用于存储返回的值。在这里，将返回值存储在了变量musician中。

让实参变成可选的

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

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('john','hooker','lee')
print(musician)

musician=get_formatted_name('jimi','hendrix')
print(musician)

John Lee Hooker
Jimi Hendrix

  这个函数让中间名变成可选的，给实参middle_name指定一个默认值——空字符串，并在用户没有提供中间名时不使用这个实参。
  调用这个函数时, 如果只想指定名和姓，调用起来非常简单。如果还要指定中间名，就必须确保它是最后一个实参,这样python才能正确地将位置实参关联到实参。

返回字典

  函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。

def build_person(first_name,last_name):
    """返回一个字典，其中包含有关一个人的信息"""
    person={'first':first_name,'last':last_name}
    return person

musician=build_person('jimi','hendrix')
print(musician)

{'last': 'hendrix', 'first': 'jimi'}

  函数build_person（）接受名和姓，并将这些封装到字典中。存储在first_name的值时，使用的键为‘first’，而存储last_name的值时，使用的键为‘last’。最后，返回表示人的整个字典。
  这个函数接受简单的文本信息，将其放在一个更适合的数据结构中，让你不仅能打印这些信息，还能以其他方式处理它们。当前，字符串‘jimi’和‘hendrix’被标记为名和姓。你可以轻松的扩展这个函数,但其接手可选值，如中间名、年龄、职业或你要存储的其他信息。例如，下面这些修改还可以存储年龄：

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)

{'first': 'jimi', 'last': 'hendrix', 'age': 27}

  在函数定义中，我们新增了一个可选形参，并将其默认值设置为空字符串。如果函数调用中包含这个形参的值，这个值将存储到字典中。在任何情况下，这个函数都会存储人的姓名，但可对其进行修改，使其也存储有关人的其它信息。

结合函数使用while循环

def get_formatted_name(first_name,last_name):
    """显示简单的问候语"""
    full_name=first_name+' '+last_name
    return full_name.title()
#这是一个无限循环
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+"!")


Please tell me your name:
(enter 'q' at any time to quit)
First name: jack
Last name: cheng

Hello, Jack Cheng!

Please tell me your name:
(enter 'q' at any time to quit)
First name: q

  我们添加了一条信息来告诉用户如何退出,然后在每次提示用户输入时，都检查他输入的是否是退出值，如果是，就退出循环。这个程序将不断的问候，直到输入的姓名为‘q’为止。

传递列表

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

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!

  我们将greet_users()定义成接受一个名字列表，并将其存储在形参中。这个函数遍历收到的列表，并对其中的每位用户都打印一条问候语。我们定义了一个用户列表——usernames,然后调用greet_users()，并将这个值传递给它。

在函数中修改列表

  将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能高效的处理大量的数据。
  来看一家为用户提交的设计制作3D打印模型的公司。需要打印的设计存储在一个列表中，打印后移到另一个列表中。

#首先创建一个列表，其中包含一些要打印的设计
unprinted_designs=['iphone case','root 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: root pendant
Printing model: iphone case

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

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

#模拟打印每个设计，直到没有未打印的设计为止
#打印每个设计后，都将其转移到列表completed_models中
def design(unprinted_designs,completed_models):
#模拟根据设计制作3D打印模型的过程,这里用for和while都可以达到相同的目的 
    """for unprinted_design in unprinted_designs:
        print("Printing model: "+unprinted_design)
        completed_models.append(unprinted_design)"""

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

#显示打印好的所有模型
def printer(completed_models):
    print("\nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

unprinted_designs=['iphone case','root pendant','dodecahedron']
completed_models=[]
design(unprinted_designs[:],completed_models)
printer(completed_models)

禁止函数修改列表

  有时候，需要禁止函数修改列表。例如,假设像前一个示例那样，你有一个未打印的设计列表，并编写了一个将这些设计移到打印好的模型列表中的函数u。你可能会做出这样的决定：即便打印出所有设计后，也要保留原来未打印的设计列表，以供备案。但由于你将所有的设计都移出了unprinted_designs,这个列表变成空的，原来的列表没有了。为解决这个问题，可向函数列表的副本，而不是原件；这样函数所做的修改都只影响副本，而不影响原件。
  切片表示法[ : ]创建列表的副本。如果不想清空未打印的设计列表，可像下面这样调用print_models( ):

design(unprinted_designs[:],completed_models)

  虽然向函数传递列表的副本可保留原始列表的内容,但除非有充分的理由需要传递副本，否则还是应该将原始列表传递给函数，因为让函数使用现成列表可避免花时间和内存创建副本，从而提高效率，在处理大型列表时尤其如此。

传递任意数量的实参

  有时候，你预先不知道函数需要多少个实参，好在Python允许函数u从调用语句中收集任意数量的实参。
  例如，来看一个制作披萨的函数，它需要接受很多配料，但你无法预先确定顾客要多少钟配料。下面的函数只有一个形参*toppings，但不管调用语句提供了多少实参,这个形参都将它们统统收入囊中。

def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

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

  

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

  例如，如果前面的函数还需要一个表示比披萨尺寸的实参,必须将形参放在形参*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

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

  有时候需要接受任意数量的实参，但预先不知道传递函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键-值对——调用了多少就提供多少。一个这样简单的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。在下面的示例中,函数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)

{'field': 'physics', 'last_name': 'einstein', 'location': 'princeton', 'first_name': 'albert'}

  函数build_profile（）的定义要求提供名和姓，同事允许用户根据需要提供任意数量的名称-值对。形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称——值对都封装到这个字典中。在这个函数中,可以像访问其他字典那样访问user_info中的名称——值对。

将函数存储在模块中

  函数的优点之一是使用它们可将代码块和主程序分离。通过函数制定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import语句允许在当前运行的程序文件中使用模块中的代码。
  通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。这还能在众多不同的程序中重用函数。将函数存储在独立文件后,可与其他程序员共享这些文件而不是整个程序。知道如何导入这个函数，还能让你使用其他程序员编写的函数库。

导入整个模块

  要让函数是可导入的，得先创建模块。模块的扩展名是.py的文件，包含要导入程序中的代码。下面来创建一个包含函数make_pizza（）的模块。为此，我们将文件pizza.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_pizza.py的文件，这个文件导入刚创建的模块，再调用make_pizza（）两次：

making_pizza.py

import pizza

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

  Python读取这个文件时，代码行import pizza让Python打开文件pizza.py，并将其中的所有函数都复制到这个程序中。你看不到复制的代码，因为这个程序运行时，Python在幕后复制这些代码。你只需知道，在making_pizzas.py中，可以使用pizza.py定义的所有函数。

导入特定的函数

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

from module_name import function_name

  通过使用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

from module_name import function_0，function_1,function_2

  对于前面的making_pizza.py的示例，如果你只想导入想要使用的函数，代码类似于下面这样：

from pizza import make_pizza

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

  若使用这种语法，调用函数就无需使用句点。由于我们在import语句中显示地导入了函数make_pizza( ),因此调用它时无需指定其名称。

使用as给函数指定别名

  如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名——函数的另外一个名称，类似于外号。
  下面给函数make_pizza指定了别名mp().这是在import语句中使用make_pizza as mp实现的。

from pizza import make_pizza as mp

mp(16,'pepperoni')
mp(12,'mushrooms','green peppers','extra cheese')

使用as 给模块指定别名

  你还可以给模块指定别名。通过给模块指定别名（如给模块pizza指定别名p）,让你能够更轻松的调用模块中的函数。相比于pizza.make_pizza( ),p.make_pizza( )更为简洁。

import pizza as p

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

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

from pizza import *

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