python入门——函数

函数

定义函数

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

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

用关键字def来告诉python要定义一个函数

在这里， 函数名为greet_user() ， 它不需要任何信息就能完成其工作， 因此括号是空的（即便如此， 括号也必不可少） 。 最后， 定义以冒号结尾。

紧跟在def greet_user(): 后面的所有缩进行构成了函数体。 ❷处的文本是被称为文档字符串 （docstring） 的注释， 描述了函数是做什么的。 文档字符串用三引号括起， Python使用它们来生成有关程序中函数的文档。

向函数传递信息

def greet_user(username):
    """显示简单的问候语"""
    print("hellow, "+username+" !")
greet_user('jesse')
#result
hellow, jesse !

实参和形参

前面定义函数greet_user() 时， 要求给变量username 指定一个值。 调用这个函数并提供这种信息（人名） 时， 它将打印相应的问候语。
在函数greet_user() 的定义中， 变量username 是一个形参 ——函数完成其工作所需的一项信息。 在代码greet_user(‘jesse’) 中， 值’jesse’ 是一个实参 。 实参是
调用函数时传递给函数的信息。 我们调用函数时， 将要让函数使用的信息放在括号内。 在greet_user(‘jesse’) 中， 将实参’jesse’ 传递给了函数greet_user() ， 这个
值被存储在形参username 中。
注意 大家有时候会形参、 实参不分， 因此如果你看到有人将函数定义,中的变量称为实参或将函数调用中的变量称为形参， 不要大惊小怪。

传递实参

鉴于函数定义中可能包含多个形参， 因此函数调用中也可能包含多个实参。 向函数传递实参的方式很多， 可使用位置实参 ， 这要求实参的顺序与形参的顺序相同；

也可使用关键字实参 ， 其中每个实参都由变量名和值组成； 还可使用列表和字典。 下面来依次介绍这些方式。

位置实参

def describe_pet(animal_type,per_name):
    """显示宠物的信息"""
    print("\nI have a "+animal_type +" .")
    print("My "+animal_type+"'s name is '"+pet_name.title()+".")
describe_pet('hamster','harry')

这个函数的定义表明， 它需要一种动物类型和一个名字（见❶） 。 调用describe_pet() 时， 需要按顺序提供一种动物类型和一个名字。 例如， 在前面的函数调用中， 实
参’hamster’ 存储在形参animal_type 中， 而实参’harry’ 存储在形参pet_name 中（见❷） 。 在函数体内， 使用了这两个形参来显示宠物的信息。

可以掉用函数多次

def describe_pet(animal_type,per_name):
    """显示宠物的信息"""
    print("\nI have a "+animal_type +" .")
    print("My "+animal_type+"'s name is '"+pet_name.title()+".")
describe_pet('hamster','harry')
descrive_pet('dog','wille')

关键字实参

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 = 'hasmer',pet_name = 'harry')
describe_pet(pet_name = 'harry',animal_type = 'hasmer')
#两个结果是一样的

看到这个函数调用时， Python知道应该将实参’hamster’
和’harry’ 分别存储在形参animal_type 和pet_name 中。 输出正确无误， 它指出我们有一只名为Harry的仓鼠。

默认值

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

def describe_pet(pet_name,animal_type = "dog")：
#默认宠物是狗
	"""显示宠物的信息"""
    print("\nI have a "+animal_type +"'s name is "+pet_name.title()+" .")
decribe_pet(per_name = 'whille')

请注意， 在这个函数的定义中， 修改了形参的排列顺序。 由于给animal_type 指定了默认值， 无需通过实参来指定动物类型， 因此在函数调用中只包含一个实参——宠物的名字。 然而， Python依然将这个实参视为位置实参， 因此如果函数调用中只包含宠物的名字， 这个实参将关联到函数定义中的第一个形参。 这就是需要将pet_name 放在形参列表
开头的原因所在。
现在， 使用这个函数的最简单的方式是， 在函数调用中只提供小狗的名字：

