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 = '***g',school='gduf')
#name: czn age: 20 other {'city': '***g', '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的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
- 默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
- 要注意定义可变参数和关键字参数的语法
- *args是可变参数，args接收的是一个tuple；
- **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标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。
字节跳动公司氛围 560人发布