mg4377娱乐娱城官网_mg4377娱乐手机版_www.mg4377.com

函数函数名称函数函数函数名称

时间:2019-09-22 13:33来源:mg4377娱乐手机版
首先,函数的概念是实现一定任务的独立程序代码单元。 函数函数名称函数函数函数名称 I've recently started maintaining someone else's JavaScript code. I'mfixing bugs, adding features, and also trying to tid

首先,函数的概念是实现一定任务的独立程序代码单元。

函数函数名称函数函数函数名称
I've recently started maintaining someone else's JavaScript code. I'm fixing bugs, adding features, and also trying to tidy up the code and make it more consistent.

第 8 章 函数,函数

  在本章中,大家将学习编写函数。函数是带名字的代码块,用于达成具体的做事。

    要实行函数定义的特定任务,可调用函数。须要在先后中一再进行同样项职分时,大家无需每每编写成功该职务的代码,而只需调用实践该任务的函数,让Python运维在那之中的代码。大家将发掘,通过采取函数,程序的编撰、阅读、测量试验和修复都将更易于。

    在本章中,大家还有大概会学习向函数字传送递音讯的形式。我们将学习怎么样编写主要职务是显示信息的函数,还只怕有用于管理多少并回到二个或一组值的函数。最后,我们将学习怎么样将函数存款和储蓄在被称为模块函数函数名称函数函数函数名称。的单身文件中,让主程序文件的组织更加的有序。

8.1  定义函数

    上边是四个打字与印刷问候语的简易函数,名叫greet_user():

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

greet_user()
    这个示例演示了最简单的函数结构。代码行使用关键字def来告诉Python我们要定义一个函数。这是函数定义,向Python指出了函数名,还可能在括号
内指出函数为完成其任务需要什么样的消息。在这里,函数名为greet_user(),它不需要任何信息就能完成其工作,因此括号是空的(即便如此,括号也必不可
少)。最后,定义以冒号结尾。
    紧跟在def greet_user():后面的所有缩进构成了函数体。上述的文本是被称为文档字符串(docstring)的注释,描述了函数是做什么的。文档字符串用三
引号扩起,Python使用它们来生成有关程序中函数的文档。
    print("Hello!")是函数体内的唯一一行代码,greet_user()只做一项工作;打印Hello!。

8.1.1  向函数体传递信息

    只要稍作修改,就可以让函数greet_user()不仅向用户显示Hello!,还将用户的名字用作抬头。为此,可在函数定义def greet_user()的括号内添加
username。通过在这里添加username,就可让函数接受我们给username制定的任何值。现在,这个函数要求我们滴啊用它给username指定一个值。调用greet
_user()时,可将一个名字传递给它,如下所示:

#定义一个函数带一个参数
def greet_user(username):
    """显示简单的问候语"""
    print("Hello, "   username   ".")

greet_user("Zengmingzhu")
    代码greet_user("Zengmingzhu")调用函数greet_user(),并向它提供执行print语句所需的信息。这个函数接受我们传递给它的名字,并向这个人发出
问候:
Hello, Zengmingzhu.
    同样,greet_user('sarah')调用函数greet_user()并向它传递'sarah',打印Hello,Sarah!.我们可以根据需要调用函数greet_user()任意次,调用时
无论传入什么样的名字,都会生成相应的输出。

8.1.2  实参和形参

    前面定义函数greet_user()时,要求给变量username指定一个值。调用这个函数并提供这种信息(人名)时,它将打印相应的问候语。
    在函数greet_user()的定义中,变量username是一个形参——函数完成其工作所需的一项信息。在代码greet_user('jesse')中,值'jesse'是一个实参
。实参是调用函数时传递给函数的信息。我们调用函数时,将要让函数使用的信息放在括号内。在greet_user('jesse')中,将实参'jesse'传递给了函数
greet_user(),这个值被存储在形参username中。

8.2  传递实参

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

8.2.1  位置实参
    我们调用函数时,Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此,最简单的关联方式是基于实参的顺序。这种关联方式
被称为位置实参。
    为明白其中的工作原理,来看一个显示宠物信息的函数。

#首先定义一个函数,然后调用这个函数
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()时,需要按顺序提供一种动物类型和一个名字。例如,在前面的函数调用中
,实参'hamster'存储在形参animal_type中,而实参'harry'存储在形参pet_name中。在函数体内,使用了这两个形参来显示宠物的信息。
    输出描述了一只名为Harry的仓鼠:
  I have a hamster.
  My hamster's name is Harry.
    1、调用函数多次
    我们可以根据需要调用函数任意次。要再描述一个宠物,只需再次调用describe_pet()即可:

#首先定义一个函数,然后调用这个函数
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")
    第二次调用describe_pet()函数时,我们向它传递了实参'dog'和'willie'。与第一次调用时一样,Python将实参'dog'关联到形参animal_type,并将
实参'willie'关联到形参pet_name。与前面一样,这个函数完成其任务,但打印的是一条名为Willie的小狗的信息。至此,我们有一只名为Harry的仓鼠,还
有一只名为Willie的小狗:
I have a hamster.
My hamster's name is Harry.

I have a dog.
My dog's name is Willie.
    调用函数多次是一种效率极高的工作方式。我们只需在函数中编写描述宠物的代码一次,然后每当需要描述新宠物时,都可调用这个函数,并向它提供新
宠物的信息。即便描述宠物的代码增加到了10行,我们依然只需使用一行调用函数的代码,就可描述一个新宠物。
    在函数中,可根据需要使用任意数量的位置实参,Python将按顺序将函数调用中的实参关联到函数定义中相应的形参。

