python-函数

函数

定义函数

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

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

向函数传递信息

def greet_user(username):
    """a"""
    print("hello, " + username)
greet_user('jesse')

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

实参和形参

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

传递实参

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

位置实参

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

def qwer(a,b):
    print("wo jiao " + a + ",wo zui ai" + b)
qwer('xiao jin','xiao wu')
qwer('xiao jin','xiao wu1')

关键字实参

关键字实参是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆(不会得到名为Hamster的harry这样的结果)。关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途

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将使用指定的实参值;否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法

#默认值
def qwer(a,b='xiao liu'):
    print("wo jiao " + a + ",wo zui ai " + b)
qwer('xiao jin')

#输出 wo jiao xiao jin,wo zui ai xiao liu

#写了实参则不取默认值
def qwer(a,b='xiao liu'):
    print("wo jiao " + a + ",wo zui ai " + b)
qwer('xiao jin','xiao wu')

#wo jiao xiao jin,wo zui ai xiao wu

返回值

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

例子

def a(xing,ming):
    quanming =  xing + ' ' + ming
    return quanming.title()

c = a('jin','tianyu')
print(c)

让实参变成可选的

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

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

def a(xing , zhongjian , ming='' ):
    if zhongjian:
        quanming = xing + ' ' + zhongjian + ' ' + ming
    else:
        quanming = xing + ' ' + ming
    return  quanming.title()

b = a('jin','tian','yu')
print(b)

b = a('xiao','jin')
print(b)

返回字典

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

def a(xing,ming,age=''):
    person = {'x':xing,'m':ming}
    if age:
        person['age'] = age
    return person

dd = a('jin','tianyu', age=27)
print(dd)

结合使用函数和while循环

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

aa=True
def mingzi(xing,ming):
    quanming= xing + ' ' + ming
    return quanming.title()

while aa:
    print("ni jiao shen ma:")
    print("an 'q' tui chu")
    xing_a = input("xing:")
    if xing_a == 'q':
        break
    ming_a = input("ming:")
    if ming_a == 'q':
        break

    mingzi_a = mingzi(xing_a,ming_a)
    print("ni hao:" + mingzi_a)

传递列表

向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象(如字典)。将列表传递给函数后，函数就能直接访问其内容。下面使用函数来提高处理列表的效率。
假设有一个用户列表，我们要问候其中的每位用户。下面的示例将一个名字列表传递给一个名为greet_users()的函数，这个函数问候列表中的每个人

def user_jieshou(names):
    for name in names:
        allname = "hello," + name.title()
        print(allname)

qwer = ('a','b','c')
user_jieshou(qwer)

在函数中修改列表

def print_models(unprinted_designs, completed_models): 
    """模拟打印每个设计，直到没有未打印的设计为止
    打印每个设计后，都将其移到列表completed_models中
    """ 
    while unprinted_designs:
        current_design = unprinted_designs.pop()
# 模拟根据设计制作3D打印模型的过程
        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)


#
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case

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

传递任意数量的实参

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

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

#形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。函数体内的print语句通过生成输出来证明Python能够处理使用一个值调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意，Python将实参封装到一个元组中，即便函数只收到一个值也如此
('pepperoni',) 
('mushrooms', 'green peppers', 'extra cheese')

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

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。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

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

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接受多少。一个这样的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。在下面的示例中，函数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-14 汽车：编写一个函数，将一辆汽车的信息存储在一个字典中。这个函数总是接受制造商和型号，还接受任意数量的关键字实参。这样调用这个函数：
# 提供必不可少的信息，以及两个名称—值对，如颜色和选装配件。这个函数必须能够像下面这样进行调用car = make_car('subaru', 'outback', color='blue', tow_package=True) 打印返回的字典，
# 确认正确地处理了所有的信息。

def car(zhizao,xinghao,**qita):
    cartest={}
    cartest['zhizao'] = zhizao
    cartest['xinghao'] = xinghao
    for key, value in qita.items():
        cartest[key] = value
    return cartest
qita = car('subaru', 'outback', color='blue', tow_package=True)
print(qita)

将函数存储在模块中

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

导入整个模块

要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。下面来创建一个包含函数make_pizza()的模块。为此，我们将文件pizza.py中除函数make_pizza()之外的其他代码都删除

#pisa.py
def make_pisa(size,*cailiao):
    print("\n 你的尺寸是" + str(size) + ",需要哪些材料：")
    for cailiaos in cailiao:
        print("- " + cailiaos)


#makepisa.py
import pisa

pisa.make_pisa(16, 'pepperoni')
pisa.make_pisa(12, 'mushrooms', 'green peppers', 'extra cheese')

如果你使用这种import语句导入了名为module_name.py的整个模块，就可使用下面的语法来使用其中任何一个函数：

module_name.function_name()

导入特定的函数

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

from module_name import function_name

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

from module_name import function_0, function_1, function_2

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

from pisa import make_pisa

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

使用as给函数指定别名

下面给函数make_pizza()指定了别名mp()。这是在import语句中使用make_pizza as mp实现的，关键字as将函数重命名为你提供的别名

例如：

from pisa import make_pisa  as ppp

# from module_name import function_name as fn

使用as给模块指定别名

你还可以给模块指定别名。

import pisa as ppp

ppp.pisi(16, 'pepperoni')
ppp.pisi(12, 'mushrooms', 'green peppers', 'extra cheese')

#import module_name as mn

导入模块中的所有函数

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

from pisa import *

# from module_name import *

函数编写指南

给形参指定默认值时，等号两边不要有空格:
def function_name(parameter_0, parameter_1='default value')
对于函数调用中的关键字实参，也应遵循这种约定:
function_name(value_0, parameter_1='value')