python参数类型定义_Python的参数类型
参数类型：
指针变量的定义格式1、必填参数，位置参数(positional arguments，官⽅定义，就是其他语⾔所说的参数)
2、默认值参数，⾮必传
3、可变参数，⾮必传，不限制参数个数，⽐如说给多个⼈发邮件，发邮件的⼈数不确定
4、关键字参数，⾮必传，不限制参数个数，会把传过来的关键字参数，放到⼀个字典⾥⾯，传参的时候必须得⽤k=v这样⼦来传
5、命名关键字参数
1. 位置参数：其他语⾔没有分参数的种类是因为只有这⼀种参数，所有参数都遵循按位置⼀⼀对应的原则。
定义：就是在给函数传参数时，按照顺序，依次传值。
defpower(n,m):
result=1
while n>1:
n= n-1result=result*mreturnresult
res=power(5,3)print(res) #输出结果：81
#解释说明：#函数power(n,m)中有两个参数，m和n，这两个参数都是位置参数，调⽤的时候，传⼊的两个值按照顺序，依次赋值给m和n。
2. 默认值参数：完全等同于C++，引⼊默认参数是为了在某些情境下提供⽅便。
定义：就是在写函数的时候直接给参数传默认的值，调⽤的时候，默认参数已经有值，就可以不⽤再传值了。作⽤：最⼤的好处就是降低调⽤函数的难度。形式: 参数名 = 默认值
def students(name,grade,gender='Male'):print(name,grade,gender)
students('Kitty',3) ##有了默认参数之后，gender这个参数即使不提供 也可以调⽤函数gender被赋了的默认值Male
students('Lily',2,'Famale')#以上输出结果如下：#Kitty 3 Male#Lily 2 Famale
默认参数需要注意的地⽅
a. 默认参数必须在最右端(最后)，这样才能被解释器正确识别，否则会产⽣⼆义性。
def fun(a=10, b): #这⾥会报错：SyntaxError: non-default argument follows default argument
return a +b
fun(10)#⼆义性：这个20究竟是赋值给a的还是b的#⼈都⽆法分辨清楚，解释器就更不⾏了
b. 默认参数⼀定要指向不变对象！
def defaultzero(list = []): #我们的本意是提供的list参数为0时 返回只有⼀个0的list
list.append(0)returnlistprint(defaultzero()) #输出：[0]
print(defaultzero()) #输出：[0, 0] 显然重复调⽤的时候结果不是我们所期望的
#解决⽅案 使⽤None
def defaultzero1(list =None):if list ==None:
list=[]
list.append(0)returnlistprint(defaultzero1()) #输出：[0]
print(defaultzero1()) #输出：[0] 重复调⽤的时候，也输出相同
#这说明list是⼀个对象#事实上Python所有的数据类型其实都是对象
结果说明python解释器会将默认参数作为⼀个公共对象来对待，多次调⽤含有默认参数的函数，就会进⾏多次修改。
因此定义默认参数时⼀定要使⽤不可变对象(int、float、str、tuple)。使⽤可变对象语法上没错，但在逻辑上是不安全的，代码量⾮常⼤时，容易产⽣很难查的bug。
3. 可变参数：Python函数提供了可变参数，来⽅便进⾏参数个数未知时的调⽤。可变参数将以tuple形式传递。
定义：可变参数就是传⼊的参数个数是可变的，可以是0个，1个，2个，……很多个。作⽤：就是可以⼀次给函数传很多的参数特征(格式)：*args  【*参数 (即在参数前加*号)】
def power(*args):
result=0for n inargs:
result=result+n*nreturnresult#调⽤函数1
tupleArray=(1,2,3)#*tupleArray这种⽅式很常见，很重要
print(power(*tupleArray)) #输出结果：14
#调⽤函数2
listArray=[1,2,3]#*listArray这种⽅式很常见，很重要#*listArray表⽰把listArray这个list中所有元素作为可变参数传进去
print(power(*listArray)) #输出结果：14
#调⽤函数3
print(power(1,2,3)) #输出结果：14
请注意: *在C语⾔中是取内容运算符，变量前加该符号意为指针变量，Python中只是⼀个标识符，表⽰将以tuple形式传递，星号本⾝
有”全部的”意思, 两者⽆任何关系，下同。
4. 关键字参数：Python的可变参数以tuple形式传递，⽽关键字参数则是以dict形式传递。 即可变参数传递的是参数值，关键字参数传递的是参数名：参数值键值对。
定义：关键字参数允许你传⼊0个或任意个含参数名的参数，这些关键字参数在函数内部⾃动组装为⼀个dict。在调⽤函数时，可以只传⼊必选参数：
作⽤：扩展函数的功能
特征：**kw  这是惯⽤写法，建议使⽤，容易被理解
def person(name, age, **kw):print('name:', name, 'age:', age, 'other:', kw)#案例⼀：
person('Michael', 30) #输出结果：name: Michael age: 30 other: {}
#案例⼀：
person('Michael', 30, city='Beijing') #输出结果：name: Michael age: 30 other: {'city': 'Beijing'}
#案例三：#定义⼀个字典数据
dictArray = {'city': 'Beijing', 'job': 'Engineer'}#调⽤函数
person('Jack', 24, **dictArray )#输出结果 name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
#解释说明：#**dictArray表⽰把dictArray这个dict的所有key-value⽤关键字参数传⼊到函数的**kw参数，kw将获得⼀个dict。注意kw获得的dict是dictArray的⼀份拷贝，对kw的改动不会影响到函数外的dictArray。
5. 命名关键字参数：Python的命名关键字参数对传⼊的关键字参数做了进⼀步的限制。
定义：例如只接收city和job的参数，其他，不接收。
def person(name, age, *, city, job):
print(name, age, city, job)
作⽤：限制要传⼊的参数的名字，只能传我已命名关键字参数。
特征：命名关键字参数需要⼀个特殊分隔符*，⽽后⾯的参数被视为命名关键字参数。
def personinfo(name, age, *, gender, city): #只能传递gender和city参数
print(name, age, gender, city)
personinfo('Steve', 22, gender = 'male', city = 'shanghai') #输出：Steve 22 male shanghai
关键字参数和命名关键字参数的区别在于，前者可以传递任何名字的参数，⽽后者只能传递*后⾯名字的参数。如果函数定义中已经有了⼀个可变参数，后⾯跟着的命名关键字参数就不再需要⼀个特殊分隔符*了：
def personinfo(name, age, *args, gender, city): #args可以传递⼀个list 其后只能传递gedner和city参数
print(name, age, gender, city, args)
personinfo('Steve', 22, [1,2,3,4],city = 'shanghai',gender = 'male')#输出：Steve 22 male shanghai ([1, 2, 3, 4],)
6. 各种参数之间组合
定义：把以上五种参数组合在⼀起的参数组合
排放顺序：在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)的形式调⽤它，⽆论它的参数是如何定义的。
⼩结
1，Python的函数具有⾮常灵活的参数形态，既可以实现简单的调⽤，⼜可以传⼊⾮常复杂的参数。 2，默认参数⼀定要⽤不可变对象，如果是可变对象，程序运⾏时会有逻辑错误！ 3，要注意定义可变参数和关键字参数的语法： *args是可变参数，args接收的是⼀个tuple；**kw是关键字参数，kw接收的是⼀个dict。4，以及调⽤函数时如何传⼊可变参数和关键字参数的语法： 可变参数既可以直接传⼊：
func(1, 2, 3)，⼜可以先组装list或tuple，再通过*args传⼊：func(*(1, 2, 3))； 关键字参数既可以直接传⼊：func(a=1, b=2)，⼜可以先组装dict，再通过**kw传⼊：func(**{'a': 1, 'b': 2})。5，使⽤*args和**kw是Python的习惯写法，当然也可以⽤其他参数名，但最好使⽤习惯⽤法。6，命名的关键字参数是为了限制调⽤者可以传⼊的参数名，同时可以提供默认值。 7，定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。7，定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。