2. 位置实参的顺序很重要
    使用位置实参来调动函数时,如果实参的顺序不正确,结果可能出乎意料:

#首先定义一个函数,然后调用这个函数
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('harry','hamster')

    在这个函数调用中,我们先制定名字,再指定动物类型。由于实参'harry'在前,这个值将存储到animal_type中;同理,'hamster'将存储到形参pet_nam
中。结果是我们得到了一个名为Hamster和Harry:
I have a harry.
My harry's name is Hamster.
    如果结果像上面一样搞笑,请确认函数调用中实参的顺序与函数定义中形参的顺序一致。

8.2.2  关键字实参

    关键字实参是传递给函数的名称-值对。我们直接在实参中将名称和值关联起来了,因此向函数传递实参时不会混淆(不会得到名为Hamster的Harry这样
的结果).关键字实参让我们无须考虑函数调用中的实参顺序,还清楚地指出了函数调用中的各个值的用途。
    下面来看重新编写pets.py,在其中使用关键字实参来调用describe_pet():

#定义一个函数,用户存储宠物的名字和类别
def describe_pets(animal_type,pet_name):
    print("nI have a "   animal_type.title()   ".")
    print("My pet "   animal_type.title()   "'s name is "   pet_name.title()  ".")

describe_pets(pet_name = 'harry',animal_type = 'hamster')
    函数describe_pet()还是原来那样,但调用这个函数时,我们向Python明确地指出了各个实参对应的形参。看到这个函数调用时,Python知道应将实参
'hamster'和'harry'分别存储在形参animal_type和pet_name中。输出正确无误,它指出我们有一只名为Harry的仓鼠。

8.2.3  默认值

    编写函数时,可给每个形参指定默认值。在调用函数中给形参提供了实参时,Python将使用制定的实参值;否则,将使用形参的默认值。因此,给形参指定
默认值后,可在函数调用中省略相应的实参。使用默认值可简化函数调用,还可清楚地指出函数的典型用法。
    例如,如果我们发现调用describe_pet()时,描述的大都是小狗,就可将形参animal_type的默认值设置为'dog'。这样,调用describe_pet()来描述小
狗时,就可不提供这种信息:

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

describe_pet("Harry")
    这里修改了函数describe_pet()的定义,在其中给形参animal_type制定了默认值'dog'.这样,调用这个函数时,如果没有给animal_type指定值,
Python将把这个形参设置为'dog'.
I have a Dog.
My dog's name is Harry.
    请注意,在这个函数中,修改了形参的排列顺序。由于给animal_type指定了默认值,无需通过实参来指定动物类型,因此在函数调用中只包含一个实参
——宠物的名字。然而,Python依然将这个实参视为位置实参,因此,如果函数调用中只包含宠物的名字,这个实参将关联到函数定义的第一个形参。这就是需
要将pet_name放在形参列表开头的原因所在。
    现在,使用这个函数的最简单的方式是,在函数调用中只提供小狗的名字:
describe_pet("willie")
    这个函数调用的输出与前一个示例相同。只提供了一个实参——‘Willie’,这个实参将关联到函数定义中的第一个形参——pet_name。由于没有给anima
l_type提供实参,因此Python使用其默认值'dog'.
    如果要描述的动物不是小狗,可使用类似于下面的函数说明:
def describe_pet(pet_name,animal_type = 'dog'):
    print('nI have a '   animal_type.title()   '.')
    print("My "   animal_type   "'s name is "   pet_name   ".")

describe_pet(animal_type = "haster",pet_name = "Harry")
describe_pet(pet_name = "Harry",animal_type = "Haster")
    由于显式地给animal_type提供了实参,因此Python将忽略这个形参的默认值。
注意 使用默认值时,在形参列表中必须先列出没有默认值的形参,再列出有默认值的形参。这让Python依然能够正确地解读位置实参。8

8.2.4  等效的函数调用

    鉴于可混合使用位置实参、关键字实参和默认值,通常有多种等效的函数调用方式。请看下面的函数describe_pet()的定义,其中给一个形参提供了默认
值:
    def describe_pet(pet_name,anmila_type = 'dog')

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

8.2.5  避免实参错误

    等我们开始使用函数后,如果遇到实参不匹配错误,不要大惊小怪。我们提供的实参多于或少于函数完成其工作所需的信息时,将出现实参不匹配错误。
例如,如果调用函数describe_pet()没有制定任何实参,结果将如何呢?
def describe_pet(pet_name,animal_type = 'dog'):
    print('nI have a '   animal_type.title()   '.')
    print("My "   animal_type   "'s name is "   pet_name   ".")

describe_pet()
    Python发现该函数调用缺少必要的信息,而traceback指出了这一点:
Traceback (most recent call last):
  File "/home/zhuzhu/title8/pets3.py", line 5, in <module>
    describe_pet()
TypeError: describe_pet() missing 1 required positional argument: 'pet_name'
    traceback指出了问题出在什么地方,让我们能够回过头去找出函数调用中的错误。指出了导致问题的函数调用,traceback指出该函数调用少两个实参,
并指出了相应的形参的名称。如果这个函数存储在一个独立文件中,我们也许无需打开这个文件并查看函数的代码,就能重新正确地编写函数调用。
    Python读取函数的代码,并指出我们需要为哪些形参提供实参,这提供了极大的帮助。这也是应该给变量和函数指定描述性名称的另一个原因;如果我们
这样做了,那么无论对于我们,还是可能使用我们编写的代码的其他任何人来说,Python提供的错误消息将更有帮助。
    如果提供的实参太多,将出现类似traceback,帮助我们确保函数调用和函数定义匹配。

