python入门基础(9)--函数及模块

函数是带名字的代码块，要执行函数定义的特定任务，可调用该函数。

需要在程序中多次执行同一项任务时，你无需反复编写完成该任务的代码，而只需调用执行该任务的函数，通过使用函数，程序的编写、阅读、测试和修复都将更容易。主程序文件的组织更为有序

一、如何定义一个函数

使用关键字 def 来定义一个函数。

def greeting_user():
print("Hello!,Welcome to Python World!")
greeting_user()

如上述代码：第一行定义一个函数greeting_user，第二行为函数的功能，即打印字符串 "Hello!,Welcome to Python World!"

第三行，即调用函数greeting_user，作用就是打印字符串。

1）向函数传递信息

稍作修改，在函数定义 def greeting_user() 的括号内添加 username ，可让函数接受所给定 username 指定的任何值。

这个函数就可以调用给 username 指定一个值，调用 greeting_user() 时，可将一个名字传递给它，如下所示： 

def greeting_user(username):
print("Hello!,Welcome "+ username.title() + " use Python programing language!")

greeting_user('Bush')
greeting_user('Jack')
greeting_user('Lucy')

代码 greeting_user('Bush') 调用函数 greeting_user() ，并向它提供执行 print 语句所需的信息。这个函数接受你传递给它的名字

 2）实参和形参

前面定义函数 greeting_user() 时，要求给变量 username 指定一个值。调用这个函数并提供这种信息（人名）时，它将打印相应的问候语。
在函数 greeting_user() 的定义中，变量 username 是一个形参—函数完成其工作所需的一项信息。

在代码 greeting_user('Bush') 中，值 'Bush'、‘Jack’、‘Lucy’ 是一个实参。实参是调用函数时传递给函数的信息，也即这几个字符串，会被传递给形参 username。

调用函数时，将要让函数使用的信息放在括号内。在greeting_user('Bush') 中，将实参'Bush' 传递给了函数 greeting_user() ，这个值被存储在形参 username 中。

 二、实参

1）位置实参

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

def my_pet(animal_type, pet_name):
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")

my_pet('dog', 'Wangcai')

 上述代码中，my_pet()函数中存在两个形参，即animal_type和pet_name，也就是在调用函数my_pet()时，需要2个参数，即在my_pet('dog', 'Wangcai')中，将‘dog’存入到animal_type中，‘Wangcai’存入到pet_name中，并在my_pet（）中的两个print语句中进行调用 。

注意：使用位置实参来调用函数时，如果实参的顺序不正确，结果会出错。

2）关键字实参

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

my_pet(animal_type='dog', pet_name='Wangcai')
my_pet(pet_name='Xiaoqiang',animal_type='cockroach')

函数 my_pet() 还是原来那样，但调用这个函数时，向Python明确地指出了各个实参对应的形参。注意：上述两个形参位置改变，在赋值的情况下，不影响程序运行。

运行结果

I have a dog.
My dog's name is Wangcai.

I have a cockroach.
My cockroach's name is Xiaoqiang.

3）默认值

编写函数时，可给每个形参指定默认值。如果在调用函数中给形参提供了实参，Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参

def my_new_pet(new_pet_name,new_animal_type='dog'):
print("\nI have a " + new_animal_type + ".")
print("My " + new_animal_type + "'s name is " + new_pet_name.title() + ".")

my_new_pet(new_pet_name='Wangcai')
my_new_pet(new_pet_name='Xiaoqiang')
my_new_pet(new_pet_name='Xiaoqiang',new_animal_type='cockroach')

运行结果：

I have a dog.
My dog's name is Wangcai.

I have a dog.
My dog's name is Xiaoqiang.

I have a cockroach.
My cockroach's name is Xiaoqiang.

　第一、二个my_new_pet(）函数调用只给定了两个名字，没有给定动物类型，则函数采用默认类型‘dog’，第三个函数调用给定的new_animal_type='cockroach'，则函数中两个打印调用给定的cockroach类型。

实际运行结果：

注意：可混合使用位置实参、关键字实参和默认值，通常有多种等效的函数调用方式，如上述

my_pet(animal_type='dog', pet_name='Wangcai')
my_pet(pet_name='Xiaoqiang',animal_type='cockroach')

my_new_pet(new_pet_name='Wangcai')
my_new_pet(new_pet_name='Xiaoqiang')
my_new_pet(new_pet_name='Xiaoqiang',new_animal_type='cockroach')

三 ，函数的返回值
函数可以处理一些数据，并返回一个或一组数值，函数返回的值被称为返回值。在函数中，可使用 return 语句将值返回到调用函数的代码行。返回值能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序

1）返回简单值

def get_full_name(first_name, middle_name, last_name):   #定义一个函数，有三个形参
full_name = first_name+' '+middle_name+' '+last_name #函数功能，将函数的三个形参进行连接
return full_name.title()                     #返回值

musician = get_full_name('Bush','lee', 'Alien')
# 调用返回值的函数时，需要提供一个变量musician，用于存储返回的值
# 通过函数将Bush和Alien连接后，赋值给变量musician
print(musician)

2)传递列表

