python的函数（三）

1，函数多类型传值和冗余参数

2，递归函数

1，函数多类型传值和冗余参数

1.0，函数多类型传值

定义1个函数，

def fun(x,y):
　　return x+y

　　

调用该函数print fun(1,2)，返回3。但是有一种情况，我就想输入一个参数，是否可行？当然，可以考虑使用默认参数。但是除了默认参数我们还可以传入一个元祖，就能完成相当于传入2个参数的效果。

def fun(x,y):
    return x+y

t=(1,2)

print fun(*t)

　　

上面的代码只是传入了一个参数，但是传入的是元祖，可以发现元祖的个数和传入参数刚好匹配，在元祖前面加个*号就可以将元祖传入到函数中并与形参一一对应。可见传入元祖或列表用*号。

def fun(x,y,z):
    return x+y+z

print fun(**{'x':1,'y':3,'z':5})

　　

上面的代码传入字典，用于替代出入的三个参数，传入字典要用**号。

2，冗余参数（可变参数）

在定义函数的时候，不确认函数传入的参数的个数，这个时候就需要用到可变参数了。

def fun(x,*args,**kwargs):
    print x
    print args
    print kwargs

fun(1)

　

上述会返回1，和一个空的元祖和一个空的字典。可见args或者*kwargs是可以不用传给参数给它的。

def fun(x,*args,**kwargs):
    print x
    print args
    print kwargs

fun(1,23,3,4,5)

　

上面的代码返回1和(23,3,4,5)和1个空字典。可见这些元素23,3,4,5都传给args这个参数了。

def fun(x,*args,**kwargs):
    print x
    print args
    print kwargs

fun(1,23,3,4,5,k=1)

　　

上面的代码返回如下：

1
(23, 3, 4, 5)
{'k': 1}

可以发现这个和上面的区别是多传入了一个参数，这个参数的传给了**kwargs这个参数并以字典返回。所以，如果需要出入字典的话，需要使用**kwargs这个可变参数。

def fun(x,*args,**kwargs):
    print x
    print args
    print kwargs

fun(1,23,3,4,5,k=1,*(5,6,7),**{'name':'tom'})

　　

上面代码返回如下：

1
(23, 3, 4, 5, 5, 6, 7)
{'k': 1, 'name': 'tom'}

可以发现这些23,3,4,5,k=1,*(5,6,7)都传给*args，k=1和{'name':'tom'}字典传给**kwargs。

2，递归函数

2.0 递归函数的通俗定义：

　　就是函数内使用函数本身。例子如下：

def fun(n):
    print(n)
    if int(n/2)>0:
        return (fun(n/2))

上述代码其实就是递归函数。fun(n)函数里面有调用了fun(n/2)，即函数本身。

在写简单的例子，求10以内的数的乘积。可以使用循环的方法写出。

def sum(x):
    sum1 = 1
    for i in xrange(1,x+1):
        sum1*=i
    print sum1

sum(10)

　　

如果用递归函数写的话：

def sum(x):
    if x==1:
        return 1
    else:
        return x*sum(x-1)

print sum(10)

　　
2.1，递归函数的特点：

1，必须要有1个明确的结束条件。
2，每次进入递归，问题规模要减少，必须向默认结果收敛。
3，效率不要，如果递归层数过多，会导致栈溢出。

2.2，测试递归函数的递归次数

def fun(n):
    n+=1
    print(n)
    return fun(n)
print fun(1)

从输出来的结果999来看，python默认递归的此时应该为999。

小结：

1，定义函数时，如果不确定的参数的个数可以用*args和**kwargs定义。

#*args接受N个位置参数，转换成元祖的形式。如果直接传入元祖，需要使用*号。
'''
def test(*args):
print(args)
test(1,2,3,4,5,5,7)
test(*[1,2,3,4,5,5,7])
'''
#**kwargs 把N个关键字参数（x=?,y=?啥形式的称为关键字参数），转换成字典的形式。如果直接传入字典，则需使用**。
'''
def test2(**kwargs):
print(kwargs)
test2(name='tom',age='30')
test2(**{'name':'tom','age':'30'})
'''

2，递归函数的实质就是函数本身自我的调用，但是必须要有个结束条件，不然就是死循环。这样Python就会报错，最终也可能会导致栈溢出。python默认最多递归为999次。当然，这个得值也是可以修改的。