如果把animal_type = 'dog’放再前面，则会输出

non-default argument follows default argument

等效的函数调用

基于这种定义， 在任何情况下都必须给pet_name 提供实参； 指定该实参时可以使用位置方式， 也可以使用关键字方式。 如果要描述的动物不是小狗， 还必须在函数调用中
给**animal_type 提供实参； **同样， 指定该实参时可以使用位置方式， 也可以使用关键字方式。

返回值

返回简单值

def get_formatted_name(first_name,last_name):
    """返回简洁的名字"""
    full_name = first_name +' ' + last_name
    return full_name.title()
musician = get_formated_name('jimi','hendrix')
print(musician)

调用返回值的函数时， 需要提供一个变量， 用于存储返回的值。 在这里， 将返回值存储在了变量musician 中（见❹） 。 输出为整洁的姓名：

让实参变成可选的

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

例如， 假设我们要扩展函数get_formatted_name() ， 使其还处理中间名。 为此， 可将其修改成类似于下面这样：

def get_formatted_name(first_name, middle_name, last_name):
"""返回整洁的姓名"""
full_name = first_name + ' ' + middle_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('john', 'lee', 'hooker')
print(musician)

只要同时提供名、 中间名和姓， 这个函数就能正确地运行。 它根据这三部分创建一个字符串， 在适当的地方加上空格， 并将结果转换为首字母大写格式：

John Lee Hooker

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

def get_formated_name(first_name,final_name,middle_name = ''):
    """返回整洁的名字"""
    if middle_name:
        full_name = first_name + ' ' + middle_name + ' ' + final_name
    else:
        full_name = first_name + " " + final_name
    return full_name.title()
musician = get_formated_name('jimi','herdrix')
print(musician)
musician = get_formated_name("john",'hooker','lee')
print(musician)

返回字典

函数可返回任何类型的值， 包括列表和字典等较复杂的数据结构。 例如， 下面的函数接受姓名的组成部分， 并返回一个表示人的字典：

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

函数build_person() 接受名和姓， 并将这些值封装到字典中（见❶） 。 存储first_name 的值时， 使用的键为’first’ ， 而存储last_name 的值时， 使用的键为’last’ 。 最后， 返回表示人的整个字典（见❷） 。 在❸处， 打印这个返回的值， 此时原来的两项文本信息存储在一个字典中：

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

这个函数接受简单的文本信息， 将其放在一个更合适的数据结构中， 让你不仅能打印这些信息， 还能以其他方式处理它们。 当前， 字符串’jimi’ 和’hendrix’ 被标记为名和
姓。 你可以轻松地扩展这个函数， 使其接受可选值， 如中间名、 年龄、 职业或你要存储的其他任何信息。 例如， 下面的修改让你还能存储年龄：

def build_person(first_name, last_name, age=''):
	"""返回一个字典， 其中包含有关一个人的信息"""
    person = {'first': first_name, 'last': last_name}
	if age:			#如果age有输入的话
		person['age'] = age
        #加键是可以直接在外面定义的
		return person
musician = build_person('jimi', 'hendrix', age=27)
print(musician)

结合使用函数和while循环

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:")
    f_name = input("First name: ")
    l_name = input("Last name: ")
formatted_name = get_formatted_name(f_name, l_name)
print("\nHello, " + formatted_name + "!")

但这个while 循环存在一个问题： 没有定义退出条件。 请用户提供一系列输入时， 该在什么地方提供退出条件呢？ 我们要让用户能够尽可能容易地退出， 因此每次提示用户输入
时， 都应提供退出途径。 每次提示用户输入时， 都使用break 语句提供了退出循环的简单途径：

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 + "!")

传递列表

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

假设有一个用户列表， 我们要问候其中的每位用户。 下面的示例将一个名字列表传递给一个名为greet_users() 的函数， 这个函数问候列表中的每个人：