向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象（如字典）,将列表传递给函数，函数就能直接访问其内容。

def menu_lists(menus):  #定义一个函数，参数为列表
for menu in menus:   #循环列表
msg = "The new menus is " + menu.title() + "!"
print(msg)  #打印列表

new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']
#定义一个列表
menu_lists(new_menus)
#调用函数menu_lists,并将列表new_menus传递给menu_lists(menus)中的形参menus,并执行函数中的循环

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

completed_menus = []  #创建一个名为 completed_menus 的空列表
# 模拟打印每个设计，直到没有未打印的菜单为止
# 打印每个菜单后，都将其移到列表completed_menus中
while new_menus:
current_menu = new_menus.pop() #pop,从列表new_menus末尾删除一个设计,并存放到变量名current_menu中
#模拟根据设计制作打印菜单的过程
print("Printing menu: " + current_menu)
completed_menus.append(current_menu)     #在列表completed_menus中，逐渐存入变量名current_menu的值

#下列代码打印new_menus
print(new_menus)  #打印出列表new_menus

print("\nThe following menus have been printed:")# 显示打印好的所有菜单
for completed_menu in completed_menus: #for循环,打印出列表completed_menus
print(completed_menu)

运行结果如下：

Printing menu: Chicken Feet with Pickled Peppers
Printing menu: Spicy fish pieces
Printing menu: Boiled meat
[]

The following menus have been printed:
Chicken Feet with Pickled Peppers
Spicy fish pieces
Boiled meat

　上述代码运行结果：

 

注：代码重组

在(1)函数中修改列表里列举的代码，有许多的重复功能 ，可以重新组织这些代码，编写两个函数，一个函数将负责处理打印菜单的工作，另一个将描写打印了哪些菜单。

#下述先定义两个函数
def print_menus(new_menus, completed_menus):  #定义一个函数将负责处理打印菜单的工作
while new_menus:  #当new_menus不为空
current_menu = new_menus.pop()    #弹出 new_menus中最后一个元素，并赋值给变量current_menu
#注意    pop()的顺序是反序，也即从最后一个元素开始，到第一个元素结束。
print("Printing menus: " + current_menu)
completed_menus.append(current_menu)    #列表completed_models逐渐增加

def show_completed_menus(completed_models):   #定义函数，显示已打印了哪些菜单
print("\nThe following models have been printed:")
for completed_model in completed_models: #for循环，打印出数列completed_models中的元素
print(completed_model)

#定义一个列表，一个空表，再调用上述两个函数。
new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']
completed_menus = [] #创建一个空表
print_menus(new_menus, completed_menus) #调用第一个函数，打印菜单
show_completed_menus(completed_menus)   #调用第2个函数，显示已完成菜单

运行结果：

Printing menus: Chicken Feet with Pickled Peppers
Printing menus: Spicy fish pieces
Printing menus: Boiled meat

The following models have been printed:
Chicken Feet with Pickled Peppers
Spicy fish pieces
Boiled meat

 （2）禁止函数修改列表

在程序运行时，可能需要禁止函数修改列表。

编写了一个将这些移到打印好的菜单列表中的函数，可能会做出这样的决定：即便打印所有菜单后，也需要保留原来的未打印的菜单列表，以供备案。

例如，上述列表new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']，由于使用pop,将所有菜单都移出了new_menus，使得列表new_menus变成了空的，致使原有数据丢失（如上述运行结果第4行显示为[]  ）。

为解决此问题，可向函数传递列表的副本；这样函数所做的任何修改都只影响副本，而丝毫不影响原列表。切片表示法 [:] 创建列表的副本 

#禁止函数修改列表
my_menus = ['meat', 'fish pieces', 'Chicken Feet']
print_menus(my_menus[:],completed_menus)

print(my_menus)  #重新打印列表my_menus,

如上述代码，重新定义一个列表my_menus ，调用重组后的函数print_menus，但参数只给定了my_menus[:]和completed_menus，最后重新打印列表my_menus ，检查是否是空列表。

运行结果如下：

Printing menus: Chicken Feet
Printing menus: fish pieces
Printing menus: meat
['meat', 'fish pieces', 'Chicken Feet']

