“一起学习，一起成长！“

1.定义函数与调用函数

定义python函数：依次输入def、函数名、带有函数参数的圆括号，最后紧跟一个冒号(:)

函数命名规范：必须使用字母或者下划线_开头，仅能含有字母、数字和下划线；

定义函数：

def do_nothing():

... pass

注：python函数中的pass表明函数没有做任何事情。和这一页故意留白有同样的作用。

调用函数：

do_nothing()

注意：

写在def语句中函数名后面的变量通常叫做函数的形参，而调用函数的时提供的值时实参，或者称为参数。

引入参数(基础)：

def echo(anything):

... return anything+" "+anything

传入到函数的值称为参数。

输入参数函数例子:

需求：调用commentary函数，把color作为输入的参数，使它返回对颜色的评论字符串：

def commentary(color):

if color=='red':

return "It's a tomato"

elif color=='green':

return "It's a green pepper"

elif color=='bee purple':

return "I don't hnow what it is,but noly bees can see it."

else:

return "I've never heard of the color "+color+"."

传入字符串参数'blue'，调用函数commentary():

comment=commentary('blue')

这个函数做了以下事情：

• 把‘blue’赋值给函数的内部参数color；
• 运行if-elif-else的逻辑链；
• 返回一个字符串；
• 将该字符串赋值给变量comment；

得到返回值：

>>>print(comment)

I've never heard of the color blue.

如果函数不显示调用return函数，那么会默认返回None。

2.位置参数

位置参数：传入参数的值是按照顺序依次复制过去的。

弊端：必须熟记每个位置的参数的含义。

下面创建一个带有位置参数的函数，并且返回一个字典：

def menu(wine,entree,dessert):

return {'wine':wine,'entree':entree,'dessert':dessert}

调用函数：

>>>menu('beef','bagel','bordeaux')

{'dessert':'bordeau','wine':'beef','entree':'bagel'}

3.关键字参数

为了避免位置参数带来的混乱，调用函数时可以指定对应参数的名字，甚至可以采用与函数定义不同的顺序调用：

>>>menu(entree='beef',dessert='bagel',wine='bordeaux')

{'dessert':'bagel','wine':'bordeaux','entree':'beef'}

把位置参数和关键字参数混合起来，位置参数必须放置于关键词参数之前：

>>>menu('frontenac',dessert='flan',entree='fish')

{'entree':'fish','dessert':'flan','wine':'frontenac'}

4.指定默认参数值

指定默认参数值：

>>>def menu(wine,entree,dessert='pudding')

... return {'wine':wine,'entree':entree,'dessert':dessert}

实用例子:

说明：函数buggy()在每次调用时，添加参数arg到一个空的列表result，然后打印输出一个单值列表。但是存在一个问题：只有在第一次调用时列表是空的，第二次调用时就会存在之前调用的返回值：

>>>def buggy(arg,result=[]):

... result.append(arg)

... print(result)

>>>buggy('a')

['a']

>>>buggy('b')

['a','b']

如果写成下面的样子就回解决刚才的问题：

>>>def works(arg)

... result=[]

... result.append(arg)

... return result

>>>works('a')

['a']

>>>wokers('b')

['b']

这样的修改也为了表明是第一次调用跳过一些操作：

>>>def nonbuggy(arg,result=None):

... if result is None:

... result=[]

... result.append(arg)

... print(result)

>>>nonbuggy('a')

['a']

>>>nonbuggy('b')

['b']

5.使用*收集位置参数(元组)

星号(*)将一组可变数量的位置参数集合成参数值的元祖，例如：

>>>def print_args(*args):

... print('Positional argument tuple:',args)

无参数调用，什么都不返回：

>>>print_args()

Positional argument tuple:()

给函数传入的所有参数都会以元祖的形式返回输出：

>>>print_args(3,2,1,'wait!','uh...')

Positional argument tuple:(3,2,1,'wait!','uh...')

应用:

说明：这样的技巧对于编写像print()一样接受可变数量的参数的函数是非常有用的。如果你的函数同时有限定的位置参数，那么*args会收集剩下的参数：

>>>def print_more(required1,required2,*args):

... print('Need this one:',required1)

... print('Need this one too:'required2)

... print('All the rest:',args)

>>>print_more('cap','gloves','scarf','mostache','mustache wax')

Need this one:cap

Need this one too:gloves

All the rest:('scarf','mostache','mustache wax')

当使用*时，不一定要把元祖参数命名为args，但这是python中的一个常见做法。

6.使用**收集关键字参数(字典)

概述：

使用两个星号(**)可以将参数收集到一个字典中，参数的名字是字典的键，对应参数的值是字典的值。

>>>def print_kwargs(**kwargs):

... print('Keyword arguments:',kwargs)

使用关键字参数调用函数：

>>>print_kwargs(wine='merlot',entree='mutton',dessert='macaroon')

Keyword arguments:{'wine':'merlot','entree':'mutton','dessert':'macaroon'}

如果把带有*args和**kwargs的位置参数混合起来，他们必须按照顺序出现。

7.文档化函数(给函数写文档)

概述：如果想要给函数写文档，让其他使用该函数的人能理解的话：