def greet_users(names):
    """向列表中的每位用户都发出简单的问候"""
    for name in names:
        msg = "Hellow, " + name.title() + " !"
        print(msg)
username = ['hannah','ty','margot']
greet_users(usernames)

输出完全符合预期， 每位用户都看到了一条个性化的问候语。 每当你要问候一组用户时， 都可调用这个函数。

在函数修改列表

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

来看一家为用户提交的设计制作3D打印模型的公司。 需要打印的设计存储在一个列表中， 打印后移到另一个列表中。 下面是在不使用函数的情况下模拟这个过程的代码：

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

这个程序首先创建一个需要打印的设计列表， 还创建一个名为completed_models 的空列表， 每个设计打印都将移到这个列表中。 只要列表unprinted_designs 中还有设计， while 循环就模拟打印设计的过程： 从该列表末尾删除一个设计， 将其存储到变量current_design 中， 并显示一条消息， 指出正在打印当前的设计， 再将该设计加入到列表completed_models 中。 循环结束后， 显示已打印的所有设计：

Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone caseThe following models have been printed:
dodecahedron
robot pendant
iphone case

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

def print_models(unprinted_designs,completed_models):
    """
    模拟打印每个设计，直到没有未打印的设计为止
    打印每个设计后，都将其移到列表completed_models中
    """
    while unpaired_desings:
        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 = ['ipone case','robot pendant','dodecahedron']
completed_models = []
#对列表赋值
print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)

在❶处， 我们定义了函数print_models() ， 它包含两个形参： 一个需要打印的设计列表和一个打印好的模型列表。 给定这两个列表， 这个函数模拟打印每个设计的过程： 将设计逐个地从未打印的设计列表中取出， 并加入到打印好的模型列表中。 在❷处， 我们定义了函数show_completed_models() ， 它包含一个形参： 打印好的模型列表。 给定这个列表， 函数show_completed_models() 显示打印出来的每个模型的名称。

这个程序的输出与未使用函数的版本相同， 但组织更为有序。 完成大部分工作的代码都移到了两个函数中， 让主程序更容易理解。 只要看看主程序， 你就知道这个程序的功能容易看清得多：

#主功能程序
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)

禁止 函数修改列表

有时候， 需要禁止函数修改列表。 例如， 假设像前一个示例那样， 你有一个未打印的设计列表， 并编写了一个将这些设计移到打印好的模型列表中的函数。 你可能会做出这样的决定： 即便打印所有设计后， 也要保留原来的未打印的设计列表， 以供备案。 但由于你将所有的设计都移出了unprinted_designs ， 这个列表变成了空的， 原来的列表没有了。 为解决这个问题， 可向函数传递列表的副本而不是原件； 这样函数所做的任何修改都只影响副本， 而丝毫不影响原件。

要将列表的副本传递给函数， 可以像下面这样做：

function_name(list_name[:])

切片表示法[:] 创建列表的副本。 在print_models.py中， 如果不想清空未打印的设计列表， 可像下面这样调用print_models() ：

print_models(unprinted_designs[:], completed_models)

这样函数print_models() 依然能够完成其工作， 因为它获得了所有未打印的设计的名称， 但它使用的是列表unprinted_designs 的副本， 而不是列
表unprinted_designs 本身。 像以前一样， 列表completed_models 也将包含打印好的模型的名称， 但函数所做的修改不会影响到列表unprinted_designs 。
虽然向函数传递列表的副本可保留原始列表的内容， 但除非有充分的理由需要传递副本， 否则还是应该将原始列表传递给函数， 因为让函数使用现成列表可避免花时间和内存创
建副本， 从而提高效率， 在处理大型列表时尤其如此。

传递任意数量的实参

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

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

现在， 我们可以将这条print 语句替换为一个循环， 对配料列表进行遍历， 并对顾客点的比萨进行描述：

def make_pizza(*toppings):
    """概述要制作的比萨"""
    print("\nMaking a pizza with the following toppings:")
    for topping in toppings:
		print("- " + topping)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