动手试一试
8-3 T恤:编写一个名为make_shirt()的函数,它接受一个尺码以及要印到T恤上的字样。这个函数应打印一个句子,概要地说明T恤的尺码和字样。

#定义一个函数,函数有两个参数,用于存储用户的尺码和字样
def make_shirt(shirt_size,lettering_on_shirt):
    print("I need a "   shirt_size  " shirt and letter "   lettering_on_shirt  " on it.")

make_shirt("L","I love you")
运行结果如下:
I need a L shirt and letter I love you on it.
    首先,定义一个函数,这个函数有两个形参,用户存储用户衣服的尺寸,以及想要在衣服上雕刻什么字
8-4 大号T恤:  修改函数make_shirt(),使其在默认情况下制作意见印有字样'I love Python'的大号T恤。调用这个函数来制作如下T恤:一件印有默认字
样的大号T恤、一件印有默认字样的中号T恤和一件印有其他字样的T恤(尺码无关紧要)。

#定义一个函数,函数有两个参数,用于存储用户的尺码和字样
def make_shirt(shirt_size = "XL",lettering_on_shirt = "I love Python"):
    print("I need a "   shirt_size  " shirt and letter "   lettering_on_shirt  " on it.")

make_shirt()
make_shirt('X')
make_shirt(shirt_size = "X")
make_shirt("L","I love zhuzhu")
make_shirt(shirt_size="L",lettering_on_shirt = "I love you")
make_shirt(lettering_on_shirt = "Work hard",shirt_size = "XXL")
运行结果如下:
I need a XL shirt and letter I love Python on it.
I need a X shirt and letter I love Python on it.
I need a X shirt and letter I love Python on it.
I need a L shirt and letter I love zhuzhu on it.
I need a L shirt and letter I love you on it.
I need a XXL shirt and letter Work hard on it.
8-5城市:编写一个名为describe_city()的函数,它接受一座城市的名字以及该城市所属的国家。这个函数应打印一个简单的句子,如Reykjavik is in 
Iceland.给用于存储国家的形参指定默认值。为三座不同的城市调用这个函数,且其中至少有一座城市不属于默认国家。

def describe_city(city,country = 'China'):
    #定义一个函数,用于存储城市以及所属国家,有两个形参
    print(city   " is in "   country   ".")

describe_city("Beijing")
describe_city(country = "America",city = "New York")
describe_city("Seoul","keroa")
运行结果如下:
Beijing is in China.
New York is in America.
Seoul is in keroa.

8.3  返回值

    函数并非总是直接显示输出,相反,它可以处理一些数据,并返回一个或一组值。函数返回的值称为返回值。在函数中,可使用return语句将值返回到
调用函数的代码行。返回值让我们能够将程序的大部分繁重工作移到函数中去完成,从而简化主程序。

8.3.1  返回简单值

    下面来看一个函数,它接受名和姓并返回整洁的姓名:

def get_formatted_name(first_name,last_name):
    """返回整洁的姓名"""
    full_name = first_name   " "   last_name
    return full_name.title()

musician = get_formatted_name('jimi','hendrix')
print(musician)
    函数get_formatted_name()的定义通过形参接受名和姓。它将姓和名合二为一,在它们之间加上一个空格,并将结果存储在变量full_name中,然后,将
full_name的值转换为首字母大写的格式,并将结果返回到函数调用行。
    调用返回值的函数时,需要提供一个变量,用于存储返回的值。在这里,将返回值存储在了变量musician中。输出为整洁的姓名:  
Jimi Hendrix
    我们原本只需要写下面的代码就可输出整洁的姓名,相比榆次,前面做的工作好像太多了:
print("Jimi Hendrix")
    但在需要分别存储大量名和姓的大型程序中,像get_formatted_name()这样的函数非常有用,我们分别存储名和姓,每当需要显示姓名时都调用这个函数

8.3.2  让实参编程可选的

    有时候,需要让实参变成可选的,这样使用函数的人就只需在必要时才提供额外的信息。可使用默认值来让实参变成可选的。
    例如,假设我们要扩展函数get_formatted_name(),使其处理中间名,为此,可将其修改成类似与下面这样:

def get_formatted_name(first_name,last_name,middle_name = ""):
    """返回整洁的姓名"""
    #使用if进行判断,middle_name是否有参数传进来
    if middle_name:
        full_name = first_name   " "   middle_name   " "   last_name
    else:
        full_name = first_name   " "   last_name
    return full_name.title()

musician = get_formatted_name('jimi','hendrix')
print(musician)

musician = get_formatted_name("Geng","xue","chang")
print(musician)
    并非所有人的都有中间名,但如果我们调用这个函数只提供名和姓,它将不能正确地运行。为让中间名变成可选的,可给实参middle_name指定一个默认值
——空字符串,并在用户没有提供中间名时不使用这个实参。为让get_formatted_name()在没有提供中间名时依然可行,可给实参middle_name指定一个默认
值——空字符串,并将其转移到形参列表的末尾:
    在这个示例中,姓名是根据三个可能提供的部分创建的。由于人都有姓和名,因此在函数定义中首先列出了这两个形参。中间名是可选的,因此在函数定义
中最后列出该形参,并将其默认值设置为空字符串。
    在函数体中,我们检查是否提供了中间名。Python将非空字符串解读为True,因此如果函数调用中间提供了中间名,if middle_name将为True。如果提供
