Python：函数

最新推荐文章于 2025-11-08 12:15:00 发布

原创最新推荐文章于 2025-11-08 12:15:00 发布 · 1k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#python #java #前端

python 专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍了Python中的函数定义、调用规则，包括函数分类（有参/无参、有返回值/无返回值）、参数类型（位置参数、默认值、可变参数、关键字参数等），以及全局变量和局部变量的区别。同时讨论了递归的概念及其在编程中的应用和潜在问题。

前言：

函数就是一个过程、功能、动作，实现一个功能或者某些功能的一个集合。函数是一个功能或者是一个过程，在python中可以将同样的代码封装成一个函数，给这个函数起个名字，下次用到的时候直接调用即可。

一、函数的定义

在python中，定义函数的时候用到def（define function）关键字。

语法结构i：

def 函数名称([参数]):
    #缩进
    函数体
    [return 返回值]

#定义一个取绝对值的函数
def my_abs(x):
    if x < 0:
        return -x
    else:
        return x
print(my_abs(-99))

函数有返回值的情况下会根据实际情况进行返回，如果函数没有返回值，其实也是有返回值的，只是返回的是None

1. 如果要定义一个空函数（暂时没有什么功能）使用关键字pass

2. 函数的参数检查

>>> def my_abs(x):
...     if x < 0:
...         return -x
...     else:
...         return x
...
>>> my_abs(-99)
99
>>> my_abs(-99,99)
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: my_abs() takes 1 positional argument but 2 were given
>>> my_abs("-99")
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "<stdin>", line 2, in my_abs
TypeError: '<' not supported between instances of 'str' and 'int'
>>> abs(-99)
99
>>> abs("-99")
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

#定义一个取绝对值的函数
def my_abs(x):
    if not isinstance(x,(int,float)):
        raise TypeError("bad operand type")
    if x < 0:
        return -x
    else:
        return x
print(my_abs("-99"))

3.返回多个值

import math
def move(x,y,step,sngle=0):
    nx = x + step + math.cos(sngle)
    ny = y + step + math.sin(sngle)
    return nx,ny
print(move(100,100,60,math.pi/6))

总结：函数可以返回多个值，指的是return可以跟多个参数，但是函数本身返回的时候只有一个，是一个元组。

import math
def move(x,y,step,sngle=0):
    nx = x + step + math.cos(sngle)
    ny = y + step + math.sin(sngle)
    return nx,ny
# print(move(100,100,60,math.pi/6))
x,y = move(100,100,60,math.pi/6)
print(x,y)

二、函数的调用

函数名称（[参数]）

>>> abs(99)
99
>>> abs(1,2)
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)
>>> abs("A")
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

函数调用的时候要注意函数参数的个数与函数的类型。

>>> a = abs
>>> a(-99)
99

函数名称其实是指向函数对象的引用，可以把函数名称赋值给一个变量，实则是给函数起了别名。

三、函数的分类

1，以有无参数：有参函数、无参函数

2，是否有返回值：有返回值函数无、返回值函数

3，按定义来分类：系统自定义函数（abs max min）、第三方函数（个人自己定义的公司组织）

四、全局变量和局部变量

全局变量：在python中，定义在py文件中的变量称为全局变量

特点：代码运行的过程中始终有效

name = "zhangsan"

局部变量：定义在函数中的变量称为局部变量

特点：在函数外面是不能访问函数内的变量（局部变量）

name = "zhangsan" #全局变量
def show(msg):
    gender = "男" #局部变量
    print(msg)
    print(gender)
    print(name)
print(gender)
print(name)
show("哈哈哈")
# print(show("哈哈哈"))

print(show("哈哈哈")) ----- 打印结果为None ,因为函数没有return 。反过来说，函数内部是可以访问全局变量，但是不能修改全局变量，如果一定要在函数内修改全局变量的话，需要使用global（全局）关键字，但是不建议这样操作。

name = "zhangsan" #全局变量
age = 18
def show(msg):
    gender = "男" #局部变量
    global age
    age += 1
    print(age)
    print(msg)
    print(gender)
    print(name)
# print(gender)
# print(name)
show("哈哈哈")
# print(show("哈哈哈"))

值传递

def add(x,y):
    return x + y
x = float(input("请输入第一个数："))
y = float(input("请输入第二个数："))
print(add(x,y))

x、y是不是不冲突，add(x,y)中x和y是局部变量（形参），外面的x和y是实参，是把实参传递给了形参引用传递（传递的是对象）。

def info(fn,msg):
    fn()
    print(msg)
def print_msg():
    print("自己定义的函数")
print(print_msg)#代表的内存地址，指向的print_msg本身，代表的函数的本身
print(print_msg())#代表的是函数的返回值，没有返回值，返回的就是None

def info(fn,msg):
    fn()
    print(msg)
def print_msg():
    print("自己定义的函数")
# print(print_msg)#代表的内存地址，指向的print_msg本身，代表的函数的本身
# print(print_msg())#代表的是函数的返回值，没有返回值，返回的就是None
#引用传递
info(print_msg,"哈哈哈哈")

注意：

1，在强数据类型语言中，函数不允许嵌套、包含函数

2，在弱数据类型语言中，函数是可以作为参数，传递到另一个函数中

五、函数的参数

函数的参数（位置参数、默认值参数、命名参数、可变参数、万能参数等）

# 计算圆的周长
def get_circle_cal(r,pi):
    return 2 * pi * r
