python 函数

函数是带名字的代码块，用于完成具体的工作。
要执行函数定义的特定任务，可以调用该函数。

定义函数

关键字def为函数定义，后面为函数名，在括号内指出函数为完成其任务需要什么样的信息，定义以冒号为结尾。
所有缩进的部分为函数体。

def greet_user():
    """显示简单的问候语"""
    print("Hello")
    
if __name__ == "__main__":
    greet_user()

像函数传递信息

def greet_user(name):
    """显示简单的问候语"""
    print("Hello" + name.title())
    
if __name__ == "__main__":
    greet_user('judi')

实参和形参

实参：调用函数时传递给函数的信息（上面代码中主函数里面的‘judi’）
形参：函数完成其工作所需要的一项信息。 (上面代码中的username)

传递参数

位置实参

位置实参要求实参的顺序和形参的顺序相同，python必须将函数调用中的每个实参都关联到函数定义的第一个形参。
可以根据需要调用函数任意次。
在位置实参里面，实参的位置不能颠倒。

def describe_pet(animal_type, pet_name):
    #显示宠物信息
    print("\nI have a " + animal_type + " .")
    print("My " + animal_type + "'s name is " + pet_name + " .")
    
if __name__ == "__main__":
    describe_pet('dog', 'xiaobai')

关键字实参

关键字实参是传递给函数的名称-值对。
关键字实参无需考虑 顺序，还能清楚地指出函数调用中各个值的用途。

def describe_pet(animal_type, pet_name):
    #显示宠物信息
    print("\nI have a " + animal_type + " .")
    print("My " + animal_type + "'s name is " + pet_name + " .")
    
if __name__ == "__main__":
    describe_pet(animal_type = 'dog', pet_name = 'xiaobai')
    describe_pet( pet_name = 'xiaobai', animal_type = 'dog')

可以发现上面两个调用函数实参位置变了但结果不会变

默认值

编写函数是，可给每个形参指定默认值。当调用函数中提供了实参将使用指定的实参，否则使用形参的默认值。
在使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。这让python依然能够正确解读位置实参。
给形参指定默认值时，等号两边不能有空格。
在函数调用中的关键字实参也应遵循此规则。

def describe_pet(pet_name, animal_type = 'dog'):
    #显示宠物信息
    print("\nI have a " + animal_type + " .")
    print("My " + animal_type + "'s name is " + pet_name + " .")
    
if __name__ == "__main__":
    describe_pet('xiaobai')
    describe_pet( pet_name = 'xiaobai')
    describe_pet('xiaobai', 'cat')
    describe_pet( pet_name = 'xiaobai', animal_type = 'cat')
    describe_pet( animal_type = 'dog', pet_name = 'xiaobai', )
    describe_pet( pet_name = 'xiaobai', animal_type = 'dog')

等效函数调用

上面6种调用函数的方式都可以得到正确答案——等效函数调用

返回值

函数并非总是直接显示输出，它可以处理一些数据返回一个或一组值。

返回简单值

def get_formatted_name(first_name, last_name):
    """返回完整的名字"""
    full_name = first_name + ' ' + last_name
    return full_name
    
if __name__ == "__main__":
    full_name = get_formatted_name('ma', 'meng')
    print(full_name.title())

让实参变成可选的

如有的人是两个字，有的人名字是三个字的时候应该怎么存储?

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
    
if __name__ == "__main__":
    full_name = get_formatted_name('ma', 'meng')
    print(full_name.title())
    full_name = get_formatted_name('ma', 'meng', 'xiao')
    print(full_name.title())

返回字典

def build_person(fisrt_name, last_name):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'first':fisrt_name, 'last':last_name}
    return(person)
if __name__ == "__main__":
    ren = build_person(fisrt_name='ma', last_name='xiao')
    print(ren)

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

def build_person(fisrt_name, last_name, age=''):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'first':fisrt_name, 'last':last_name}
    if age:
        person['age'] = age  #字典添加键值对的方式
    return(person)
if __name__ == "__main__":
    ren = build_person(fisrt_name='ma', last_name='xiao', age=12)
    print(ren)

结合使用函数和while循环

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
if __name__ == "__main__":
    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
        full_name = get_formatted_name(f_name, l_name)
        print (full_name)

传递列表

def greet_users(names):
    for name in names:
        print("Hello " + name + " !")
    
    
if __name__ == '__main__':
    names = ['zhangsan', 'lisi', 'wangwu']
    greet_users(names)

在函数中修改列表

将列表传递给函数后，函数就可以对其修改。在函数中对此列表所做的任何修改都是永久性的。

#打印列表
def print_models(unprinted_list, printed_list):
    while unprinted_list:
        printing = unprinted_list.pop()
        print("正在打印" + printing + "中")
        printed_list.append(printing)
        
def show_printed_list(printed_list):  
    for printed in printed_list:
        print(printed)
    
    
    