了中间名,就将名、中间名和姓合并为姓名,然后将其修改为首字母大写格式,并返回到函数调用行。在函数调用行,将返回的值存储在变量musician中;然后
将这个变量的值打印出来。如果没有提供中间名,middle_name将为空字符串,导致if测试未通过,进而执行else代码块;只是用名和姓来生成姓名,并将设置
好格式的姓名返回给函数调用行。在函数调用行,将返回的值存储在变量musician章;然后将这个变量的值打印出来。
    调用这个函数时,如果只想制定名和姓,调用起来将非常简单。如果还要指定中间名,就必须确保它是最后一个实参,这样Python才能正确地将位置实参
关联到形参。
    这个修改后的版本适用于只有名和姓的人,也适合于还有中间名的人:
Jimi Hendrix
Geng Chang Xue
    可选值让函数能够处理各种不同情形的同时,确保函数调用尽可能简单。

8.3.3  返回字典

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

person.py
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'
。最后,返回表示人的整个字典。打印这个返回的值,此时原来的两项文本信息存储在一个字典中:
{'last': 'hendrix', 'first': 'jimi'}
    这个函数接受简单的文本信息,将其放在一个更合适的数据结构中,让我们不仅能打印这些信息,还能以其他方式处理它们。当前,字符串'jimi'和'hen'
被标记为名和姓。我们可以轻松地扩展这个函数,使其接受可选值,如中间名、年龄、职业或我们要存储的其他任何信息。例如,下面的修改让我们还能存储
年龄:

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')
print(musician)
    在这个函数中,我们新增了一个可选形参age,其默认值设置为空字符串。如果函数调用中包含这形参的值,这个值将存储到字典中。在任何情况下,这个
函数都会存储人的姓名,但可对其进行修改,使其也存储有关人的其他消息。

8.3.4  结合使用函数和while循环
    可将函数同本书前面介绍的任何Python结构结合起来使用。例如,下面将结合使用函数get_formatted_name()和while循环,以更正规的方式问候用户。
下面尝试使用名和姓跟用户打招呼:
greet.py

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   "!")
    在这个示例中,我们使用的是get_formatted_name()的简单版本,不涉及中间名。其中的while循环让用户输入姓名:依次提示用户输入名和姓:
    但这个while循环存在一个问题:没有定义退出条件。请用户提供一系列的输入时,该在什么地方退出循环呢?(备注:退出条件一定在用户输入之后进行
判断,只有用户输入之后,我们才能根据用户的输入,判定是否要退出循环这样的问题)我们要让用户能够尽可能很容易退出,因此每次提示用户输入时,都应
该提供退出路径。每次提示用户输入时,都使用break语句提供了退出循环的简单途径:

#d定义一个函数,用于存储用户的名和姓,函数有两个形参
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)
    我们添加了一条消息来告诉用户如何退出,然后在每次提示用户输入时,都检查他输入的是否是退出值,如果是,就退出循环。现在,这个程序将不断地
问候,知道用户输入的姓或名为'q'为止:
Please tell me your name: 
Enter 'q' at any time to quit
First name: sora
Last name: aoi

Hello, Sora Aoi

Please tell me your name: 
Enter 'q' at any time to quit
First name: ria
Last name: sakurai

Hello, Ria Sakurai

Please tell me your name: 
Enter 'q' at any time to quit
First name: q

动手试一试
8-6 城市名: 编写一个名为city_country()的函数,它接受城市的名称及其所属的国家。这个函数应返回一个格式类似于下面这样的字符串:

def city_country(city,country):
    '''定义一个函数,用于存储国家和城市'''
    print(city.title()   ", "   country.title())

city_country("seoul",'korea')
city_country("beijing",'china')
city_country("london",'frence')
运行结果如下:
Seoul, Korea
Beijing, China
London, Frence

8-7 专辑:编写一个名为make_album()的函数,它创建一个描述音乐专辑的字典。这个函数应接受歌手名字和专辑名,并返回一个包含这两项信息的字典。使
用这个函数创建三个表示不同专辑的字典,并打印每个返回值,以核实字典正确地存储了专辑的信息。
    给函数make_album()添加一个可选形参,以便能够存储专辑包含的歌曲数。如果调用这个函数时指定了歌曲数,就将这个值添加到表示专辑的字典中。调
用这个函数,并至少在一次调用中指定专辑包含的歌曲数。

def make_album(singer,album,songs = 0):
    '''定义一个函数,三个形参,由于存储歌手,专辑及专辑里面包含的歌曲数'''
    albums = {'singer':singer,'album':album}
    if songs > 0:
        albums["songs"] =songs
    return albums

favorite_album = make_album("Westlife",'face to face',4)
print(favorite_album)

favorite_album = make_album("Amazing","The Location")
print(favorite_album)
运行结果如下:
{'singer': 'Westlife', 'album': 'face to face', 'songs': 4}
{'singer': 'Amazing', 'album': 'The Location'}

分析:如果使用return,则必须有接收变量,因为return是把函数运行的结果返回给调用行,必须有一个指定的变量能够接收这个返回值,否则,就必须输出
这个函数。

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

def greet_users(names):
    '''向列表中的每位用户发出问候语'''
    for name in names:
        msg = "Hello, "   name.title()   "!"
        print(msg)

usernames = ['zengmingzhu','gengchangxue','linzhiling','zhaobenshan']
greet_users(usernames)
    我们将greet_users()定义成接受一个名字列表,并将其存储在形参names中。这个函数遍历收到的列表,并对其中的每位用户都打印一条问候语。我们
定义了一个用户列表——usernames,然后调用greet_users(),并将这个列表传递给它:
Hello, Zengmingzhu!
Hello, Gengchangxue!
Hello, Linzhiling!
Hello, Zhaobenshan!
注意:函数的形参可以是任意形式的值,字典,列表,数字,字符串都可以,我们可以定义任何类型,然后根据参数的属性,调动相应对象的属性进行操作。

