文章目录

• 调用函数
• 定义函数
• • 格式
  • 导入函数
  • 占位符与类型检查
  • 关于多个返回值
• 函数的参数
• • 位置参数
  • 默认参数
  • 可变参数
  • • 情况1：
    • 情况2
  • 关键字参数
  • 命名关键字参数
  • • 情况1：使用分隔符分割
    • 情况2：使用可变参数分割
  • 递归函数

调用函数

Python本身就提供了很多函数直接调用，需要匹配正确的参数，如果输入的参数错误，会在错误提示中告诉你。

例如，绝对值函数，取最值函数，强制类型转换函数等。

>>> abs(-100)
100
>>> max(-1,2,3,4)
4
>>> int(12.56)
12

Python支持通过别名的方式调用函数：

>>> i=int
>>> i(12.56)
12

定义函数

格式

使用def语句定义，def后面接函数名，括号，括号中的参数以及冒号。例如，求绝对值函数：

def my_abs(x):
    if x>=0:
        return x
    else:
        return -x

注意：python中冒号的使用，不要少东西

与其他语句相同，执行到return 语句就返回，停止执行。没有return，则返回值为none。

导入函数

可以从py文件中导入函数来使用，例如

from input_output import my_abs;#此处的input_output是文件名，my_abs()是函数名
print(my_abs(-99))

占位符与类型检查

因为python中没有大括号的存在，可以使用pass作为占位符，构造空函数

def nop():#什么也不执行
	pass

因为python定义变量时没有类型，因此没有参数检查。写一个完善的函数，就需要自己做参数检查。

def my_abs(x):
    if not isinstance(x,(int, float)):
        raise TypeError("not this type")#做一个参数类型检查，如果参数类型不对，提示错误信息
    if x>=0:
        return x
    else:
        return -x

关于多个返回值

Python函数可以return 多个值，格式是在return时使用,隔开。多个返回值会以tuple的形式返回。

def mult_return(x):
    a=x+2
    return x-1,x+1,a    
print(mult_return(5))

运行结果：

(4, 6, 7)

函数的参数

位置参数

在正常情况下，python的函数参数是按，定义时的顺序传入：

例如：

def power(x,y):#计算x的y次方，依次读入x和y作为参数
    sum=1
    while y>0:
        sum*=x
        y-=1
    return sum
print(power(2,3))

运行结果：

8

默认参数

可以在传入参数时设定一个参数的值，这样可以在调用时少传入一个参数

例如：

def power3(x,y=3):# y的默认值是3
    sum=1
    for i in range(y):
        sum*=x
        # print("第%d轮\n" %i)
    return sum
print(power3(9,1))#带入两个参数，此时y的取值被覆盖
print(power3(9))#带入一个参数，y取默认值3

运行结果：

9
729

注意：在python中，函数中的参数并不是c++中的形参，而是一个变量。因此，如果讲函数参数设为可变的，那就会出问题。

例如：

def my_func(L=[]):
    L.append('zcc')
    return L
print(my_func())
print(my_func())

运行结果：

['zcc']
['zcc', 'zcc']

这是由于，作为参数的L被修改了。因此，默认参数必须指向不变对象

例如，将上面的程序进行修改，使L等于不变对象none

def  my_func2(L=None):
    if L is None:
        L=[]
        L.append('zcc')
    return L
print(my_func2())
print(my_func2())

运行结果：

['zcc']
['zcc']

这样就保证每次输出的结果都一样了

注：不变对象：tuple,str,None

可变参数

用法类似于C++的数组作为函数参数，在传入参数数量不确定时使用。

情况1：

正常定义一个参数即可，传入时传入一个tuple或者list

def my_func3(L):
    sum = 0 #注：sum是一个内置的变量名，最好不要用这个
    for i in L:
        sum += i
    return sum
L=[1,2,3,5]
print(my_func3(L)) #将L作为参数传入

但是，此时想直接传入几个变量就不行了

例如：

print(my_func3(1,2,3,4))

就会报错，因为默认一个参数。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBlzcKfK-1631074952721)(C:\Users\26741\AppData\Roaming\Typora\typora-user-images\image-20210902103833246.png)]

因此需要先组合成list或者tuple

print(my_func3((1,2,3,4))

情况2

利用可变参数，相当于自动把传入的参数组合成tuple。免去自己组合的麻烦。这个方法有点像C语言中的取指针

def my_func4(*l1):
    sum1 = 0
    for i in l1:
        sum1 += i
    return sum1


L=(1,2,3,4)
print(my_func4(1,2,3,4))
print(my_func4(*L)) #在list或者tuple变量名前面加一个*即可

若想在可变参数中使用list或者tuple作为变量，可以直接传入。

运行结果：

10
10

关键字参数

关键词参数的变量类型必须是dict。可以是传入参数的时候作为一个key-value键值对传入，也可以就直接将一个dict变量集合传入。这种函数传递参数的方式，可以获得额外的变量值。

def my_func5(name, age, **kw):
    print('name', name, 'age', age, 'other', kw)


my_func5('Bob', 12, city='Beijing', country='China')#此处的city='Beijing'，就是以键值对形式传入
info={'city': 'tianjin', 'college': 'hebut'}
my_func5('zcc', 22, **info)#想直接将dict传入需要加**

输出结果

name Bob age 12 other {'city': 'Beijing', 'country': 'China'}
name zcc age 22 other {'city': 'tianjin', 'college': 'hebut'}

注：关键字函数传入的是一个拷贝，所以在针对关键字函数作出修改之后，不会对原来造成影响。

命名关键字参数

可以传入任意数量的参数，但是只接受想要的参数。原理就是中间用一个可变参数接受多余的变量。所有的命名关键字必须以键值对的形式插入，不能没有。缺一个都会报错

情况1：使用分隔符分割

def my_func6(name, age, *, city, school):
    print('name:', name, 'age:', age, 'city', city, 'school', school)


my_func6('zcc', 22, city='baoding', school='hebut')
my_func6('zcc', 22, school='hebut', city='baoding')

这种情况下，* 后面被视为命名关键字，输入参数数量与函数定义必须数量一致。但，* 后面只要所有的命名都有，顺序可以不一致。

运行结果：

name: zcc age: 22 city baoding school hebut
name: zcc age: 22 city baoding school hebut

情况2：使用可变参数分割

def my_func7(name, age, *args, city, school):
    print('name:', name, 'age:', age, 'city', city, 'school', school)


my_func7('zcc', 22, 1, 1, city='baoding', school='hebut')

这种情况下，中间多余的参数会被可变参数吃掉。但是可变参数后面不能再有多余的参数。

虽然python中可以定义多种函数，但是调用的时候必须遵照必选参数，默认参数，可变参数，命名关键字参数和关键字参数的顺序。

递归函数

调用自身的函数，通过栈实现。

def my_func7(n):
    if(n == 1):
        return 1
    else:
        return n * my_func7(n - 1)

print(my_func7(5))

由于栈的大小有限，因此没完没了的递归。会造成栈溢出。可以使用尾递归的方式解决。即：函数本身的返回语句不包括表达式，这样就不会占用多余的栈了。

def fact(n):
    return fact1(n, 1)

def fact1(num , product):
    if(num == 1):
        return product #已经算到了最后一步
    else:
        return fact1(num-1, product * num) #乘以当前的数


print(fact(5))

不用让栈等着参数被计算，而是直接计算完。类似于循环。