Python函数、参数、参数解构

Python函数详解

最新推荐文章于 2025-07-31 15:58:19 发布

原创最新推荐文章于 2025-07-31 15:58:19 发布 · 807 阅读

3 ·

CC 4.0 BY-SA版权

本文深入讲解Python函数的概念，包括数学定义、函数定义、调用、参数传递、可变参数、关键字参数、缺省值、可变位置参数、可变关键字参数等，以及参数规则和结构的实践应用。

Python函数

函数

数学定义

y=f(x)，y是x的函数，x是自变量。y=f(x0,x1,…xn)

Python函数

由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元
完成一定的功能

函数的作用

结构化变成对代码的最基本的封装，一般按照功能组织一段代码
封装的目的为了复用，减少冗余代码
代码更加简介美观、可读易懂

函数的分类

内建函数，如max()、reversed()等
库函数，如math、ceil()等
自定义函数，使用def关键字定义

函数定义

def 函数名(参数列表):
	函数体(代码块)
	[return 返回值]

函数名就是标识符，命名要求一样
语句块必须缩进，约定4个空格
Python的函数若没有return语句，会隐式返回一个None值
定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参

函数调用

函数定义，只是声明了一个函数，它不能被执行，需要调用执行
调用的方式，就是函数名后加上小括号，如有必要在括号内填上参数
调用时写的参数是实际参数，是实实在在传入的值，简称实参

def add(x, y): # 函数定义
	result = x + y # 函数体
	return result # 返回值

out = add(4, 5) # 函数调用，可能有返回值，使用变量接收这个返回值
print(out) # print函数加上括号也是调用

上面代码解释：

定义一个函数add，及函数名是add，接受2个参数
该函数计算的结果，通过返回值返回，需要return语句
调用时，通过函数名add后加2个参数，返回值可使用变量接受。
函数名也是标识符，返回值也是值
定义需要在调用前
函数是可调用的对象，如callable()

函数参数

函数在定义是要约定好形式参数，调用时也提供足够的十级参数，一般来说，形参和实参个数要一致（可变参数除外）

传参方式

位置传参

定义时def f(x,y,z)，调用使用f(1,3,5)，按照参数定义顺序传入实参

关键字传参

定义时def f(x,y,z)，调用使用f(x=1, y=3, z= 5)，使用形参的名字来传入实参的方式，如果使用了形参名字，那么传参顺序就可和定义顺序不同
要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的

def f(x, y, z):
	pass

f(z=None, y=10, x=[1])
f((1,), z=6, y=4.1)
f(y=5, z=6, 2) #错误传参

参数缺省值

缺省值也称为默认值，可以在函数定义时，为形参增加一个缺省值。其作用：

参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值
参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用
可在定义缺省值时，将不常修改的缺省值放在其他缺省值后

def add(x=4, y=5):
	return x+y

测试调用:

#用print()测一下输出结果是多少
add()			9
add(x=5)		10
add(y=7)		11
add(6, 10)		16
(add(6, y=7)	13
add(x=5, y=6)	11
add(y=5, x=6)	11
add(x=5, 6)		#SyntaxError
add(y=8, 4)		#SyntaxError
add(8, x=4)		#TypeError

def add(x, y=5)，这样可以定义
def add(x=4, y)，这样定义会报错SyntaxError

# 定义一个函数login，参数名称为lost、port、username、password
def login(host='192.168.1.1', port='8080', username='luqx',password='luqx'):
    print('{}:{}@{}/{}'.format(host, port, username, password))

login()
login('127,0,0,1', 80, 'tom', 'tom')
login('127.0.0.1', port=80, password='com')
login('localhost', port=80, password='com')
login(port=80, password='magedu', host='www')

输出结果

192.168.1.1:8080@luqx/luqx
127,0,0,1:80@tom/tom
127.0.0.1:80@luqx/com
localhost:80@luqx/com
www:80@luqx/magedu

可变参数

需求：写一个函数，可以对多个数累加求和

def sum(iterable):
    sum = 0
    for x in iterable:
        sum += x
    return sum

print(sum([1,2,5]))
print(sum(range(4)))

输出结果

8
6

上例，传入可迭代对象，并累加每一个元素
也可以使用可变参数完成上面的参数

def sum(*nums):
    sum = 0
    for x in nums:
        sum += x
    return sum

9
6

可变位置参数

在形参前使用 * 表示该形参是可变位置参数，可以接受多个实参
它将收集来的实参组织到一个tuple中

可变关键字参数

在形参前使用 ** 表示该形参是可变关键字参数，可以接受多个关键字参数
它将收集来的实参的名称和值，组织到一个dict中

def showconfig(**kwargs):
    for k, v in kwargs.items():
        print("{}={}".format(k,v), end=',')

showconfig(host='192.168.1.1', port=8080, username='tom', password='tom')

输出结果

host=192.168.1.1,port=8080,username=tom,password=tom,

总结

有可变位置参数和可变关键字参数
可变位置参数在形参前使用一个星号 *
可变关键字参数在形参前使用两个星号 **
可变位置参数和可变关键字参数都可以收集若干个实参,可变位置参数收集形成一个tuple，可变关键字参数收集形成一个dict
混合使用参数的时候，普通参数需要放到参数列表前面，可变参数要放到参数列表的后面，可变位置参数需要在可变关键字参数之前
例:

def fn(x, y, *args, **kwargs):
    print(x, y, args, kwargs, sep='\n', end='\n\n')

fn(3, 5, 7, 9, 10, a=1, b='abc')
fn(3, 5)
fn(3, 5, 7)
fn(3, 5, a=1, b='abc')
fn(x=3, y=8, 97, a=1, b='abc') # 错误传参，位置传参必须在关键字传参之前
fn(7, 9, y=5, x=3, a=1, b='abc') # 错误传参，7、9已按位置传参，y=5，x=3有重复传参

keywoed-only 参数

在Python3之后，新增了keyword-only参数
keywoed-only参数：在形参定义时，在一个*星号之后，或一个可变位置参数之后，出现的普通参数，就已经不是普通的参数了，称为keyword-only参数

def fn(*args,x):
    print(x, args, sep='\n', end'\n\n')

fn(3, 5) # 传参有误
fn(3, 5, 7) # 传参有误
fn(3, 5, x=7)

keyword-only参数，言下之意就是这个参数必须采用关键字传参
可以认为，上例中，args可变位置参数已经获取了所有位置参数，其后的变量x不可能通过位置传参传入了
思考：def fn(**kwargs, x) 可以吗?

def fn(**kwargs, x):
	print(x, kwargs, sep='\m', end='\n\n')

这样传参会直接报语法错误
可以认为，kwargs会截取所有关键字传参，就算写了x=5，x也没有机会得到这个值，所以这种语法不存在
keyword-only参数另一种形式

星号后所有的普通参数都称为了keyword-only参数

def fn(*, x, y):
	print(x, y)

fn(x=6, y=7)
fn(y=8, x=9)

参数的混合使用

可变位置参数、keyword-only参数、缺省值

def fn(*args, x=5):
    print(x)
    print(args)

fn() # 等价于fn(x=5) # 返回值 5 ()
fn(5) # 返回值 5 (5,)
fn(x=6) # 6 ()
fn(1, 2, 3, x=10) 10 (1, 2, 3)

普通参数、可变位置参数、keyword-only参数、缺省值

def fn(y, *args, x=5):
    print("x={}, y={}".format(x, y))
    print(args)
fn() # 错误传参 y未传参
fn(5)  
fn(5, 8)
fn(x=6) # 错误传参
fn(1, 2, 3, x=10)  
fn(y=17, 2, 3, x= 10) # 错误传参，关键字传参不允许在位置传参前
fn(1, 2, y=3, x=10) # 错误传参，y已经有赋值1，y=3重复传参

普通参数、缺省值、可变位置参数

def fn(x=5, **kwargs ):
    print("x={}".format(x))
    print(kwargs)
fn()				x=5		{}
fn(5)				x=5		{}
fn(x=6)				x=6		{}
fn(y=3, x=10)		x=10	{'y': 3}
fn(3, y=10)			x=3		{'y': 10}
fn(y=3, z=20)		x=5		{'y': 3, 'z': 20}

参数规则

参数列表参数一般顺序是：普通参数、缺省参数、可变位置参数、keyword-only参数（可带缺省值）、可变关键字参数
注意：
代码应该易读易懂，而不是为难别人
请按照书写习惯定义函数参数

def fn(x, y, z=3, *args, m=4, n, **kwargs):
    print(x, y, z, m ,n)
    print(args)
    print(kwargs)

def connect(host='localhost', port='3306', user='tom',password='tom',**kwargs):
    print(host, port)
    print(user, password)
    print(kwargs)
connect(db='cmdb')
connect(host='192.168.1.123', db='cmdb')
connect(host='192.168.1.123', db='cmdb',password='mysql')

输出结果:

localhost 3306
tom tom
{'db': 'cmdb'}
192.168.1.123 3306
tom tom
{'db': 'cmdb'}
192.168.1.123 3306
tom mysql
{'db': 'cmdb'}

定义最常用参数为普通参数，可不提供缺省值，必须由用户提供，注意这些参数的顺序，最常用的先定义
必须使用名称的才能使用的参数，定义为keyword-only，要求必须使用关键字传参
如果函数有很多参数，无法逐一定义，可使用可变参数。如果需要知道这些参数的意义，则使用可变关键字参数收集

参数结构

def add(x, y):
    print(x, y)
    return x +y

add(4, 5)
add((4, 5)) # 传参错误,只传了一个参数(4, 5)
t = 4, 5
add(t[0], t[1])
# 将参数结构，分为两个参数
add(*t)
add(*(4, 5))
add(*[4, 5])
add(*{4, 5})
add(*range(4, 6))

结果都为4, 5

add(*{'a':100, 'b':11}) #结果为 a	b 等价于 a,b
add(**{'a':10, 'b':11}) # 错误，**为结构成关键字传参，定义的函数中形参并没有a，b
add(**{'x':10, 'y':11})	结果为10	11 等价于,x=10,y=11

在给函数提供实参的时候，可以在可迭代对象前使用* 或者 ** 来进行结构的解构，提取出其中所有元素作为函数的实参
使用 * 解构成位置传参
使用 ** 解构成关键字传参
提取出来的元素数目要和参数的要求匹配

def add(*iterable):
    result = 0
    for x in iterable:
        result += x
    print(result)

add(1, 2, 3)	# 6
add(*[1, 3, 5])	# 9
add(*range(5))	#10

练习

1、编写一个函数，能够接受至少2个参数，返回最小值和最大值
2、完成一个函数，可以接受输入的多个数，每一次都能返回到目前为止的最大值、最小值

答案

第一题答案

def select(x,y,*args):
    print(x, y, args)
    return max(x, y, *args), min(x, y, *args)

import random
print(*select(*[random.randint(10,20) for i in range(random.randint(2, 10))]))

解析：利用max与min函数求极值，利用random.randint生成随机数，利用 * 结构可迭代对象

第二题答案

def double_values():
    max_ = min_ = None
    while True:
        x = input('>>>')
        nums = [int(c) for c in x.replace(',', ' ').split()]
        if not nums:
            continue
        if max_ is None:
            max_ = min_ = nums[0]
        max_ = max(max_, *nums)
        min_ = min(min_, *nums)
        print(max_, min_)

double_values()