8.4.1  在函数中修改列表

    将列表传递给函数后,函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的,这让我们能够高效地处理大量的数据。
    来看一家为用户提交的设计制作3D打印模型的公司。需要打印的设计存储在一个列表中,打印后移到另一个列表中。下面是在不使用函数的情况下模拟这个
过程的代码:

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

The following models have been printed: 
dodecahedron
robot pandant
iphone case
    为重新组织这些代码,我们可编写两个函数,每个都做一件具体的工作。大部分代码都与原来相同,只是效率更高。每一个函数将负责处理打印设计的工
作,而第二个将概述打印了哪些设计:
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 = ['inpone 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 = ['inpone case','robot pendant','dodecahedron']
completed_models = []

print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)
    我们创建了一个未打印的设计列表,还创建了一个空列表,用于存储打印好的模型。接下来,由于我们已经定义了两个函数,因此只需调用它们并传入正确
的实参即可。我们调用print_models()并向它传递两个列表;像预期的一样,print_models()模拟打印设计的过程。接下来,我们调用show_completed_ms()
,并将打印好的模型列表传递给它,让其能够指出打印了哪些模型。描述性的函数名让别人阅读这些代码时也能明白,虽然其中没有任何注释。
    相比于没有使用函数的版本,这个程序更容易扩展和维护。如果以后需要打印其他设计,只需再次调用print_models()即可。如果我们发现需要对打印代
码进行修改,只需修改这些代码一次,就能影响所有调用该函数的地方;与必须分别修改程序的多个地方相比,这种修改的效率更高。
    这个程序还演示了这样一种理念,即每个函数都应只负责一项具体的工作。第一个函数打印每个设计,而第二个显示打印好的模型;这优于使用一个函
数来完成两项工作。编写函数时,如果我们发现执行的任务太多,请尝试将这些代码划分到两个函数中。别忘了,总是可以在一个函数中调用另一个函数,这有
助于将复杂的任务划分成一系列的步骤。

8.4.2  禁止函数修改列表
    有时候,需要禁止函数修改列表。例如,假设像前一个示例那样,我们有一个未打印的设计列表,并编写了一个将这些设计移到打印好的模型列表中的函数。
我们可能会做出这样的决定:即便打印所有设计后,也要保留原来的未打印的设计列表,以供备案。但由于我们将所有的设计都移出了unprinted_designs,这个
列表变成了空的,原来的列表没有了,为解决这个问题,可向函数传递列表的副本而不是原件;这样函数所做的任何修改都只影响副本,而丝毫不影响原件。
    要将列表的副本传递给函数,可以像下面这样做:
    function_name(list_name[:])
    切片表示法[:]创建列表的副本。在print_models中,如果不想清为打印的设计列表,可像下面这样调用print_models():
    print_models(unprinted_designs[:],completed_models)
    这样函数print_models()依然能够完成其工作,因为它获得了所有未打印的设计的名称,但它使用的是列表unprinted_models的副本,而不是列表unprint
ed_designs本身。像以前一样,列表completed_models也将包含打印好的模型的名称,但函数所做的修改不会影响到列表unprinted_designs.
    虽然向函数传递列表的副本可保留原始列表的内容,但除非有充分的理由需要传递副本,否则还是应该将原始列表传递给函数,因为让函数使用现成列表可
避免花时间和内存创建副本,从而提高效率,在处理大型列表时尤其如此。

8.5  传递任意数量的实参

    有时候,我们事先不知道函数需要接收多少个实参,好在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
不管函数收到的实参是多少个,这种语法都管用。

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

    如果要让函数接受不同类型的实参,必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参,再将余下的实参
都收集到最后一个形参中。
    例如,如果前面的函数还需要一个表示比萨的尺寸的实参,必须将该形参放在形参*toppings的前面:

def make_pizza(size,*toppings):
    print("nMaking a "   str(size)   "-inch pizza with following toppings: ")
    for topping in toppings:
        print("- "   topping)

make_pizza(16,"mushrooms")
make_pizza(32,"pepperoni","mushrooms","green peppers")
    基于上述函数定义,Python将收到的第一个值存储在形参size中,并将其他的所有值都存储在元组toppings中。在函数调用中,首先指定表示比萨的
尺寸的实参,然后根据需要制定任意数量的配料:
Making a 16-inch pizza with following toppings: 
- mushrooms

Making a 32-inch pizza with following toppings: 
- pepperoni
- mushrooms
- green peppers

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

    有时候,需要接受任意数量的实参,但预先不知道传递给函数的会是什么样的信息。在这种情况下,可将函数编写成能够接受任意数量的键-值对——
调用语句提供了多少就接受多少。一个这样的示例是创建用户简介:我们知道我们将收到有关用户的信息,但不确定会是什么样的信息。在下面的示例中,函数
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)
    函数build_profile()的定义要求提供名和姓,同时允许用户根据需要提供任意数量的名称-值对。形参**user_info中的两个星号让Python创建一
个名为user_info的空字典,并将收到的所有名称-值对都封装到这个字典中。在这个函数中,可以像访问其他字典那样访问user_info的中名称-值对。
    在build_profile()的函数体内,我们创建了一个名为profile的空字典,用于存储用户简介。我们将名和姓加入到这个字典中,因为我们总是会从用户
哪里收到这两项信息。在2处,我们遍历字典user_info中的键-值对,并将每个键-值对都加入到字典profile中。最后,我们将字典profile返回给函数调
用行。
    我们调用build_profile(),向它传递名'albert'、姓('einstein')和两个键-值对(location = 'princeton'和field = 'physics').并将返回的
