初学Python：函数

在编程过程中可以定义自己想要实现的功能的函数，语法如下：

[python]  view plain  copy

1. def 函数名（参数列表）：    #函数名可以随意编写，但最好不要与内置函数重复，不然内置函数将被替换成你所定义的函数  
2.     函数体   

例：

[python]  view plain  copy

1. def f(a,b,c,d):  
2.     return a,b,c,d  
3. c=f(1,2,3,4)  
4. print(c)  
5. c,d,x,y=f(1,2,4,3)  
6. print(c,d,x,y)  

输出结果：

[python]  view plain  copy

1. (1, 2, 3, 4)  
2. 1 2 4 3  

例：

[python]  view plain  copy

1. def test(x):                    #参数列表里的参数为形参  
2.     x=10  
3.     print('-----',x)  
4. x=5                             #这里的x为实参，虽然与形参一样，但是却是不同的两个值  
5. test(x)  
6. print('--+--',x)  

输出结果：

[python]  view plain  copy

1. ----- 10  
2. --+-- 5  

可变参数和不可变参数：

在之前的学习中，我们知道不可变类型为：字符串、元组和数值；可变类型为：列表、字典、集合。在函数中对不可变参数重新赋值后，函数的输出结果则会输出新赋值，而对可变参数中的某个元素重新赋值后，可变参数本身没有动，只是将内部元素进行了修改。

例：

[python]  view plain  copy

1. def a(x):  
2.     x=10  
3.     print(x)  
4. s=1  
5. a(s)  
6. def b(y):  
7.     y[2]=14  
8.     print(y)  
9. k=[1,2,3,4,5,6]  
10. b(k)  

输出结果：

[python]  view plain  copy

1. 10  
2. [1, 2, 14, 4, 5, 6]  

函数的参数主要分为五个类型：必需参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。但是请注意，参数定义的顺序必须是：必需参数、默认参数、可变参数/命名关键字参数和关键字参数。

例：

[python]  view plain  copy

1. def f2(a, b, c=0, *e, x, d,**k):  
2.     print('a =', a, 'b =', b, 'c =', c, 'e=', e,'x=',x,'d=',d,'k =', k)  
3. args = (1, 2, 3, 4)  
4. kw = {'d': 99, 'x': '#'}  
5. f2(*args,**kw)   

输出结果：

[python]  view plain  copy

1. a = 1 b = 2 c = 3 e= (4,) x= # d= 99 k = {}  

必需参数

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

例：

[python]  view plain  copy

1. #可写函数说明  
2. def printme( str ):  
3.    print (str)  
4.    return  
5.    
6. #调用printme函数  
7. printme( str = "hello")  

输出结果：

[python]  view plain  copy

1. hello  

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

例：

[python]  view plain  copy

1. #可写函数说明  
2. def printinfo( name, age = 35 ):  
3.    print ("名字: ", name)  
4.    print ("年龄: ", age)  
5.    return  
6.    
7. #调用printinfo函数  
8. printinfo( age=30, name="Leo" )  
9. print ("------------------------")  
10. printinfo( name="Leo" )  

输出结果：

[python]  view plain  copy

1. 名字:  Leo  
2. 年龄:  30  
3. ------------------------  
4. 名字:  Leo  
5. 年龄:  35  

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

例：

[python]  view plain  copy

1. #可写函数说明  
2. def printinfo( name, age ):  
3.    print ("名字: ", name)  
4.    print ("年龄: ", age)  
5.    return  
6.    
7. #调用printinfo函数  
8. printinfo( age=30, name="Leo" )  

输出结果：

[python]  view plain  copy

1. 名字:  Leo  
2. 年龄:  30  

不定长参数

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

[python]  view plain  copy

1. def a(*args):    #主要区别为加了‘*’符号  
2.     函数体  
3.     return  

例：

[python]  view plain  copy

1. # 可写函数说明  
2. def printinfo( arg, *args ):  
3.    print ("输出: ")  
4.    print (arg)  
5.    for i in args:  
6.       print (i)  
7.    return  
8.    
9. # 调用printinfo 函数  
10. printinfo( 10 )  
11. printinfo( 70, 60, 50 )  

输出结果：

[python]  view plain  copy

1. 输出:  
2. 10  
3. 输出:  
4. 70  
5. 60  
6. 50  

全局变量和局部变量

全局变量

在一个模块中最高级别的变量有全局作用域，除非被删除，否则能存活到程序运行结束。所有函数都能访问全局变量。

局部变量

定义在函数内的变量有局部作用域。

依赖于定义变量的函数现阶段是否处于活动状态。

调用函数时，局部变量产生，暂时存在。

一旦函数执行完，局部变量将会被释放。

注：

同一个函数中，不允许有同名局部变量

不同函数中，可以有同名局部变量

同一个程序中，全局变量和局部变量同名时，局部变量具有更高的优先级

例：

[python]  view plain  copy

1. total = 0 # 这是一个全局变量  
2. # 可写函数说明  
3. def sum( arg1, arg2 ):  
4.     #返回2个参数的和."  
5.     total = arg1 + arg2 # total在这里是局部变量.  
6.     print ("函数内是局部变量 : ", total)  
7.     return total  
8.   
9. #调用sum函数  
10. sum( 10, 20 )  
11. print ("函数外是全局变量 : ", total)  

输出结果：

[python]  view plain  copy

1. 函数内是局部变量 :  30  
2. 函数外是全局变量 :  0  

但是有时候我们想要函数中修改外部作用域的变量时，就需要global方法来实现了。

例：

[python]  view plain  copy

1. num = 1  
2. def fun1():  
3.     global num  # 需要使用 global 关键字声明  
4.     print(num)   
5.     num = 2  
6.     print(num)  
7. fun1()  

输出结果：

[python]  view plain  copy

1. 1  
2. 2