函数
函数是实现特定功能的代码段的封装,在需要时可以多次调用函数来实现该功能
1. 内置函数
Python内置了许多非常有用的函数,可以直接调用
2. 自定义函数
语法:
def 函数名(形参1,形参2,...):
函数体
注意:
- 函数名可以包含数字、字母、下划线,但不能以数字开头
- 如果函数有返回值,使用return关键字
- 定义函数后函数中的代码并不会执行,需要调用函数才会执行
# 定义函数,使用def
def calc(num1, num2): # 必选参数,也称为位置参数,不能省略
res = num1 + num2
return res
# print(calc(3, 5)) # 调用函数
# 参数类型检查
def my_abs(x):
# 可以为函数添加文档注释,也称为文档字符串doc string
"""
计算绝对值
:param x: 参数
:return: 返回x的绝对值
"""
# 对参数类型进行检查
if not isinstance(x, (int, float)):
raise TypeError('参数类型不正确,只能为数值类型') # 抛出异常
if x >= 0:
return x
else:
return -x
# print(my_abs('aaa'))
# print(help(my_abs))
# 默认参数,即有默认值的参数
def my_pow(x, y=2):
if y == 0:
return 1
res = x
for i in range(y - 1):
res *= x
return res
# print(my_pow(5))
# 可变参数,使用*号,表示参数个数是可变的
def my_sum(x, *y):
print(x)
print(y) # 接收到的实际上是一个tuple
# my_sum(3, 5, 8, 12, 4)
# 不建议下面的这种写法,建议将必选参数放在最前面
def my_sum2(*y, x):
print(y)
print(x)
# my_sum2(12, 4, 2, 7, x=9) # 必选参数在后面时需要指定参数名
# 对于可变参数,可以直接传入list或tuple,只需要在参数前添加一个*
nums = [12, 4, 2, 64, 23, 9]
# my_sum(4, nums[0], nums[1], nums[2], nums[3], nums[4], nums[5])
# my_sum(4, *nums)
# 关键字参数,使用**,也表示参数个数是可变的,但传递的是带名称的参数
def f1(x, **y):
print(x)
print(y) # 接收到的实际上一个dict
# f1(3, a=5, b=9, c=18)
# 对于关键字参数,可以直接传入一个dict,只需要在参数前添加**
user = {'id': 1001, 'name': 'tom', 'age': 18}
# f1(4, id=user['id'], name=user['name'], age=user['age'])
# f1(4, **user)
# 命名关键字参数,限制关键字参数的名字,使用*分隔,*号后面的参数表示命名关键字参数
def f2(x, *, name, age):
print(x)
print(name)
print(age)
# f2(4, name='alice', age=20)
# 接收任意参数
def f3(*args, **kwargs):
print(args)
print(kwargs)
f3(1, 43, 'aaa', name='alice', age=20)
# 空函数,表示以后再实现
def empty():
pass # 使用pass
# 函数的返回值,返回多个值
def f1():
name = ‘tom’
age = 20
sex = ‘male’
return name, age, sex
# print(f1()) # 返回值实际上是一个tuple
a, b, c = f1()
# print(a, b, c)
# 函数的返回值,返回一个函数,即将函数作为返回值
def f2(x):
print(111)
z = 6
def f3(y):
print(x * y + z) # 内部函数使用了外部函数的参数或局部变量,称为闭包
return f3
# fn = f2(3)
# fn(5)
# 递归函数:一个函数在内部调用自身,这个函数就是递归函数
# 计算x的y次方,如计算2的5次方
def calc(x, y):
# 常规方式
# if y == 0:
# return 1
# i = 1
# res = x
# while i < y:
# res *= x
# i += 1
# return res
# 递归方式
# 2*2*2*2*2=2*(2*2*2*2)=2*(2*(2*2*2))=
if y == 0:
return 1
else:
return x * calc(x, y - 1) # 不停的调用自己,递归太深可能会抛出栈溢出异常
print(calc(2, 99999999999999))