• 加入注释(以#开头)；
• 直接写上字符串(又称文档字符串)。如果在函数的开头写下字符串，它就会作为函数的一部分进行存储，这称为文档字符串。

文档字符串：

>>>def echo(anything)

... 'echo returns its input argument'

... return anything

可以定义非常长的文档字符串，加上详细的规范说明，例如：

def print_if_true(thing,check):

'''

Prints the first argument if a second argument is true.

The operation is:

1.Check whether the *second* argument is true.

2.If it is,print the *first* argument.

调用Python函数help()打印输出一个函数的文档字符串：

>>>help(echo)

Help on function echo in module _main_:

echo(anything):

echo returns its input argument

如果仅仅想得到文档字符串：

>>>print(echo._doc_)

echo returns its input argument

注意：

_doc_是函数属性，作为函数中变量的文档字符串的名字。属性名中的双下划线表示它是个特殊属性

8.一等公民：函数

Python中一切都是对象，包括数字、字符串、元组、列表、字典和函数。

函数是Python中的一等公民，可以把它们(返回值)赋给变量，可以作为参数被其他函数调用，也可以从其他函数中返回值。它可以帮助在python中实现其他语言难以实现的功能。

举例如下：

No.1

>>>def answer():

... print(42)

>>>answer()

42

No.2

>>>def run_something(func):

... func()

>>>run_something(answer)

42

注意：传给函数的是answer，不是answer()。在Python中圆括号意味着调用函数。在没有圆括号的情况下，python会把函数当作普通对象。这是因为在其他情况下，它也仅仅代表一个对象：

>>>type(run_something)

No.3

>>>def add_args(arg1,arg2):

... print(arg1+arg2)

add_args的类型是？

>>>type(add_args)

No.4

此刻定义一个函数run_something_with_args，它带有三个参数：

func-可以运行的函数

arg1-func函数的第一个参数

arg2-func函数的第二个参数

>>>def run_something_with_args(func,arg1,arg2):

... func(arg1,arg2)

当调用run_something_with_args()时，调用方传来的函数赋值给func参数，而arg1和arg2从参数列表中获得值。然后运行带参数的func(arg1,arg2).

>>>run_something_with_args(add_args,5,9)

14

程序最后执行：

func(5,9)

同样可以在此用上*args(位置参数收集)和**args(关键字参数收集)的技巧：

>>>def sum_args(*args):

... return sum(args)

再定义一个新的函数run_with_positional_args()，接收一个函数名以及任意数量的位置参数：

>>>def run_with_positional_args(func,*args):

... return func(*args)

直接调用：

>>>run_with_positional_args(sum_args,1,2,3,4)

10

注意：同样可以把函数作为列表、元组、集合和字典的元素。函数名时不可变的，因此可以把函数用作字典的键。

9.内部函数

在Python中，可以在函数中定义另外一个函数：

>>>def outer(a,b):

... def inner(c,d):

... return c+d

... return inner(a,b)

>>>outer(4,7)

特点：当需要在函数内部多次执行复杂的任务时，内部函数时非常有用的，从而避免了循环和代码的堆叠重复。

>>>def knights(saying):

... def inner(quote):

... return "We are the knights who say:'%s'" % quote

... return inner(saying)

>>>knights('Ni!')

"We are the knights who say:'Ni!'"

10.闭包

概述：内部函数可以看作一个闭包。闭包是一个可以由另一个函数动态生成的函数，并且可以改变和存储函数外创建的变量的值。

>>>def knights2(saying):

... def inner2():

... return "We are the knights who say:'%s' %saying"

... return inner2

inner2()函数可以得到saying参数的值并且记录下来。return inner2这一行返回的是inner2函数的复制(没有直接调用)。所以它就是一个闭包：一个被动态创建的可以记录外部变量的函数。

>>>a=knights2('Duck')

>>>b=knights2('Hasenpfeffer')

>>>type(a)

>>>type(b)

如果调用它们，它们会记录被knights2函数创建时的外部变量saying：

>>>a()

"We are the knights who say:'Duck' "

>>>b()

"We are the knights who say:'Hasenpfeffer' "

11.匿名函数：lambda()函数

Python中，lambda函数是用一条语句表达的匿名函数。可以用它来代替小的函数。

>>>def edit_story(words,func):

... for word in words:

... print(func(word))

>>>stairs=['thud','meow','thud','hiss']

对于函数，它要将每个单词的首字母变为大写，然后在末尾加上感叹号：

>>>def enliven(word): #让这些单词更有情感

>>>edit_story(stairs,enliven)

Thud!

Meow!

Thud!

Hiss!

最后，到了lambda。enliven()函数可以简洁地用下面的一个lambda代替：

>>>edit_story(stairs,lambda word:word.capitalize() + '!')

Thud!

Meow!

Thud!

Hiss!

lambda函数接收一个参数word。在冒号和末尾圆括号之间的部分为函数的定义。

在定义很多小的函数以及记住它们的名字时，lambda会非常有用。尤其实在图形用户界面中，可以使用lambda来定义回调函数。

12.生成器

生成器是用来创建python序列的一个对象。使用它可以迭代庞大的序列，且不需要在内存中创建和存储整个序列。通常，生成器是为迭代器产生数据的。

>>>sum(range(1,101))

5050

特点：每次迭代生成器时，它会记录上一次调用的位置，并且返回下一个值。这一点和普通的函数是不一样的，一般函数都不记录前一次调用，而且都会在函数的第一行开始执行。

如果你想创建一个比较大的序列，使用生成器推导的代码会很长，这时可以尝试写一个生成器函数。生成器函数和普通函数类似，但是它的返回值使用yield语句声明而不是return。

>>>def my_range(first=0,last=10,step=1)

... number=first

... while number

... yield number

... number +=step

>>>my_range

>>>ranger=my_range(1,5)

>>>ranger

>>>for x in ranger:

... print(x)

...

1

2

3

4

「亲，如果笔记对您有帮助，收藏的同时，记得给点个赞、加个关注哦！感谢！」

「文中代码均亲测过，若有错误之处，欢迎批评指正，一起学习，一起成长！」

python语言及其应用