函数

1、函数定义：

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回，不带参数值的return语句返回None。

#1、定义无参函数：
def person1():
　　print(“hello”)
　　return("hello")　　　　#调用return函数获取返回值

#2、定义有参函数：
def person2(name):
　　print(“hello”,name)
　　return("hello",name)  #调用return函数获取返回值

#3、函数的调用
person1()
person2("ryan")

#1、函数定义:
def test():
    "the funcation details"
    print("in the test funcation")
    return 0

'''
def #定义函数的关键字
test #函数名
() #定义形参，我这边没有定义。如果定义的话，可以写成:def test(x): 其中x就是形式参数
"the funcation details" # 文档描述(非必要，但是强烈建议你为你的函数添加详细信息，方便别人阅读)
print #泛指代码块或者程序逻辑处理
return #定义返回值
'''

#2、过程定义:
#定义过程
def test_2():
    "the funcation details"
    print("in the test funcation")
    
'''
 注：从上面两个例子看出来，函数和过程，无非就是函数比过程多了一个return的返回值，其他的也没什么不一样。
 小结：不难看出，函数和过程其实在python中没有过多的界限，当有return时，则输出返回值，当没有return，则返回None
'''

2、函数作用域

Python使用名称空间的概念存储对象，这个名称空间就是对象作用的区域,不同对象存在于不同的作用域。

每个模块都有自已的全局作用域。函数定义的对象属局部作用域，只在函数内有效，不会影响全局作用域中的对象。赋值对象属局部作用域，除非使用global关键字进行声明。在函数、类等内部可见局部作用域；局部变量使用范围不能超过其所在的局部作用域。

LGB 规则--大多数名字引用在三个作用域中查找：先局部(Local)，次之全局(Global)，再次之内置(Build-in)。

全局变量是位于模板文件内部的顶层的变量名；
全局变量如果在函数内部被赋值的话，必须经过声明；
全局变量在函数的内部不经过声明也可以被引用。

如想在局部作用域中改变全局作用域的对象，必须使用global关键字 。'global'声明把赋值的名字映射到一个包含它的模块的作用域中。若仍然找不到这个变量名，则引发NameError异常。

#coding=utf-8
name = "ryan"   #全局变量
def fun():
    country = "China" #局部变量
    print name
    global name     #声明全局变量
    name = "joe"    #修改全局变量
    print name
fun() 
print name

3、函数参数

#1、普通参数：
# ######### 定义函数 #########
# name 叫做函数func的形式参数，简称：形参
def func(name):
    print(name)
# ######### 执行函数 #########
#  'xiaoyao' 叫做函数func的实际参数，简称：实参
func('xiaoyao')

#2、默认参数：
def func(name, age = 18):
    print("%s:%s" %(name,age))
func('xiaoyao')  　　# 默认参数在不指定的时候，就是默认值
func('xiaoyao',20) 　　# 一旦指定，就不再使用默认值
#注：默认参数需要放在参数列表最后，可以有多个默认参数
#指定参数：
def func(name, age):
    print("%s:%s" %(name,age))
func(age=20,name='xiaoyao')  # 可以通过形参名称，不按顺序的传入参数

#3、动态参数(参数组)：
#(*args) 功能：接收N个位置参数，转换成元组的形式
def hello(*argv):
    print argv[0]
    print argv
hello(3,3,4)
#(**kwargs) 功能：把N个关键字参数，转换成字典形式
def hello(**kargv):
    print kargv.keys()
    print kargv.values()
    print kargv
hello(a=1,b=3,c=4,d=0)

4、匿名函数

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

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

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

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

5、嵌套函数

 在一个函数中定义了另外一个函数

#coding=utf-8
def outer():
    def inner():
        print('inner')
        print('outer')
    inner()
outer()

inner()    # 此句会出错,内部函数不能被外部直接使用，会抛NameError异常)
#函数有可见范围，这就是作用域的概念

 6、递归

递归调用是函数嵌套调用的一种特殊形式，如果一个函数在内部直接或间接调用自身，这个函数就是递归函数。

'''
场景：用10不断除以2，直到除不尽为止，打印每次结果。
思路：
# 10/2=5
# 5/2=2.5
# 2.5/2=1.25
# ...
'''

#用while循环实现：
n = 10
while True:
    n = int(n/2)
    print(n)
    if n == 0:
        break
''' 
#输出
5
2
1
0
'''

#非递归方式实现：
def calc(n):
    n = int(n/2)
    return n
 
r1 = calc(10)
r2 = calc(r1)
r3 = calc(r2)
r4 = calc(r3)
print(r1)
print(r2)
print(r3)
print(r4)

''' 
#输出
5
2
1
0
'''

#用递归实现：
def calc(n):
    print(n)
    if int(n/2) == 0:  #结束符
        return n
    return calc(int(n/2))  #调用函数自身
  
m = calc(10)
print('----->',m)

'''  
#输出
10
5
2
1
-----> 1 #最后返回的值
'''

#来看实现过程，我改了下代码
def calc(n):
    v = int(n/2)
    print(v)
    if v > 0:
        calc(v)
    print(n)
 
calc(10)

'''
#输出
5
2
1
0
1
2
5
10
'''

#递归层数：
import sys
print(sys.getrecursionlimit()) # 默认递归限制层数
sys.setrecursionlimit(1500) # 修改递归层数

#尾递归优化：
#调用下一层时候退出。（解决栈溢出的问题，每次只保留当前递归的数据），在C语音里有用，Python中没用
def recursion(n):
    print(n)
    return recursion(n+1)
recursion(1)

'''
递归特性:
(1)递归就是在过程或者函数里调用自身
(2)在使用递归策略时，必须有一个明确的结束条件，称为递归出口
(3)每次进入更深一层递归时，问题规模相比上次递归都应有所减少(问题规模：比如你第1次传进的是10，第2次递归应该是9...依次越来越少，不能越来越多)。
(4)递归算法解题通常显得很简洁，但递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出），所以一般不倡导使用递归算法设计程序。
'''

递归算法一般用于解决三类问题：
（1）数据的定义是按递归定义的。（比如Fibonacci函数）
（2）问题解法按递归算法实现。（回溯）
（3）数据的结构形式是按递归定义的。（比如树的遍历，图的搜索，二分法查找等）

堆栈扫盲：http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html