锐客网

  1. 首页 > 睿知 > it技术 > >

python函数参数无限 python函数参数为函数

IT技术参数

python 函数参数类型 python 的函数参数类型分为4种：
1.位置参数：调用函数时根据函数定义的参数位置来传递参数，位置参数也可以叫做必要参数，函数调用时必须要传的参数 。
当参数满足函数必要参数传参的条件，函数能够正常执行：
add(1,2)#两个参数的顺序必须一一对应，且少一个参数都不可以
当我们运行上面的程序,输出:
当函数需要两个必要参数 ， 但是调用函数只给了一个参数时 ， 程序会抛出异常
add(1)
当我们运行上面的程序,输出：
当函数需要两个必要参数，但是调用函数只给了三个参数时，程序会抛出异常
add(1,2,3)
当我们运行上面的程序,输出
2.关键字参数：用于函数调用 ， 通过“键-值”形式加以指定 。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求 。
add(1,2) # 这种方式传参，必须按顺序传参：x对应1，y对应:2
add(y=2,x=1) #以关健字方式传入参数（可以不按顺序）
正确的调用方式
add(x=1, y=2)
add(y=2, x=1)
add(1, y=2)
以上调用方式都是允许的，能够正常执行
错误的调用方式
add(x=1, 2)
add(y=2, 1)
以上调用都会抛出SyntaxError 异常
上面例子可以看出：有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序的
3.默认参数：用于定义函数 ， 为参数提供默认值，调用函数时可传可不传该默认参数的值，所有位置参数必须出现在默认参数前，包括函数定义和调用，有多个默认参数时 ， 调用的时候，既可以按顺序提供默认参数，也可以不按顺序提供部分默认参数 。当不按顺序提供部分默认参数时，需要把参数名写上
默认参数的函数定义
上面示例第一个是正确的定义位置参数的方式 ， 第二个是错误的，因为位置参数在前 ， 默认参数在后
def add1(x=1,y) 的定义会抛出如下异常
默认参数的函数调用
注意：定义默认参数默认参数最好不要定义为可变对象，容易掉坑
不可变对象：该对象所指向的内存中的值不能被改变，int,string,float,tuple
可变对象 ， 该对象所指向的内存中的值可以被改变，dict,list
这里只要理解一下这个概念就行或者自行百度，后续会写相关的专题文章讲解
举一个简单示例
4.可变参数区别:定义函数时，有时候我们不确定调用的时候会多少个参数,j就可以使用可变参数
可变参数主要有两类：
*args: (positional argument) 允许任意数量的可选位置参数(参数),将被分配给一个元组, 参数名前带* ， args只是约定俗成的变量名，可以替换其他名称
**kwargs：(keyword argument) 允许任意数量的可选关键字参数，,将被分配给一个字典，参数名前带**，kwargs只是约定俗成的变量名，可以替换其他名称
*args 的用法
args 是用来传递一个非键值对的可变数量的参数列表给函数
语法是使用 符号的数量可变的参数; 按照惯例,通常是使用arg这个单词，args相当于一个变量名 ， 可以自己定义的
在上面的程序中,我们使用* args作为一个可变长度参数列表传递给add()函数 。在函数中,我们有一个循环实现传递的参数计算和输出结果 。
还可以直接传递列表或者数组的方式传递参数,以数组或者列表方式传递参数名前面加（*） 号
理解* * kwargs
**kwargs 允许你将不定长度的键值对, 作为参数传递给函数，这些关键字参数在函数内部自动组装为一个dict
下篇详细讲解 *args, **kwargs 的参数传递和使用敬请关注
在python中bits=struct.pack('L',1234) ， bits是什么结果？struct.pack这个函数的参数是无限的
第一个参数是定义打包的格式
第二个参数开始，所有参数都是要打包的内容～
而第一个格式参数的具体写法参见下表：
Formatc TypePythonNote
xpad byteno value
ccharstring of length 1
bsignedcharinteger
Bunsignedcharinteger
?_Boolbool(1)
hshortinteger
Hunsignedshortinteger
iintinteger
Iunsignedintinteger or long
llonginteger
Lunsignedlonglong
qlonglonglong(2)
Qunsignedlonglonglong(2)
ffloatfloat
ddoublefloat
schar[]string
pchar[]string
Pvoid*long
还有相应的大/小端的问题：
@nativenative
=nativestandard
little-endianstandard
big-endianstandard
!network (= big-endian)standard
大/小端标记可以省略，貌似默认是小端
你的例子中，L表示无符号的长整形值
所以按你的写法打包出来的就应该是一个小端的无符号长整型数据
python的函数可以定义参数不限定数量def hanshu(*a):
return a
print(hanshu(1,2))
输出(1,2)
print(hanshu(1,2,3,4,5,6))
输出(1,2,3,4,5,6)
print(hanshu('a','b','c'))
输出('a','b','c')
注意python函数参数无限：这里a会自动生成元组python函数参数无限 ， 不是列表 。
Python参数类型 上一期python函数参数无限我们学习参数传递怎么传递python函数参数无限，也python函数参数无限了解了参数python函数参数无限的几种类型 。
首先，我们再来回顾一下，形参和实参:
形参是在定义函数时定义的，放在函数名后面的圆括号里,可为空
实参是调用函数时为形参传入具体的参数值
简单总结一下 ， 谁调用函数，谁就负责传入参数 。
好呐，本期我们来详细学习函数几种参数类型，大纲如下：
python函数的参数名是无意义的 ， Python允许在调用函数时通过通过名字来传入参数值 。
位置参数：按照形参位置传入的参数
调用函数时，实参默认按位置顺序传递的 。同时实参个数也要和形参匹配
举一个小栗子
如果实参的个数与形参不匹配时 ， 调用函数运行就会报错
Python中，形参与调用函数紧密联系在一起的 。
关键字参数：调用函数时，使形参名称来传递参数 ， 形式为“形参名=实参”
关键字参数，又叫命名参数，传递时无需考虑参数位置和顺序
举一个小栗子
默认参数：定义函数时 ， 我们可以为形参提前设置具体的值 。
在定义函数时，默认参数要放到位置等其python函数参数无限他参数后面
在调用函数时，默认参数是可选的 。如果传入新值，则会覆盖默认值
举一个小栗子
注意 ， 默认值不能位于位置参数前面，否则程序会报错误
不定长参数又名可变参数 。
不定长参数指的是可变数量的参数，分两种情况：
如果不定长参数后面，可以新增参数吗？
我们通过例子来看,会发生什么？
运行上面的程序，Python解释器会报错
原因是，形参a已经是不定长参数，我们调用的test(2,3,4)传入的三个实参,系统自动把它们属于形参a的值，形参b 和形参c就等于没有值传入 ， 这时候系统就认为，调用函数的对象，参数没有传够 。
为了解决这一报错，python引入了 强制命名参数
规定，调用不定参数后面有跟位置参数的函数时 ， 传入给位置参数时，必须要强制命名参进行传参 。
逆向参数收集针对的对象传入函数的实参
调用函数时，如果实参是元组，列表或者字典，通过在实参前面加入星号，可以自动把元素进行隔开，然后再转入给函数进行处理
举一个小栗子
本期 ， 我们详细学习了参数几种类型，为后面我们学习函数，打好基础 。
实践是检验真理的过程，大家多动手练习练习 ， 会有不一样的奇妙旅程~
好呐，以上是本期内容，欢迎大佬们评论区指正~
请问这个python脚本哪里出错了？打印出一个无限循环的数定义函数的时候 ， 我们把参数的名字和位置确定下来，函数的接口定义就完成了 。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解 。
Python的函数定义非常简单，但灵活度却非常大 。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数 ， 使得函数定义出来的接口 ， 不但能处理复杂的参数，还可以简化调用者的代码 。
位置参数
我们先写一个计算x2的函数：
def power(x):
return x * x
对于power(x)函数，参数x就是一个位置参数 。
当我们调用power函数时，必须传入有且仅有的一个参数x：
power(5)25 power(15)225
现在，如果我们要计算x3怎么办？可以再定义一个power3函数，但是如果要计算x4、x5……怎么办？我们不可能定义无限多个函数 。
你也许想到了，可以把power(x)修改为power(x, n)，用来计算xn，说干就干：
def power(x, n):
s = 1
while n0:
n = n - 1
s = s * xreturn s
对于这个修改后的power(x, n)函数，可以计算任意n次方：
power(5, 2)25 power(5, 3)125
修改后的power(x, n)函数有两个参数：x和n ， 这两个参数都是位置参数 ， 调用函数时，传入的两个值按照位置顺序依次赋给参数x和n 。
默认参数
新的power(x, n)函数定义没有问题，但是 ， 旧的调用代码失败了 ， 原因是我们增加了一个参数，导致旧的代码因为缺少一个参数而无法正常调用：
power(5)
Traceback (most recent call last):
File "stdin", line 1, in moduleTypeError: power() missing 1 required positional argument: 'n'
Python的错误信息很明确：调用函数power()缺少了一个位置参数n 。
这个时候，默认参数就排上用场了 。由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：
def power(x, n=2):
s = 1
while n0:
n = n - 1
s = s * xreturn s
这样，当我们调用power(5)时，相当于调用power(5, 2)：
power(5)25 power(5, 2)25
而对于n2的其他情况，就必须明确地传入n，比如power(5, 3) 。
从上面的例子可以看出 ， 默认参数可以简化函数的调用 。设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后 ， 否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数 。
当函数有多个参数时 ， 把变化大的参数放前面，变化小的参数放后面 。变化小的参数就可以作为默认参数 。
使用默认参数有什么好处？最大的好处是能降低调用函数的难度 。
举个例子，我们写个一年级小学生注册的函数，需要传入name和gender两个参数：
def enroll(name, gender):
print('name:', name)
print('gender:', gender)
这样，调用enroll()函数只需要传入两个参数：
enroll('Sarah', 'F')
name: Sarah
gender: F
如果要继续传入年龄、城市等信息怎么办？这样会使得调用函数的复杂度大大增加 。
我们可以把年龄和城市设为默认参数：
def enroll(name, gender, age=6, city='Beijing'):
【python函数参数无限 python函数参数为函数】print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
这样 ， 大多数学生注册时不需要提供年龄和城市 ， 只提供必须的两个参数：
enroll('Sarah', 'F')
name: Sarah
gender: F
age: 6city: Beijing
只有与默认参数不符的学生才需要提供额外的信息：
enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')
可见 ， 默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现 。无论是简单调用还是复杂调用，函数只需要定义一个 。
有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如调用enroll('Bob', 'M', 7)，意思是 ， 除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值 。
也可以不按顺序提供部分默认参数 。当不按顺序提供部分默认参数时，需要把参数名写上 。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值 。
默认参数很有用，但使用不当，也会掉坑里 。默认参数有个最大的坑 ， 演示如下：
先定义一个函数，传入一个list ， 添加一个END再返回：
def add_end(L=[]):
L.append('END')return L
当你正常调用时，结果似乎不错：
add_end([1, 2, 3])[1, 2, 3, 'END'] add_end(['x', 'y', 'z'])['x', 'y', 'z', 'END']
当你使用默认参数调用时，一开始结果也是对的：
add_end()['END']
但是，再次调用add_end()时，结果就不对了：
add_end()['END', 'END'] add_end()['END', 'END', 'END']
很多初学者很疑惑，默认参数是[]，但是函数似乎每次都“记住了”上次添加了'END'后的list 。
原因解释如下：
Python函数在定义的时候 ， 默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了 。
定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用None这个不变对象来实现：
def add_end(L=None):
if L is None:
L = []
L.append('END')return L
现在，无论调用多少次，都不会有问题：
add_end()['END'] add_end()['END']
为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建 ， 对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误 。此外，由于对象不变，多任务环境下同时读取对象不需要加锁 ， 同时读一点问题都没有 。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象 。
可变参数
在Python函数中，还可以定义可变参数 。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个 。
我们以数学题为例子，给定一组数字a，b，c……，请计算a2b2c2…… 。
要定义出这个函数，我们必须确定输入的参数 。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：
def calc(numbers):
sum = 0
for n in numbers:
sum = sumn * nreturn sum
但是调用的时候，需要先组装出一个list或tuple：
calc([1, 2, 3])14 calc((1, 3, 5, 7))84
如果利用可变参数 ， 调用函数的方式可以简化成这样：
calc(1, 2, 3)14 calc(1, 3, 5, 7)84
所以，我们把函数的参数改为可变参数：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sumn * nreturn sum
定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号 。在函数内部 ， 参数numbers接收到的是一个tuple，因此，函数代码完全不变 。但是，调用该函数时，可以传入任意个参数 ， 包括0个参数：
calc(1, 2)5 calc()0
如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：
nums = [1, 2, 3] calc(nums[0], nums[1], nums[2])14
这种写法当然是可行的，问题是太繁琐 ， 所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：
nums = [1, 2, 3] calc(*nums)14
*nums表示把nums这个list的所有元素作为可变参数传进去 。这种写法相当有用，而且很常见 。
关键字参数
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple 。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict 。请看示例：
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
函数person除了必选参数name和age外，还接受关键字参数kw 。在调用该函数时，可以只传入必选参数：
person('Michael', 30)
name: Michael age: 30 other: {}
也可以传入任意个数的关键字参数：
person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'} person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
关键字参数有什么用？它可以扩展函数的功能 。比如，在person函数里，我们保证能接收到name和age这两个参数 ， 但是，如果调用者愿意提供更多的参数 ， 我们也能收到 。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求 。
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
extra = {'city': 'Beijing', 'job': 'Engineer'} person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
当然，上面复杂的调用可以用简化的写法：
extra = {'city': 'Beijing', 'job': 'Engineer'} person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict ， 注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra 。
命名关键字参数
对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数 。至于到底传入了哪些 ， 就需要在函数内部通过kw检查 。
仍以person()函数为例，我们希望检查是否有city和job参数：
def person(name, age, **kw):
if 'city' in kw:# 有city参数
pass
if 'job' in kw:# 有job参数
pass
print('name:', name, 'age:', age, 'other:', kw)
但是调用者仍可以传入不受限制的关键字参数：
person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数 。这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数 。
调用方式如下：
person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名，这和位置参数不同 。如果没有传入参数名 ， 调用将报错：
person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
File "stdin", line 1, in moduleTypeError: person() takes 2 positional arguments but 4 were given
由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数 。
命名关键字参数可以有缺省值，从而简化调用：
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
由于命名关键字参数city具有默认值，调用时，可不传入city参数：
person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer
使用命名关键字参数时 ， 要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符 。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：
def person(name, age, city, job):
# 缺少 *，city和job被视为位置参数
pass
参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用 。但是请注意 ， 参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数 。
比如定义一个函数，包含上述若干种参数：
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)
在函数调用的时候 ， Python解释器自动按照参数位置和参数名把对应的参数传进去 。
f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {} f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {} f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {} f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99} f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
最神奇的是通过一个tuple和dict，你也可以调用上述函数：
args = (1, 2, 3, 4) kw = {'d': 99, 'x': '#'} f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'} args = (1, 2, 3) kw = {'d': 88, 'x': '#'} f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的 。
虽然可以组合多达5种参数 ， 但不要同时使用太多的组合，否则函数接口的可理解性很差 。
练习
以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：
# -*- coding: utf-8 -*-
# 测试
print('product(5) =', product(5))
print('product(5, 6) =', product(5, 6))
print('product(5, 6, 7) =', product(5, 6, 7))
print('product(5, 6, 7, 9) =', product(5, 6, 7, 9))
if product(5) != 5:
print('测试失败!')
elif product(5, 6) != 30:
print('测试失败!')
elif product(5, 6, 7) != 210:
print('测试失败!')
elif product(5, 6, 7, 9) != 1890:
print('测试失败!')
else:
try:
product()
print('测试失败!')
except TypeError:
print('测试成功!')
Run
关于python函数参数无限和python函数参数为函数的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：如何搭建聚合服务器？ 聚合服务器怎么搭建

    下一篇：网络上的游戏兼职，网络游戏兼职一天3小时,99元,现结