[python笔记]7.函数

一.定义函数

1）def

使用关键字def定义函数，后面跟函数名，括号中为参数，以冒号结尾，后面的缩进行为函数体，
eg：

def greeter_user():
    print("hello world")
greeter_user()

输出：

hello world

二.给函数传递参数

1）位置实参

eg1：

def great_user(user_name):
    '''显示其简单的问候语'''
    print("Hello, " + user_name.title() + "!")
great_user('jesse')

输出：

Hello, Jesse!

其中user_name作为形式参数，jesse作为实际参数传给great_user函数保存在user_name中
eg2：

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')
describe_pet('dog', 'willie')

输出

I have a hamster.
My hamster's name is Harry.

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

2）关键字实参

将形式参数与实际参数的内容绑定，形成名称-值对，则此时传递实参的顺序就无关紧要了，下面程序段两端输出相同结果
eg：

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(pet_name = 'harry', animal_type = 'hamster')

输出：

I have a hamster.
My hamster's name is Harry.

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

3）默认值

编写函数时，可以给每个形参指定默认值，在调用函数中给形参提供了实参时，将使用指定的实参值，否则，将使用形参的默认值，指定默认值后，在调用的过程中可以简化调用
在定义函数时有默认值的形参需要放在没有默认值的形参后面
给形参指定默认值，等号两边不要有空格
eg1:

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

输出：

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

如果将有默认值的形参放在没有默认值的前面，会出现错误、

扫描二维码关注公众号，回复： 9002544 查看本文章

eg2：

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

输出

SyntaxError: non-default argument follows default argument

原因在于由于给animal_name指定了默认值，无需通过实参来指定动物类型，因此在函数调用中只跑含一个实参即宠物的名字，然而python依然将这个实参视为位置实参，因此如果值包含宠物的名字，这个实参视为位置实参，关联到第一个形参。

如果需要描述其他的动物，则需要手动给参数赋值
eg:

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 = 'willie', animal_type = 'hamster')

输出：

My hamster's name is Willie.

三.返回值

1）返回简单值

函数返回一个值或是一组值，函数返回的值称为返回值，在函数中，可以使用return语句返回调用函数的代码行。
eg:

def get_formatted(first_name, last_name):
    full_name = first_name + " " + last_name
    return full_name.title()
musician = get_formatted('jimi', 'hendrix')
print(musician)

函数将full_name的首字母大写返回，调用时保存在musician中
输出：

Jimi Hendrix

2）可选实参

使用默认值让实参变为可选的，使用函数的人只需要在必要时提供额外的信息
eg:

def get_formatted(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
musician = get_formatted('jimi', 'hendrix')
print(musician)
musician = get_formatted('join', 'hooker', 'lee')
print(musician)

middle_name默认为空字符串，在使用时才手动传参数。
如果使用位置参数，要使用middle_name，就必须保证它是最后一个实参

3）返回字典

eg:

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}

4）函数与while循环

def get_formatted(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 qiut)")
    f_name = input("First Name: ")
    if f_name == 'q':
        break
    l_name = input("Last Name: ")
    if l_name == 'q':
        break
    formatted_name = get_formatted(f_name, l_name)
    print("\nHello " + formatted_name + "!")

输出

Please tell me your name:
(enter 'q' at any time to qiut)
First Name: eric
Last Name: matthes

Hello Eric Matthes!

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

四.传递列表

eg

def greet_users(names):
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)
usernames = ['hannah', 'try', 'margot']
greet_users(usernames)

输出

Hello, Hannah!
Hello, Try!
Hello, Margot!

1）在函数中修改列表

将列表传递给函数后，函数就可以进行修改，在函数中对列表所作的任何修改都是永久性的
eg1：

unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
while unprinted_designs:
    current_design = unprinted_designs.pop()
    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: robot pendant
Printing model: iphone case

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

对该列表修改的例子可以重新组织，定义两个函数，分别为处理函数和显示函数，每个函数都应该只负责一项具体工作。便于阅读与维护
eg2：

def print_models(unprinted_designs, completed_models):
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print("Printing model: " + current_design)
        completed_models.append(current_design)