profile存储在变量user_profile中,再打印这个变量:
{'location': 'princeton', 'first_name': 'albert', 'field': 'physics', 'last_name': 'einstein'}
    在这里,返回的字典包含用户的名和姓,还有求学的地方和所学的专业。调用这个函数时,不管额外提供了多少个键-值对,它都能正确地处理。
    编写函数时,我们可以以各种方式混合使用位置实参、关键字实参和任意数量的实参。知道这些实参类型大有裨益,因为阅读别人编写的代码时经常会见到
它们。要正确地使用这些类型的实参并知道它们的使用时机,需要经过一定的练习。就目前而言,牢记使用最简单的方法来完成任务就好了。我们继续往下阅读,
就会知道在各种情况下哪种方法的效率是最高的。
    感悟:其实就是函数参数的方法,*代表的以元组的形式进行输入的情况,而**代表的是以字典输入的情况,并且字典要以键-值对的方式进行输出才行,
**代表创建一个空的字典,把用户输入的参数传给这个空的字典。return是返回到调用函数的位置,返回生成的结果到函数调用的位置。

动手试一试
8-12  三明治:编写一个函数,它接受顾客要在三明治中添加的一系列食材。这个函数只有一个形参(它收集函数调用中提供的所有食材),并打印一条消息
,对顾客点的三明治进行概述。调用这个函数三次,每次都提供不同数量的实参。

def make_sandwich(*toppings):
    """定义一个函数,用于存放制作三明治的材料,以元组形式传递参数"""
    print("nMaking sandwich with the following toppings: ")
    for topping in toppings:
        print('- '   topping)

make_sandwich("rice")
make_sandwich("wirte",'milk','pepperoni')
make_sandwich()
运行结果如下:
Making sandwich with the following toppings: 
- rice

Making sandwich with the following toppings: 
- wirte
- milk
- pepperoni

Making sandwich with the following toppings: 
注意:第三次调用函数的时候,我们没有向函数传递参数,但是也没有出现错误,说明*的形式,参数是任意个的,可以没有,也可以是多个。

8-14  汽车:编写一个函数,将一辆汽车的信息存储在一个字典中,这个函数总是接受制造商和型号,还接受任意数量的关键字是实参。这样调用这个函数:
提供必不可少的信息,以及两个名称-值对,如颜色和选装配件。

 def make_car(Manufacturer,model,**car_information):
"""创设多少个函数,用于接受大肆数量的实参,字典情势"""
car_information['making'] = Manufacturer
car_information['test'] = model
return car_information

car = make_car('subaru','outback',color = 'blue',tow_package = True)
print(car)

运作结果如下:

{'test': 'outback', 'color': 'blue', 'tow_package': True, 'making': 'subaru'}

 

思考:小编在想上边的措施也能够,为何小编还要创设三个空的列表,特地来积累的客商的音信,大家平素把结果放入到字典里面岂不是更加好,为何要多此

一口气增多二个空的字典特地来积累变量呢?难道独有是因为不想修改原始的字典新闻。因为在那么些程序中,我们也把小车的承包商和型号放到字典里面去了。

def make_car(manufacturer,model,**car_information):
    """定义一个函数,用于存放一个汽车的信息,以字典的方式存放,形参最后是一个空的字典"""
    profile = {}
    profile['making'] = manufacturer
    profile['size'] = model
    for key,value in car_information.items():
        profile[key] = value

    return profile

car = make_car('subaru','outback',color = 'blue',tow_package = True)
print(car)
运行结果如下:
{'size': 'outback', 'color': 'blue', 'tow_package': True, 'making': 'subaru'}

8.6  将函数存储在模块中

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

8.6.1  导入整个模块

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

def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print("nMaking a pizza with the following toppings: ")
    for topping in toppings:
        print("- "   topping)
    接下来,我们在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件,这个文件导入刚创建的模块,在调用make_pizza()两次:

import pizza1

pizza1.make_pizza(16,"mushrooms")
pizza1.make_pizza(32,"pepperoni","mushrooms","green peppers")
    Python读取这个文件时,代码行import pizza1让Python打开文件pizza1.py,并将其中的所有函数都复制到这个程序中。我们看不到复制的代码,
因为这个程序运行时,Python在幕后复制这些代码。我们只需知道,在making_pizzas.py中,可以使用pizza1.py中定义的所有函数。
    要调用被导入的模块中的函数,可指定导入的模块的名称pizza1和函数名make_pizza(),并用句点分隔它们。这些代码的输出与没有导入模块的原始
程序相同:
Making a 16-inch pizza with following toppings: 
- mushrooms

Making a 32-inch pizza with following toppings: 
- pepperoni
- mushrooms
- green peppers

    这就是一种导入方法:只需编写一条import语句并在其中指定模块名,就可在程序中使用该模块中的所有函数。如果我们使用这种import语句导入了module
_name.py的整个模块,就可以使用下面的语法来使用其中任何一个函数:
    module_name.function_name()

8.6.2    导入特定的函数

    我们还可以导入模块中的特定函数,这种导入方法的语法如下:
    from module_name import function_name
    通过用逗号分隔函数名,可根据需要从模块中导入任意数量的函数:
    from module_name import function_0,function_1,function_2
    对于前面的making_pizzas.py示例,如果只想导入要使用的函数,代码将类似于下面这样:

from pizza1 import make_pizza

make_pizza(16,"mushrooms")
make_pizza(32,"pepperoni","mushrooms","green peppers")
    若使用这种语法,调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza(),因此调用它时只需指定其名称。

8.6.3    使用as给函数指定别名

    如果要导入的函数的名称可能与程序中现有的名称冲突,或者函数的名称太长,可指定简短而独一无二的别名——函数的另一个名称,类似于外号。