if __name__ == '__main__':
    r = float(input("请输入圆的半径："))
    cal = get_circle_cal(r,3.14)
    print("半径为{}的圆的周长为{}".format(r,cal))

注意：python中并不是从main函数入口的，python属于脚本语言，从上到下的顺序进行执行，python 中main函数的目的：写在main函数中的代码，不会导入到其他模块中。

5.1 位置参数

def power(x):
    return x * x

对于power(x)，参数x就是一个位置参数。

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

5.2 默认值参数

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

默认值参数就是传递的参数如果没有给参数赋值的情况的，按照默认的情况进行执行函数。

默认值参数必须要写在必选参数的后面，并且有多个默认值参数的情况下，变化比较大的写在前，变化较小的写在后。

def add_end(L=[]):
    L.append("END")
    return L
print(add_end())
print(add_end())
print(add_end())

默认值参数L指向的[]，[] 指的是列表，代码执行的过程中[]是会发生改变的

注意：1，默认值参数一般要指向不可变对象 2，None 是一个不可变对象

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

5.3 可变参数

在python中，可变参数使用*表示。可变参数的意思就是调用函数的时候可以传递参数也可以不传递参数，并且传递的参数个数可以是0个或者1个或者任意个。底层原理是将参数封装为元组进行传递的。

def calc(number):
    sum = 0
    for i in number:
        sum += i * i
    return sum
print(calc((1,2,3,4)))

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

def calc(*number):
    sum = 0
    for i in number:
        sum += i * i
    return sum
print(calc(1,2,3,4,5,6))
print(calc())

def calc(*number):
     sum = 0
     for i in number:
          sum += i * i
     return sum
# print(calc(1,2,3,4,5,6))
# print(calc())
list = [1,2,3,4]
print(calc(list[0],list[1],list[2],list[3]))
print(calc(*list))

5.4 关键字参数

底层是将参数封装为字典进行传递的

传入0个或者任意个参数

def person(name,age,**kw):
    print("name=",name,"age=",age,"other=",kw)
person("zhangsan",18)
person("zhangsan",18,city="Beijing")

用途：扩展函数的功能

def person(name,age,**kw):
    print("name=",name,"age=",age,"other=",kw)
dict = {"city":"chongqing","job":"XXX工程师"}
person("lisi",20,**dict)

5.5 命名关键字参数

*后面的参数就是命名关键字参数，使用*将必选参数和命名关键字参数隔开

如果没有传入命名关键字参数的值就会报错

def person(name,age,*,city,job):
    print("name=",name,"age=",age,"city=",city,"job=",job)
person("zhangsan",18)

def person(name,age,*,city,job):
    print("name=",name,"age=",age,"city=",city,"job=",job)
person("zhangsan",18,city="chongqing",job="XXX工程师")

如果函数中已经有了可变参数了，就不需要使用*,但是可变参数后面的参数依旧是命名关键字参数

def person(name,age,*args,city,job):
    print("name=",name,"age=",age,"city=",city,"job=",job)
person("zhangsan",18,city="chongqing",job="XXX工程师")

如果传递值的时候没有写命名关键字参数的名称的时候会报错，会把传入的参数全部当作必选参数

def person(name,age,*,city,job):
    print("name=",name,"age=",age,"city=",city,"job=",job)
person("zhangsan",18,"chongqing","XXX工程师")

命名关键字参数也可以取默认值，命名关键字参数是可以出现缺省的状态

def person(name,age,*,city="Beijing",job):
    print("name=",name,"age=",age,"city=",city,"job=",job)
person("zhangsan",18,job="XXX工程师")

5.6 参数的组合

顺序：必选参数，默认值参数、可变参数、命名关键字参数、关键字参数

def f1(a,b,c=0,*args,**kw):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
def f2(a,b,c=0,*,d,**kw):
    print("a=",a,"b=",b,"c=",c,"d=",d,"kw=",kw)
f1(1,2)
f1(1,2,c=3)
f1(1,2,3,"a","b")
f1(1,2,3,"a","b",X=99)
f2(1,2,3,d=99,X=88)
args = (1,2,3,4)
kw = {"d":99,"X":88}
f1(*args,**kw)
args1 = (1,2,3)
kw1 = {"d":99,"X":88}
f2(*args1,**kw1)

六、函数的递归

在python中函数里面是可以调用其他函数的，那如果调用的是自己的话就是函数的递归，函数的递归就是函数自己调用自己。

前提条件：

1. 函数自己调用自己

2. 要有终止条件

如果没有终止条件的情况下，就会出现死循环的状态（在python中，会报错）

def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)
print(fact(5))

fact(5)
5 * fact(5-1)
5 * 4 * fact(4-1)
5 * 4 * 3 * fact(3-1)
5 * 4 * 3 * 2 *fact(2-1)
5 * 4 * 3 * 2 * 1

栈溢出的问题 ------- 尾递归优化

尾递归：函数内部自己调用自己，要有终止条件，return语句中不能包含表达式

def fact(n):
    return fact_iter(n,1)
def fact_iter(num,product):
    if num == 1:
        return product
    return fact_iter(num-1,num*product)
print(fact(5))

fact(5)
fact_iter(5,1)
fact_iter(5-1,5*1)
fact_iter(4-1,4*5)
fact_iter(3-1,3*20)
fact_iter(2-1,2*60)

总结：递归优缺点

优点：逻辑简单清晰

缺点：过深的递归会造成栈溢出的问题

python解释器并没有对尾递归做优化，所以在python任何递归都会造成栈溢出的问题。