def show_completed(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(completed_models)

输出：

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

The following models have been printed
dodecahedron
robot pendant
iphone case

2）禁止函数修改列表

在上一个例子中，执行结束后unprinted_designs全部移植到completed_models中，此时列表unprinted_designs为空，如果需要保存unprinted_designs的初始状态，则可以向函数传递参数时不传递原件而是副本function_name(list_name[:])
即采用切片表示法传递副本
这种效率会降低，因为要花时间保留副本，所以除非有充分的理由需要传递副本，否则还是应该将原始列表传递给函数
eg:

def print_models(unprinted_designs, completed_models):
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print("Printing model: " + current_design)
        completed_models.append(current_design)
def show_completed(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(completed_models)
print(unprinted_designs)

输出：

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

The following models have been printed
dodecahedron
robot pendant
iphone case
['iphone case', 'robot pendant', 'dodecahedron']

五.传递任意数量的实参

eg：

def make_pizza(*toppings):
    print("\nMaking a pizza with the following toppings: ")
    for topping in toppings:
        print("- " + topping)
make_pizza('pepperoin')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

输出

Making a pizza with the following toppings:
- pepperoin

Making a pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

*toppings可以创建一个名为toppings的空元组，并将接收到的所有值（不论多少）装入这个元组之中

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

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

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

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

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

eg1：

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_pofile('albert', 'einstein', location='princetin', filed='physics')
print(user_profile)

本例中build_profile()的定义要求提供名和姓，同时需要用户根据需要提供任意数量的名称-值对。形参**user_info中的两个星号让python创建一个名为user_info的空字典，并将收到的所有名称-值对都封装到这个字典中，在这个函数中，可以像访问其他字典那样访问user_info中的名称-值对。
调用这个函数，不管额外提供了多少键-值对，它都能够正确处理。
输出：

{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princetin', 'filed': 'physics'} 

传递任意个参数用 * 代表创建一个元组
传递任意个参数用 ** 代表创建一个字典

eg2:

def make_car(car_name, car_type,**car_info):
    car = {}
    car['name'] = car_name
    car['type'] = car_type
    for key, value in car_info.items():
        car[key] = value
    return car
car1 = make_car('subaru', 'outback', color='blue', two_package=True)
print(car1)

输出

{'name': 'subaru', 'type': 'outback', 'color': 'blue', 'two_package': True}

六.将函数存储在模块中

使用函数可以将代码块与主程序分离。通过给函数指定描述性名称，让主程序更容易理解。进一步将函数存储在称为模块的独立文件中，再将模块导入主程序中。使用import语句允许当前运行的程序文件中使用模块中的代码
(类似C++中#include<>)

1）导入整个模块

首先要创建模块，模块是拓展名为.py的文件，包含要导入程序中的代码

module_name.function_name()

要调用被导入模块中的函数，可指定导入的模块的名称pizza和函数名make_pizza()，并用句点分割他们，这些代码的输出与没有导入模块的原始程序相同

eg1:

#pizza.py
def make_pizza(size, *toppings):
    print("\nMaking a " + str(size) + 
        "-inch pizza with the following toppings: ")
    for topping in toppings:
        print("- "+topping)       

#making_pizza.py
import pizza
pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(16, 'mushroom', 'green peppers', 'extra cheese')

输出

Making a 16-inch pizza with the following toppings:       
- pepperoni

Making a 16-inch pizza with the following toppings:       
- mushroom
- green peppers
- extra cheese

Python读取这个文件时。通过代码行import pizza让Python打开文件pizza.py，并将其所有的函数都复制到这个程序中去，复制过程在后台进行，所以在making_pizza.py中可以使用pizza.py中的所有函数

2）导入特定的函数

即从模块中导入任意数量的函数

from module_name import function0, function1, function2

eg：

#making_pizza.py
from pizza import make_pizza
make_pizza(16, 'pepperoni')
make_pizza(16, 'mushroom', 'green peppers', 'extra cheese')

输出
这里在import中显示的导入make_pizza()，因此调用它时只需指定其名称

3）使用as给函数指定别名

在2）的例子中 引入了pizza.py中的make_pizza()函数，则在现有的程序中就不能存在名为make_pizza()的函数，否则会产生冲突，此时就需要将引入的函数设置一个别名
eg:

#making_pizza.py
from pizza import make_pizza as mp
def make_pizza():
    print("hello world")
mp(16, 'pepperoni')
mp(16, 'mushroom', 'green peppers', 'extra cheese')
make_pizza()

输出

Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 16-inch pizza with the following toppings:
- mushroom
- green peppers
- extra cheese
hello world

这里将引入的make_pizza()声明为别名mp，这样就不会与程序本身的make_pizza()产生冲突
如果不声明
eg:

#making_pizza.py
from pizza import make_pizza
def make_pizza():
    print("hello world")
make_pizza(16, 'pepperoni')
make_pizza(16, 'mushroom', 'green peppers', 'extra cheese')
make_pizza()

输出：

make_pizza(16, 'pepperoni')
TypeError: make_pizza() takes 0 positional arguments but 2 were given
#产生冲突 

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

操作同上 import moudle_name as mn
eg：

#making_pizza.py
import pizza as p
p.make_pizza(16, 'pepperoni')
p.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

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

使用*运算符可让python导入所有模块中的函数

from moudle_name import * 

eg：

#making_pizza.py
from pizza import *
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

容易产生冲突，尽量不要用，道理同3）