函数　　

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

1.代码重用

2.保持一致性

3.可扩展性

 

函数的创建

1.格式

Python 定义函数使用 def 关键字，一般格式如下：

1 #def 函数名（参数列表）:2 #    函数体3 4 def hello():5     print('hello')6    7 hello()#调用

 

2.函数的命名规则

1. 函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；
2. 函数名是区分大小写的。
3. 函数名不能是保留字。

3.形参和实参

形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）

实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参   

区别：形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参。

1 import time2 times=time.strftime('%Y--%m--%d')3 def f(time):4     print('Now  time is : %s'%times)5 f(times)

 

4.实例

现在我们就用一个例子来说明函数的三个特性：

1 def action1(n): 2     print ('starting action1...') 3  4     with open('日志记录','a') as f: 5         f.write('end action%s\n'%n) 6  7 def action2(n): 8     print ('starting action2...') 9 10     with open('日志记录','a') as f:11         f.write('end action%s\n'%n)12 13 def action3(n):14     print ('starting action3...')15 16     with open('日志记录','a') as f:17         f.write('end action%s\n'%n)18 19 action1(1)20 action2(2)21 action3(3)22 23 24 ##***************代码重用25 26 def logger(n):27     with open('日志记录','a') as f:28         f.write('end action%s\n'%n)29 30 def action1():31     print ('starting action1...')32     logger(1)33 34 35 def action2():36     print ('starting action2...')37     logger(2)38 39 40 def action3():41     print ('starting action3...')42     logger(3)43 44 45 action1()46 action2()47 action3()48 49 ##***************可扩展和保持一致50 ##为日志加上时间51 import time52 53 def logger(n):54     time_format='%Y-%m-%d %X'55     time_current=time.strftime(time_format)56 57     with open('日志记录','a') as f:58         f.write('%s end action%s\n'%(time_current,n))59 60 def action1():61     print ('starting action1...')62     logger(1)63 64 65 def action2():66     print ('starting action2...')67     logger(2)68 69 70 def action3():71     print ('starting action3...')72     logger(3)73 74 action1()75 action2()76 action3()

 

函数的参数

站在形参角度：

1.位置参数

位置参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

1 def f(name,age):2  3     print('I am %s,I am %d'%(name,age))4  5 f('alex',18)6 f('alvin',16)

 

2.关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

1 def f(name,age):2  3     print('I am %s,I am %d'%(name,age))4  5 # f(16,'alvin') #报错6 f(age=16,name='alvin')

 

3.位置参数、关键字参数混着用

def mymax(x,y):    #此时x = 10,y = 20    print(x,y)    the_max = x if x > y else y    return the_maxma = mymax(10,y = 20)print(ma)正确用法：位置参数必须在关键字参数的前面即必须先按位置传参，然后再关键字传参；对于一个形参只能赋值一次

 

4.默认参数

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

1 def print_info(name,age,sex='male'):2  3     print('Name:%s'%name)4     print('age:%s'%age)5     print('Sex:%s'%sex)6     return7  8 print_info('alex',18)9 print_info('铁锤',40,'female')

默认参数陷阱：如果默认参数的值是一个可变数据类型，那么每一次调用的时候如果不传值就共用这个数据类型的资源。

例1：def qqxing(l=[])    l.append(1)    print(l)qqxing(1)   #[1]qqxing([])   #[1]qqxing()     #[1,1]qqxing()     #[1,1,1]例2：def qqxing(k,l=[])    l[k] = 'v'    print(l)qqxing(1)qqxing(2)qqxing(3)输出：[1,'v'][1:'v',2:'v'][1:'v',2:'v',3:'v']

 

5.不定长参数

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

1 def add(*args):2     sum=03     for v in args:4         sum+=v5　　  #print(args)    输出(1,4,6,9)，即会以元组的形式存放参数 6     return sum7  8 print(add(1,4,6,9))9 print(add(1,4,6,9,5))

*args：接收的是按照位置传参的值，组织成一个元组；**args：接收的是按照关键字传参的值，组织成一个字典。

1 def print_info(**kwargs):2     print(kwargs)  #输出：{'sex': 'female', 'name': 'alex', 'ability': 'Python', 'age': 18, 'nationality': 'Chinese', 'hobby': 'girl'}即以字典的方式存放变量3     for i in kwargs:4         print('%s:%s' % (i, kwargs[i]))  # 根据参数可以打印任意相关信息了5 6     return7 8 9 print_info(name='alex', age=18, sex='female', hobby='girl', nationality='Chinese', ability='Python')

定义函数时，参数位置顺序：（位置参数、关键字参数、*args、默认参数、**kwargs）

1 def print_info(name,*args,**kwargs):#def print_info(name,**kwargs,*args):报错 2   3     print('Name:%s'%name) 4   5     print('args:',args) 6     print('kwargs:',kwargs) 7   8     return 9  10 print_info('alex',18,hobby='girl',nationality='Chinese',ability='Python')11 # print_info(hobby='girl','alex',18,nationality='Chinese',ability='Python')  #报错12 #print_info('alex',hobby='girl',18,nationality='Chinese',ability='Python')   #报错

注意，还可以这样传参：

