Python函数笔记（python函数详解）

Python的函数

1、函数介绍

我们知道圆的面积计算公式为：S = πr2

当我们知道半径r的值时，就可以根据公式计算出面积。假设我们需要计算3个不同大小的圆的面积：

r1 = 12.34 r2 = 9.08 r3 = 73.1

s1 = 3.14 * r1 * r1

s2 = 3.14 * r2 * r2

s3 = 3.14 * r3 * r3

当代码出现有规律的重复的时候，你就需要当心了，每次写3.14 * x * x不仅很麻烦，而且，如果要把3.14改成3.14159265359的时候，得全部替换。

有了函数，我们就不再每次写s = 3.14 * x * x，而是写成更有意义的函数调用s = area_of_circle(x)，而函数area_of_circle本身只需要写一次，就可以多次调用。

基本上所有的高级语言都支持函数，Python也不例外。Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

2、函数的定义与调用

1、定义函数

定义函数的格式如下：

def 函数名(): 代码

demo:

# 定义一个函数，能够完成打印信息的功能

def printInfo():

print'------------------------------------'

print' 人生苦短，我用Python'

print'------------------------------------'

2、调用函数

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它

调用函数很简单的，通过 函数名() 即可完成调用

demo:

# 定义完函数后，函数是不会自动执行的，需要调用它才可以

printInfo()

3、函数参数（一）

思考一个问题，如下：

现在需要定义一个函数，这个函数能够完成2个数的加法运算，并且把结果打印出来，该怎样设计？下面的代码可以吗？有什么缺陷吗？

def add_2num():

a = 11

b = 22

c = a+b

print c

为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是 函数的参数

<1> 定义带有参数的函数

示例如下：

def add2num(a, b):

c = a+b

print c

<2> 调用带有参数的函数

以调用上面的add2num(a, b)函数为例:

def add2num(a, b):

c = a+b

print c

add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据

<4> 小总结

定义时小括号中的参数，用来接收参数用的，称为 “形参”

调用时小括号中的参数，用来传递给函数用的，称为 “实参”

4、函数参数（二）

1. 缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

注意：带有默认值的参数一定要位于参数列表的最后面。

>>> defprintinfo(name, age=35, sex):

... print name

...

File "<stdin>", line 1 SyntaxError: non-default argument follows default argument

2.不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

基本语法如下：

Def functionname([formal_args,] *args, **kwargs):"函数_文档字符串"

function_suite

return [expression]

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

>>> def fun(a, b, *args, **kwargs):

... """可变参数演示示例"""

... print"a =", a

... print"b =", b

... print"args =", args

... print"kwargs: "

... for key, value in kwargs.items():

... print key, "=", value

...

>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应

a = 1

b = 2

args = (3, 4, 5)

kwargs: p = 8 m = 6 n = 7

>>>

>>> c = (3, 4, 5)

>>> d = {"m":6, "n":7, "p":8}

>>> fun(1, 2, *c, **d) # 注意元组与字典的传参方式

a = 1

b = 2

args = (3, 4, 5)

kwargs: p = 8 m = 6 n = 7

>>> 

>>> fun(1, 2, c, d) # 注意不加星号与上面的区别

a = 1

b = 2

args = ((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})

kwargs:

3. 引用传参

可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？

Python有没有类似C语言中的指针传参呢？

>>> def selfAdd(a):... """自增"""... a += a

...

>>> a_int = 1

>>> a_int 1

>>> selfAdd(a_int)

>>> a_int 1

>>> a_list = [1, 2]

>>> a_list [1, 2]

>>> selfAdd(a_list)

>>> a_list [1, 2, 1, 2]

Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

5、函数返回值（一）

<1>带有返回值的函数

想要在函数中把结果返回给调用者，需要在函数中使用return

如下示例:

def add2num(a, b):

c = a+b

return c

或者

def add2num(a, b):

return a+b

<2>保存函数的返回值

在本小节刚开始的时候，说过的“买烟”的例子中，最后儿子给你烟时，你一定是从儿子手中接过来 对么，程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，那么就需要保存

保存函数的返回值示例如下:

#定义函数

def add2num(a, b):

return a+b #调用函数，顺便保存函数的返回值

result = add2num(100,98) #因为result已经保存了add2num的返回值，所以接下来就可以使用了

print result

6、函数的返回值（二）

在python中我们可不可以返回多个值？

>>> def divid(a, b):

... shang = a//b

... yushu = a%b

... return shang, yushu

...

>>> sh, yu = divid(5, 2)

>>> sh 5

>>> yu 1

本质是利用了元组

7、局部变量和全局变量

1、局部变量

局部变量（Local variables）指在程序中只在特定过程或函数中可以访问的变量。

总结

1、局部变量，就是在函数内部定义的变量

2、不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响

3、局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

2、全局变量

<1>什么是全局变量

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

<2>全局变量和局部变量名字相同问题

<3>修改全局变量

既然全局变量，就是能够在所以的函数中进行使用，那么可否进行修改呢？：global

<4>可变类型的全局变量

>>> a = 1

>>> deff():

... a += 1

... print a

...

>>> f()

Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in f UnboundLocalError: local variable 'a' referenced before assignment

>>> li = [1,]

>>> deff2():

... li.append(1)

... print li

...

>>> f2() [1, 1]

>>> li [1, 1]

<5>总结1:

在函数外边定义的变量叫做全局变量

全局变量能够在所有的函数中进行访问

如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错

如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧：强龙不压地头蛇

<5>总结2：

在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。

对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。

对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。

可变类型：值可以修改（内存地址不变但是所保存的值变化了），引用可以修改（变量的内存地址变化了）

不可变类型：值不可以修改，可以修改变量的引用（=赋值号）。

在函数里面修改全局变量：

1、如果全局变量是可变类型：所以在函数里面任意修改（值，引用）

2、如果全局变量是不可变类型：在函数里面不能修改值，也不能修改引用，除非加上global才能修改引用。

8、递归函数

<1>什么是递归函数

通过前面的学习知道一个函数可以调用其他函数。

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

<2>递归函数的作用

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n

解决办法1:

看阶乘的规律

1! = 1 2! = 2 × 1 = 2 × 1! 3! = 3 × 2 × 1 = 3 × 2! 4! = 4 × 3 × 2 × 1 = 4 × 3! ... n! = n × (n-1)!

解决办法2:

递归函数案例：

斐波拉契数列，该数列中有n个数字。

1 1 2 3 5 8

该数列中，从第三个数字开始：数值 =前一个数字 + 前前面一个数字

(n-1) + (n-2)

9、匿名函数

1、匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:

expression

如下实例：

sum = lambda arg1, arg2: arg1 + arg2 #调用sum函数

print"Value of total : ", sum( 10, 20 )

print"Value of total : ", sum( 20, 20 )

以上实例输出结果：

Value of total : 30

Value of total : 40

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

匿名函数不能直接调用print，因为lambda需要一个表达式

2、应用场合

函数作为参数传递

1、自己定义函数

>>> def fun(a, b, opt):

... print"a =", a

... print"b =", b

... print"result =", opt(a, b)

...

>>> fun(1, 2, lambda x,y:x+y)

a = 1

b = 2

result = 3

2、作为内置函数的参数

想一想，下面的数据如何指定按age或name排序？

stus = [ {"name":"zhangsan", "age":18}, {"name":"lisi", "age":19}, {"name":"wangwu", "age":17} ]

按name排序：

>>> stus.sort(key = lambda x:x['name'])

>>> stus [{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]

 

按age排序：

>>> stus.sort(key = lambda x:x['age'])

>>> stus [{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]