不管收到的是一个值还是三个值， 这个函数都能妥善地处理：

Making a pizza with the following toppings:
- pepperoni
Making a pizza with the following toppings:
- 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')

基于上述函数定义， Python将收到的第一个值存储在形参size 中， 并将其他的所有值都存储在元组toppings 中。 在函数调用中， 首先指定表示比萨尺寸的实参， 然后根据需要指定任意数量的配料。
现在， 每个比萨都有了尺寸和一系列配料， 这些信息按正确的顺序打印出来了——首先是尺寸， 然后是配料：

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
        #这个操作等于把收到的值键对收录在user_info这个字典
    return profile
user_profile = build_profile('albert','einstein',location = 'princeton',field = 'physics')
print(user_profile)

函数build_profile() 的定义要求提供名和姓， 同时允许用户根据需要提供任意数量的名称—值对。 形参**user_info 中的两个星号让Python创建一个名为user_info 的空字典，并将收到的所有名称—值对都封装到这个字典中。

在这个函数中， 可以像访问其他字典那样访问user_info 中的名称—值对。

在build_profile() 的函数体内， 我们创建了一个名为profile 的空字典， 用于存储用户简介。 在❶处， 我们将名和姓加入到这个字典中， 因为我们总是会从用户那里收到这两项信息。 在❷处， 我们遍历字典user_info 中的键—值对， 并将每个键—值对都加入到字典profile 中。 最后， 我们**将字典profile 返回给函数调用行。 **

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

把函数存储在模块

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

导入整个模块

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

def make_pizza(size,*toppings):
    """概述要制作的比萨"""
    print("\nMaking a " + str(size) + "-inch pizza with following toppings:")
    for topping in toppings:
        print("- " + topping)

接下来， 我们在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件， 这个文件导入刚创建的模块， 再调用make_pizza() 两次：

import pizza					#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中定义的所有函数。

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

Making a 16-inch pizza with the following toppings:
- pepperoniMaking a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

导入特定的函数

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

ps:这种情况通常用于一个文件有多个函数

from module_name import function_name 

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

对于前面的making_pizzas.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 实现的， 关键字as 将函数重命名为你提供的别名：

from pizza import make_pizza as mp
mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

上面的import语句将函数make_pizza() 重命名为mp() ； 在这个程序中， 每当需要调用make_pizza() 时， 都可简写成mp() ， 而Python将运行make_pizza() 中的代码， 这可避免与这个程序可能包含的函数make_pizza() 混淆。

指定别名的通用语法如下：

from module_name import function_name as fn

使用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')

上述import 语句给模块pizza 指定了别名p ， 但该模块中所有函数的名称都没变。 调用函数make_pizza() 时， 可编写代码p.make_pizza() 而不
是pizza.make_pizza() ， 这样不仅能使代码更简洁， 还可以让你不再关注模块名， 而专注于描述性的函数名。 这些函数名明确地指出了函数的功能， 对理解代码而言， 它们
比模块名更重要。
给模块指定别名的通用语法如下：

import module_name as mn

导入模块中的所有函数

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

form pizza import *
make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green peppers', 'extra cheese')

import 语句中的星号让Python将模块pizza 中的每个函数都复制到这个程序文件中。 由于导入了每个函数， 可通过名称来调用每个函数， 而无需使用句点表示法。 然而， 使用
并非自己编写的大型模块时， 最好不要采用这种导入方法： 如果模块中有函数的名称与你的项目中使用的名称相同， 可能导致意想不到的结果： Python可能遇到多个名称相同的函
数或变量， 进而覆盖函数， 而不是分别导入所有的函数。
最佳的做法是， 要么只导入你需要使用的函数， 要么导入整个模块并使用句点表示法。 这能让代码更清晰， 更容易阅读和理解。 这里之所以介绍这种导入方法， 只是想让你在阅
读别人编写的代码时， 如果遇到类似于下面的import 语句， 能够理解它们：

from module_name import *