1 def f(*args):         # 站在形参的角度上，给变量加上*，就是组合所有传来的值2     print(args)4 f(*[1,2,5])           # 站在实参的角度上，给一个字典加上*，就是将这个序列按照顺序打散后传递给函数 6 def f(**kargs):       # 站在形参的角度上，给变量加上**，就是组合所有按照关键字的方式传递过来的值 7     print(kargs)8  9 f(**{
   'name':'alex'})   # 站在实参的角度上，给一个字典加上**，就是将这个字典按照顺序打散后按照关键字的方式传递给函数 输出： (1, 2, 5) {'name': 'alex'} 例子： def outer(*args,**args): 　　print(args) 　　print(*args) outer(1,2,3,4)  # 等同于： outer(*[1,2,3,4]) 或 outer(*(1,2,3,4)) 输出： (1,2,3,4) 1 2 3 4    即将序列按照顺序打散

 

函数的返回值

要想获取函数的执行结果，就可以用return语句把结果返回。

注意：

• 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，所以也可以理解为 return 语句代表着函数的结束；
• 如果未在函数中指定return,那这个函数的返回值为None；(只写return，也只返回None，这里的return的作用是终止函数)
• return多个对象，解释器会把这多个对象组装成一个元组作为一个一个整体结果输出。也可以使用多个变量来接收多个返回值。

 

命名空间

内置命名空间

python解释器一启动就能识别的名字则就保存在内置命名空间中。内置的名字在启动解释器的时候被加载进内存，（如print、int等）。内置命名空间只有一个。

全局命名空间

是在程序从上到下被执行的过程中依次加载进内存的。放置自定义的名字和函数名。全局命名空间只有一个。

局部命名空间

就是函数内部定义的名字。当调用函数的时候，才会产生这个名称空间，随着函数执行的结束，这个名称空间就又消失了。每一个函数都有自己独立的局部命名空间，局部命名空间之间是隔离的。

在局部命名空间可以使用全局、内置命名空间中的名字；在全局命名空间可以使用内置命名空间的名字，但不能使用局部命名空间的名字；内置命名空间中不能使用全局、内置命名空间中的名字。

正常情况下，直接使用内置的名字；当在全局和内置命名空间定义了相同的名字时，会使用全局的名字；当名字在本命名空间查找的到时，就不会向上级命名空间查找，当名字在本命名空间查找不到时才会向上级命名空间找，上一级没有再找上一级，如果在内置的命名空间都没有，就会报错。

 

 

作用域

 

1.作用域介绍：

python中的作用域分2种情况：

局部作用域：作用在局部，局部命名空间中的名字属于局部作用域如函数；对于不可变数据类型的变量，在局部作用域中可以查看全局作用域中的变量，但是不能直接修改全局作用域中的变量。如果想要修改全局作用域中的变量，需要在局部作用域的一开始添加global关键字声明，声明后才能对全局作用域的变量进行修改

• L：local，局部作用域，即函数中定义的变量；
• E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

全局作用域：作用在全局，内置命名空间和全局命名空间中的名字属于全局作用域

• G：globa，全局作用域，就是模块级别定义的变量；
• B：built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：局部作用域>外层作用域>当前模块中的全局作用域>python内置作用域，也就是LEGB。

1 x = int(2.9)  # int built-in 2   3 g_count = 0  # global 4 def outer(): 5     o_count = 1  # enclosing 6     def inner(): 7         i_count = 2  # local 8         print(o_count)  #输出1 9    #print(i_count) 找不到10     inner()  11 outer()12  13 # print(o_count) #找不到

 

2.作用域的产生：

在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的，如下代码：

1 if 2>1:2     x = 13 print(x)  # 1

这个是没有问题的，if并没有引入一个新的作用域，x仍处在当前作用域中，后面代码可以使用。

1 def test():2     x = 23 print(x) # NameError: name 'x2' is not defined

def、class、lambda是可以引入新作用域的。print(x)中的x不处于当前作用域中。

3.变量的修改：

1 ################# 2 x=6 3 def f2(): 4     print(x) 5     x=5 6 f2() 7    8 # 错误的原因在于print(x)时,解释器会在局部作用域找,会找到x=5(函数已经加载到内存),但x使用在声明前了,所以报错: 9 # local variable 'x' referenced before assignment.10 #同理11 x=612 def f2(): 13     x+=1 #local variable 'x' referenced before assignment.14 f2()

4.global关键字：

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域（global作用域）上的，就要使用global先声明一下，代码如下：

1 count = 102 def outer():3     global count4     print(count)  #正常情况下，count位于global作用域上，在内部作用域里可以查看但不能修改，如果要修改就需要使用global关键字了5     count = 100  #修改global作用域上的变量6     print(count)7 outer()8 #109 #100

 

5.nonlocal关键字：

global关键字声明的变量必须在全局作用域上，不能位于嵌套作用域上，当要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量时就需要nonlocal关键字：

1 def outer(): 2     count = 10 3     def inner(): 4         nonlocal count 5         count = 20 6         print(count) 7     inner() 8     print(count) 9 outer()10 #2011 #20　

6.总结：

（1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；

（2）只有模块、类、及函数才能引入新作用域。其它的代码块（如if、try、for等）是不会引入新的作用域的；

（3）对于一个变量，内部作用域声明了就会覆盖外部变量。不声明直接使用，就会使用外部作用域的变量；

（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个 关键字，就能完美的实现闭包了。 

 

程序的执行过程解析