if __name__ == '__main__':
    unprinted_list = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'fengqi']
    printed_list = []
    print_models(unprinted_list, printed_list)
    show_printed_list(printed_list)

禁止函数修改列表

切片表示法[:]创建列表的副本。如果不想清空未打印的设计列表，可这样调用print_models

print_models(unprinted_list[:], printed_list)

例如：

#打印列表
def print_models(unprinted_list, printed_list):
    while unprinted_list:
        printing = unprinted_list.pop()
        print("正在打印" + printing + "中")
        printed_list.append(printing)
        
def show_printed_list(printed_list):  
    for printed in printed_list:
        print(printed)
    
    
    
if __name__ == '__main__':
    unprinted_list = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'fengqi']
    printed_list = []
    print_models(unprinted_list[:], printed_list)
    show_printed_list(printed_list)

传递任意数量的实参

在预先不知道函数需要接受多少实参的时候，python允许函数从调用语句中收集任意数量的实参。
形参*toppings中的*让python创建一个名为toppings的空元组，并将所有值都封装在这个元组中。

def make_pizza(*topping):
    
    print(topping)
    
if __name__ == "__main__":
    make_pizza('mianbaopian', 'tomato')
    make_pizza('mianbaopian', 'tomato', 'pingguo', 'xiangjiao')

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

def make_pizza(size, *topping):
    
    print("Making a " + str(size) + "-inch pizza:")
    print(topping)
    
if __name__ == "__main__":
    make_pizza(12, 'mianbaopian', 'tomato')
    make_pizza(18, 'mianbaopian', 'tomato', 'pingguo', 'xiangjiao')

让函数接受不同类型的实参，需要在函数定义中将接纳任意数量实参的形参放在最后。

使用任意数量的关键字实参（键-值对）

需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息时，可将函数编写成能够接受任意数量的键-值对。
形参**user_info中两个星号让python创建一个名为user_info的空字典。

def build_profile(first, last, **user_info):
    #创建一个字典，其中包括用户的一切
    profile ={}
    profile['first'] = first
    profile['last'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile
    
    
if __name__ == "__main__":
    user_profile = build_profile('zhang', 'sam',
                                location = 'beijing', field = 'complete')
    print(user_profile)

将函数存储在模块中

函数的优点之一：使用它们可将代码块与主程序分离。
将函数存储在被称为模块的独立文件中
import语句允许在当前运行的程序文件中使用模块中的代码。

导入整个模块

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

module_name.function_name()

同样的代码，放在模块中这样运行：
pizza.py文件

def make_pizza(size, *topping):
    print("Making a " + str(size) + "-inch pizza:")
    print(topping)

main.py文件

import pizza
if __name__ == "__main__":
    pizza.make_pizza(12, 'mianbaopian', 'tomato')
    pizza.make_pizza(18, 'mianbaopian', 'tomato', 'pingguo', 'xiangjiao')

导入特定的函数

也可以导入模块中特定的函数，导入方法的语法如下：

from module_name import fuction_name

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

from module_name import fuction_0, fuction_1, fuction_2

直接导入函数时，调用函数无需使用句点。

pizza.py文件中内容不变，main.py文件中内容如下，最终结果仍然不变。

from pizza import make_pizza
if __name__ == "__main__":
    make_pizza(12, 'mianbaopian', 'tomato')
    make_pizza(18, 'mianbaopian', 'tomato', 'pingguo', 'xiangjiao')

使用as给函数指定别名

如果要导入的函数名称可能与程序中现有的名称冲突，或者函数名太长，可指定简短而独一无二的别名——函数的另一个名称
关键词as将函数重命名为代码提供别名
指定别名的通用语法：

from module_name import function_name as fn

pizza.py文件中内容不变，main.py文件中内容如下，最终结果仍然不变。

from pizza import make_pizza as mp
if __name__ == "__main__":
    mp(12, 'mianbaopian', 'tomato')
    mp(18, 'mianbaopian', 'tomato', 'pingguo', 'xiangjiao')

使用as给模块指定别名

和函数类似，给模块指定别名的通用语法如下：

import module_name as mn

pizza.py文件中内容不变，main.py文件中内容如下，最终结果仍然不变。

import pizza as pz
if __name__ == "__main__":
    pz.make_pizza(12, 'mianbaopian', 'tomato')
    pz.make_pizza(18, 'mianbaopian', 'tomato', 'pingguo', 'xiangjiao')

导入模块中所有函数

使用星号*运算符可让python导入模块中所有函数，并在调用时可直接只用函数名称调用，不需要句点。
导入模块中所有函数的通用语法如下：

from module_name import *

函数编写指南

给形参指定默认值时，等号两边不能有空格；

def function_name(parameter_0, parameter_1='default value')

对于函数调用中的关键词实参，也应遵循这种约定：

function_name(value_0, parameter_1='value')