函数

函数介绍
如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。

<1>定义函数
定义函数的格式如下：（用def定义函数，函数名的命名规则与变量名相同）

def 函数名():
    代码

<2>调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它。调用函数很简单的，通过 函数名() 即可完成调用。

# 定义一个函数，能够完成打印信息的功能
def printInfo():       
    print '人生苦短，我用Python'     

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

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

def add2num(a, b):
    c = a+b
    print c

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

def add2num(a, b):
    c = a+b
    print c

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

<3> 小总结
定义时小括号中的参数，用来接收参数用的，称为 “形参”
调用时小括号中的参数，用来传递给函数用的，称为 “实参”

函数返回值(一)
<1>“返回值”介绍

开发中的场景：
定义了一个函数，完成了获取室内温度，想一想是不是应该把这个结果给调用者，只有调用者拥有了这个返回值，才能够根据当前的温度做适当的调整

综上所述：
所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果

<2>带有返回值的函数
想要在函数中把结果返回给调用者，需要在函数中使用return

def add2num(a, b):
    c = a+b
    return c

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

#定义函数
def add2num(a, b):
    return a+b
#调用函数，顺便保存函数的返回值
result = add2num(100,98)
#因为result已经保存了add2num的返回值，所以接下来就可以使用了
print result        

#定义函数
def get_wendu(a):
    wendu = 22
    return wendu 
#定义函数，传入第一个函数的返回值    
def get_wendu_huashi(wendu):
    wendu = wendu + 3
    print("当前的温度(华氏)是:%d"%wendu)
    #调用函数，顺便保存函数的返回值
    result = get_wendu(1000000)
    get_wendu_huashi(result)

<3>保存函数的多个返回值

    def test():
        a = 11
        b = 22
        c = 33

        #第1种,用一个列表来封装3个变量的值
        #d = [a,b,c]
        #return d
        #第2种
        #return [a,b,c]
        #第3中
        #return (a,b,c)
        return a,b,c #本质是元组
        #定义三个变量保存返回的结果
        num1,num2,num3 = test()

4种函数的类型

函数根据有没有参数，有没有返回值，可以相互组合，一共有4种
无参数，无返回值 无参数，有返回值
有参数，无返回值 有参数，有返回值

<1>无参数，无返回值的函数
此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数

def printMenu():
    print('--------------------------')
    print('      xx涮涮锅 点菜系统')
    print('')
    print('  1.  羊肉涮涮锅')
    print('  2.  牛肉涮涮锅')
    print('  3.  猪肉涮涮锅')
    print('--------------------------')

<2>无参数，有返回值的函数
此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数

# 获取温度
def getTemperature():
    #这里是获取温度的一些处理过程
    #为了简单起见，先模拟返回一个数据
    return 24
temperature = getTemperature()
print('当前的温度为:%d'%temperature)

<3>有参数，无返回值的函数
此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

<4>有参数，有返回值的函数
此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数

# 计算1~num的累积和
def calculateNum(num):
    result = 0
    i = 1
    while i<=num:
        result = result + i
        i+=1
    return result

result = calculateNum(100)
print('1~100的累积和为:%d'%result)

<5>小总结
函数根据有没有参数，有没有返回值可以相互组合
定义函数时，是根据实际的功能需求来设计的，所以不同开发人员编写的函数类型各不相同

函数的嵌套调用
如果函数A中调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

def testB():
    print('这里是testB函数执行的代码...(省略)...')
def testA():
    testB()
testA()

小总结：
一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用

局部变量
局部变量，就是在函数内部定义的变量
不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

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

# 定义全局变量
a = 100
def test1():
    print(a)
def test2():
    print(a)
# 调用函数
test1()
test2()

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

<3>修改全局变量

<4>总结1:
在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧强龙不压地头蛇

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

>>> a = 1
>>> def f():
...     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,]
>>> def f2():
...     li.append(1)
...     print li
...
>>> f2()
[1, 1]

<5>总结2：
在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。

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

def printinfo( name, age = 35 ):
   # 打印任何传入的字符串
   print "Name: ", name
   print "Age ", age

   # 调用printinfo函数
printinfo(name="miki" )

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

>>> def printinfo(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中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

引用

  a = "hello"
  b = a #b是a的引用，a与b指向同一个地址

用id(变量名) 可以查看地址

递归函数
如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

匿名函数

用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 )

思考题：交换两个变量的值
方法一：采用第三个变量
方法二：a = a+b;b = a-b;a = a-b
方法三：a,b = b,a