要给函数指定这种特殊外号,需要在导入它时这样做。
    下面给函数make_pizza()指定了别名mp()。这是在import语句中使用make_pizza as mp实现的。关键字as将函数重命名为你提供的别名:

from pizza1 import make_pizza as mp

mp(16,"mushrooms")
mp(12,'moshrooms','green pepper','pepperoni')
    上面的import语句将函数make_pizza()重命名为mp();在这个程序中,每当需要调用make_pizza()时,都可简写成mp(),而Python将运行
make_pizza()中的代码,这可避免与这个程序可能包含的函数make_pizza()混淆。
    指定别名的通用语法如下:
    from module_name import function_name as fn

8.6.4  使用as给模块指定别名
    我们还可以给模块指定别名。通过给模块指定简短的别名(如给模块pizza指定别名p),让我们能够更轻松地调动模块中的函数。相比于pizza.make_pizza
,p.make_pizza()更为简洁:

import pizza1 as p

p.make_pizza(16,"mushrooms")
p.make_pizza(12,'moshrooms','green pepper','pepperoni')
    上述import语句给模块pizza指定了别名p,但该模块中所有函数的名称都没变。调用函数make_pizza()时,可编写代码p.make_pizza()而不是
pizza.make_pizza(),这样不仅能够使代码更简洁,还能让我们不再关注模块名,而专注于描述性的函数名。这些函数名明确地指出了函数的功能,对理解代码
而言,它们比模块名更重要。
    给模块指定别名的通用语法如下:
    import module_name as mn

8.6.5  导入模块中的所有函数

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

from pizza1 import *
'''从模块中导入所有的函数'''

make_pizza(16,"mushrooms")
make_pizza(12,'moshrooms','green pepper','pepperoni')

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

8.7  函数编写指南
    编写函数时,需要牢记几个细节。应该函数制定描述性名称,且只在其中使用小写字母和下划线。描述性名称可帮助我们和别人明白代码想要做什么。给模
块命名时也应遵循上述约定。
    每个函数都应包含简要地阐述其功能的注释,该注释应紧跟在函数定义后面,并采用文档字符串格式。文档良好的函数让其他程序员只需阅读文档字符
串中的描述就能够使用它:他们可以相信代码如描述的那样运行;只要知道函数的名称,需要的实参以及返回值的类型,就能在自己的程序中使用它。
    给形参指定默认值时,等号两边不要有空格:
    def function_name(parameter_0,parameter_1='default value')
    对于函数调用中的关键字实参,也应遵循这种约定:
    function_name(value_0,parameter_1='value')
    PEP 8建议代码行的长度不要超过79字符,这样只要编辑器窗口适中,就能看到整行代码。如果形参很多,导致函数定义的长度超过了79字符,可在函数定义
中输入左括号后按回车键,并在下一行按两次Tab键,从而将形参列表和只缩进一层的函数体区分开来。
    大多数编辑器都会自动对齐后续参数列表行,使其缩进程度与我们给第一个参数列表行指定的缩进程度相同:
    def funciton_name(
    parameter_0,parameter_1,parameter_2,
    parameter_3,parameter_4,parameter_5):
    如果程序或模块包含多个函数,可使用两个空行将相邻的函数分开,这样将更容易知道前一个函数在什么地方结束,下一个函数从什么地方开始。
    所有的import语句都应放在文件开头,唯一例外的情形是,在文件开头使用了注释来描述整个程序。

8.8  小结

    在本章中,我们学习了:如何编写函数,以及如何传递实参,让函数能够访问完成其工作所需的信息;如何使用位置实参和关键字实参,以及如何接受任意
数量的实参;显示输出的函数和返回值的函数,如何将函数同列表/字典,if语句和while循环结合起来使用。我们还知道了如何将函数存储在被称为模块的
独立文件中,让程序文件更简单、更易于理解。最后,我们学习了函数编写指南,遵循这些指南可让程序始终结构良好,并对我们和其他人来说易于阅读。
    程序员的目的之一是,编写简单的代码来完成任务,而函数有助于我们实现这样的目标。它们让我们编写好代码块并确定其能够正确运行后,就可置之不理。
确定函数能够正确地完成其工作后,我们就可以接着投身于下一个编码任务。
    函数让我们编写代码一次后,想重用它们多少次就重用多少次。需要运行函数中的代码时,只需编写一行函数调用代码,就可让函数完成其工作。需要修改
函数的行为时,只需修改一下代码块,而所做的修改将影响调用这个函数的每个地方。
    使用函数让程序更容易阅读,而良好的函数名概述了程序各个部分的作用。相对于阅读一系列的代码块,阅读一系列函数调用让我们能够更快地明白程序的
作用。
    函数还让代码更容易测试和调试。如果程序使用一系列的函数来完成其任务,而其中每个函数都完成一项具体的工作,测试和维护起来将容易很多:我们可
编写分别调用每个程序,并测试每个函数是否在它可能遇到的各种情形下都能正确地运行。经过这样的测试后我们就能信心满满,深信我们每次调用这些函数时,
它们都将正确地运行。
    在第9章中,我们将学习编写类。类将函数和数据整洁地封装起来,让我们能够灵活而高效地使用它们。
    函数其实就是要掌握如何调用的形式,形参和实参的对应,以及*元组,**字典的使用方式,明白函数的调用原则,函数要么打印值,要么return返回值,
返回函数中那个值到调用行,调用行那个变量接收函数的返回值。



 

 

 


 

 


 



 

 

 

 

 

 

 

 

 

 

8 章 函数,函数 在本章中,我们将学习编写 函数 。函数是带名字的代码块,用于落成具体的干活。 要进行函数定义的一定职责,可调...

