python函数—函数的参数+递归函数

函数的参数

def abs(x):
    if not isinstance(x,(int,float)):
        raise TypeError('类型错误')
    if x < 0:
        return -x
    else :
        return x

if __name__ == '__main__':
    print(abs('str'))

默认参数

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

if __name__ == '__main__':
    print(power(5,1))
    print(power(5))
# 5 
# 25

默认参数可以简化函数的调用。设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后，否则Python的解释器会报错（默认参数不能放在必选参数前面：报错 ，构造函数没有必要默认值 因为每次都要输入两个）；
二是如何设置默认参数。
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
使用默认参数好处：最大的好处是能降低调用函数的难度。

def student(name,age):
    print('name:',name)
    print('age:',age)

# 增加维度 默认值就可以派上用场
def teacher(name,age,city='beijing'):
    print('name:', name)
    print('age:', age)
    print('city:',city)

def school(name='gduf',loc='guangzhou'):
    print('name:',name)
    print('loc:',loc)

if __name__ == '__main__':
    student('cznczai',10)
    #name: cznczai
    #age: 10
    teacher('czn',20)
    #name: czn
    #age: 20
    #city: beijing
    #一个参数风骚设值 如下        
    school(loc='qingyuan')
    #name: gduf
    #loc: qingyuan
#也可以传入一个空参 全输出默认值

注意事项！！！

默认参数是[]，但是函数似乎每次都“记住了”上次添加了'END'后的list。

def add_end(L=[]):
    L.append('END')
    return L
print(add_end())
print(add_end())
print(add_end())
#['END']
#['END', 'END']
#['END', 'END', 'END']

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。 变量【默认】不比常量可控制性强 慎重~！！！
可以用None这个不变对象来实现上面的代码 这样就不会变了

def add_end(L=None):
    if L == None:
        L = []
    L.append('END')
    return L
print(add_end())
print(add_end())
print(add_end())
#['END']
#['END']
#['END']

可变参数 ：也就是参数的数量可以发生改变

不可变参数 多个参数传入需要用一个list 或者 tuple保存

可变参数

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

print(calc(1, 2, 3))
print(calc(1, 3, 5, 7))
#14
#84
### 可变参数调用list 或 tuple,*nums表示把nums这个list的所有元素作为可变参数传进去
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

num = [1 , 2 ,4 ]
print(calc(num[0], num[1], num[2]))
print(calc(*num))
#21

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

# 函数person除了必选参数name和age外，还接受关键字参数kw。
# 在调用该函数时，可以只传入必选参数,也可以传入多个或者一个参数组装成可变参数
def student(name , age , **kw):          # 仅允许传入一个 **kw
    print('name:',name,'age:',age,'other',kw)

student('czn','20',city = 'jieyang',school='gduf')
#name: czn age: 20 other {'city': 'jieyang', 'school': 'gduf'}

它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求 good

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
检查是否有city'和job参数：

def person(name, age, **kw):
    if 'city' in kw:
        print(" city in kw")
    if 'job' in kw:
        print( 'job in kw')
    print('name:', name, 'age:', age, 'other:', kw)

person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)

命名关键字的用法如下：

def function(name ,age , * , addr , school):       
#def function(name ,age , * , addr='gz' , school='school'):  #  调用时为默认               
    print(name, age , addr , school)
# 必须要传入参数 参数名必须定义的名字  不能传入其他,     定义可以传入默认值    

# * 星号后面是命名关键字  分隔符 而不是作为一个参数 而且不能省略  如果省略了 python不法辨别是位置参数 还是命名关键字
# 关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
if __name__ == '__main__':
#    function('sprint', '2', 'gz ', 'gduf')     #TypeError: function() takes 2 positional arguments but 4 were given
#    function('sprint','2' ,addr='gz', school='gduf') # sprint 2 gz gduf
#    function('sprint','2' ,addr='gz', school='gduf',height=20) #TypeError: function() got an unexpected keyword argument 'height'
    function('sprint','2' ,addr='gz',height =10 , area = 20) #function() got an unexpected keyword argument 'height'
    function('sprint','2',school='gduf' ,addr='gz')  #不会报错 位置参数 还是命名关键字 的区别

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

• 虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

小结

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。

• 默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
• 要注意定义可变参数和关键字参数的语法

1. *args是可变参数，args接收的是一个tuple；
2. **kw是关键字参数，kw接收的是一个dict。
   1.以及调用函数时如何传入可变参数和关键字参数的语法：

• 可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；
• 关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({'a': 1, 'b': 2})。
• 使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
• 命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
• 定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

递归函数

一个函数在内部调用自身本身

def first_func(n):
    if(n==1):
       return n
    else :
       return n+first_func(n-1)
if __name__ == '__main__':
    print(first_func(100))

由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

小结

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。
针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。
Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。