3）传递任意数量的实参

当预先不知道函数需要接受多少个实参时，Python允许函数从调用语句中收集任意数量的实参。函数只有一个形参 *toppings ，但不管调用语句提供了多少实参，这个形参都将它们统统收入囊中

形参名 *toppings 中的星号让Python创建一个名为 toppings 的空元组，并将收到的所有值都封装到这个元组中

def make_menus(*toppings):
print("\nMaking a menus with the following toppings:")
for topping in toppings:
print("- " + topping)

make_menus('fish')
make_menus('meat', 'fish', 'beef')

运行如下：

Making a menus with the following toppings:
- fish

Making a menus with the following toppings:
- meat
- fish
- beef

（1）结合使用位置实参和任意数量实参　

在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中

def make_menus(size,*toppings):
print("\nMaking a "+str(size)+" kilogram menus with the following toppings:")
for topping in toppings:
print("- " + topping)

make_menus(2,'fish')
make_menus(6,'meat', 'fish', 'beef')

运行结果如下：

Making a 2 kilogram menus with the following toppings:
- fish

Making a 6 kilogram menus with the following toppings:
- meat
- fish
- beef

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

 

def get_person_info(given_name, family_name,**user_info):   #定义一个函数，有三个形参
person_info={}  #定义一个person_info
person_info['first_name']=family_name #字典里的第一个key为first_name，赋值为形参中的given_name
person_info['last_name']=given_name #字典里的第二个key为last_name，赋值为形参中的family_name

for key,value in user_info.items():
person_info[key]=value
return person_info

user_info = get_person_info('albert','einstein',location='princetion',field = 'physics')
print(user_info)

运行结果如下：

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

4）将函数存储在模块中

函数的优点:

一，可将代码块与主程序分离。通过给函数指定描述性名称，让主程序容易理解得多。

二、将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import 语句允许在当前运行的程序文件中使用模块中的代码。
通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上，能让你在不同的程序中重用函数。
函数存储在独立文件中后，可与其他程序员共享这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库

1）导入整个模块

让函数是可导入的，创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。如下图中的创建一个包含4个不同函数的 function 的模块

在mainframe中调用模块function及其中的函数

import function   #导入模块function

new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']
completed_menus = [] #创建一个空表
function.print_menus(new_menus, completed_menus) #调用模块function中的函数print_menus
function.show_completed_menus(completed_menus)   #调用模块function中的函数show_completed_menus
#禁止函数修改列表
my_menus = ['meat', 'fish pieces', 'Chicken Feet']
function.print_menus(my_menus[:],completed_menus)#调用模块function中的函数print_menus

function.make_menus(2,'fish')
function.make_menus(6,'meat', 'fish', 'beef')

user_info =function.get_person_info('albert','einstein',location='princetion',field = 'physics')
#调用模块function中的get_person_info函数
print(user_info)

2）导入特定的函数

from function import print_menus,show_completed_menus #直接导入某模块中的特定函数，

new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']
completed_menus = [] #创建一个空表
print_menus(new_menus, completed_menus) #调用函数print_menus
show_completed_menus(completed_menus)   #调用函数show_completed_menus

3） 使用 as 给模块指定别名

导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名，类似于外号，在引用 的过程中，就相对比较方便

import function as func #给function指定一个短的名称func

new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']
completed_menus = [] #创建一个空表
func.print_menus(new_menus, completed_menus) #调用函数print_menus
func.show_completed_menus(completed_menus)   #调用函数show_completed_menus

as 除了给模块指定别名，也可以给模块中的函数指定别名：

from function import  print_menus  as p_m
from function import  show_completed_menus as s_m

new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']
completed_menus = [] #创建一个空表
p_m(new_menus, completed_menus) #调用函数print_menus
s_m(completed_menus)   #调用函数show_completed_menus

4）导入模块中的所有函数

from function import  *

new_menus = ['Boiled meat', 'Spicy fish pieces', 'Chicken Feet with Pickled Peppers']
completed_menus = [] #创建一个空表
print_menus(new_menus, completed_menus) #调用函数print_menus
show_completed_menus(completed_menus)   #调用函数show_completed_menus

 

注意区别：(1)在导入模块时，使用函数用法：function.print_menus(new_menus, completed_menus)

                 (2) 导入特定的函数时，使用函数用法：print_menus(new_menus, completed_menus)

                 (3)使用模块的别名时，使用函数用法：func.print_menus(new_menus, completed_menus)

import 开头导入的模块，在使用的时候需要带上模块的名称或别名（  as 后面名称）

from  model  import *  这种类型的则不需要，可以直接调用函数。