函数(一),函数(

概念函数:

 

#语法
def 函数名(参数1,参数2,参数3,...):
    '''注释'''
    函数体
    return 返回的值

#函数名要能反映其意义

进程:正是从未再次回到值的函数

 

 

函数的参数:

  • 形参:独有在被调用时才分配内部存款和储蓄器单元,在调用停止时,登时释放所分配的内部存款和储蓄器单元。由此,形参只在函数内部有效。
  • 实参:可以是常量、变量、表达式、函数等,在进行函数调用时,都必需有规定的值,以便把这么些值传给形参。 

 

图片 1

 

def test(x,y,z): #x=1,y=2,z=3
    print(x)
    print(y)
    print(z)

#位置参数,必须一一对应,缺一不行多一也不行
test(1,2,3)

#关键字参数,无须一一对应,缺一不行多一也不行
test(y=1,x=2,z=3)

#输出结果:
1
2
3
2
1
3

 

 

#参数组:**字典 *列表
def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get('s'))
test(1,*[1,2,3],**{'s':1})

#输出结果:
1
(1, 2, 3) 3
{'s': 1} 1

 

从概念中得以看出,函数能成功一定职分何况是二个独自单元。

The previous developer uses two ways of declaring functions and I can't work out if there is a reason behind it or not.

全局变量和一些变量:

在子程序中定义的变量称为局地变量,在程序的一同来定义的变量称为全局变量。

全局变量成效域是一切程序,局地变量效用域是概念该变量的子程序。 当全局变量与一些变量同名时:在概念局地变量的子程序内,局地变量起效果;在其他地点全局变量起功效。  

name='reese'
def change_name():
    print('我的名字',name)
change_name()


def change_name():
    name='帅'
    print('我的名字',name)
change_name()
print(name)


def change_name():
    global name
    name='帅'
    print('我的名字',name)
change_name()
print(name)

#输出结果:
我的名字 reese
我的名字 帅
reese
我的名字 帅
帅

 # 固然函数内部无global关键字,优先读取局地变量,能读取全局变量,无法对全局变量重新赋值;

    但对于可变类型(除数字、字符串、元祖,别的都可变),可对个中因素进行操作。

# 假设函数内部有global关键字,变量本质上是全局变量,可读取可赋值。

# 一般全局变量名用大写,局地变量名用小写。

 

先看那一个函数

The two ways are:

 

图片 2

var functionOne = function() { // Some code};

function functionTwo() { // Some code}

递归 

#递归调用

def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n
    s = calc(int(n / 2))
    return s


calc(10)

#输出:
10
5
2
1

 

递归天性:

  1. 必得有一个确定的完毕条件

  2. 历次步向更加深一层递归时,难题规模相比较上次递归都应怀有缩减

3. 递归功效不高,递归档案的次序过多会招致栈溢出(在微型Computer中,函数调用是透过栈(stack)这种数据结构达成的,

每当步入贰个函数调用,栈就能加一层栈帧,每当函数重回,栈就能减一层栈帧。由于栈的轻重不是极致的,所以,递归调用的次数过多,会招致栈溢出)

 

#问路

import time

person_list=['林克','士官长','奎爷','但丁']
def ask_way(person_list):
    print('-'*60)
    if len(person_list) == 0:
        return '没人知道'
    person=person_list.pop(0)
    if person == '但丁':
        return '%s说:我知道,路在脚下,走多了,也就知道了' %person
    print('hi 美男[%s],敢问路在何方' %person)
    print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))
    time.sleep(3)
    res=ask_way(person_list)
    # print('%s问的结果是: %res' %(person,res))
    return res



res=ask_way(person_list)

print(res)

 

从上边看,有多个函数:f和g,那八个函数在有的细节某些不一致,但都得包涵函数的主导组织,函数的概念和函数体

What are the reasons for using these two different methods and what are the pros and cons of each? Is there anything that can be done with one method that can't be done with the other?

函数功能域

 

功用域在概念函数时就早已定位住了,不会趁机调用地方的退换而改变

name = "reese"
def s():
    name = "neo"
    def n():
        print(name)
    return n

func = s()
func()

#输出:
neo

 

函数的概念是投身一个函数的首先行 常常由多少个类型开始代表函数的回到值类型,后接一串德语代表函数名,那是分别函数的率先个部分,函数名后跟一对圆括号,里面写函数的形参,同样函数的形参也许有档案的次序和名字,最终圆括号外边不能够写分号函数定义下边正是以一对花括号括起来的函数体,在函数体中得以扩充各类你想实行的操作,赋值剖断循环调用别样函数以至调用本人;当然一般是达成二个功用。那样函数格式就好了。

转载于:

 

函数分为有参函数和无参函数,有参数正是上边的圆括号内部有形参,无参就是圆括号内部能够写void代表空,也足以怎么都不写;函数又分为有再次来到值的函数和无再次回到值的函数,有重临值的函数中一定要有return(return上面详解)return前边跟二个变量也许常数恐怕三个表明式,必须知足变量可能常数也许表明式与函数定义时的再次来到值一致,无重临值在函数定义时函数名前写void 同有时间函数中能够不出新return。

无名氏函数:

无需出示的内定函数

def calc(x):
    return x   10


res = calc(10)
print(res)

#输出:
20


#用匿名函数:
func = lambda x: x   10
print(func(10))

#输出:
20

 

func = lambda x, y, z: x   y   z
print(func(1, 2, 3))

#输出:
6

 

 

编辑:mg4377娱乐手机版 本文来源:函数函数名称函数函数函数名称

关键词: 函数 名称 function