Python教程

Python函数

本文主要是介绍Python函数,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

文章目录

  • 调用函数
  • 定义函数
    • 格式
    • 导入函数
    • 占位符与类型检查
    • 关于多个返回值
  • 函数的参数
    • 位置参数
    • 默认参数
    • 可变参数
      • 情况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))

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

这篇关于Python函数的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!