Python初学第四天函数之函数的参数

最新推荐文章于 2023-03-07 09:30:00 发布

熊猫憨憨

最新推荐文章于 2023-03-07 09:30:00 发布

阅读量627

点赞数 1

本文链接：https://blog.csdn.net/qq_40193347/article/details/104739739

版权

函数的参数

位置参数

对于函数 power() ，参数 x 就是一个位置参数，当我们调用函数 power() 时，必须传入有且仅有一个参数x

def power(x):
    return x * x

如果函数有两个以上的位置参数时，调用函数时，传入的值按照位置顺序依次赋给位置参数。

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

默认参数

在进行函数定义时，可以设定参数的默认值，如果没有对该参数进行赋值，则该参数将取其默认值。

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

此时，当我们调用power(5) 时，相当于调用 power(5, 2)

注意

在进行默认参数的设置时，注意以下几点：

1.严格遵守"必选参数在前，默认参数在后” 的规则

因为函数参数在传入时，是按照顺序来的，如果默认参数放在前面， def power(n=2, x): , 调用 power(5) 时，会按顺序将值赋给参数，首先将 5 赋给 n,然后轮到 x 时发现参数个数不对，报错，而对于 power(x, n=2): , 则相反，先将 5 赋给 x,然后轮到n 时，由于没有n有默认值2，且没有值传入，则n取默认值2

2.设置默认参数时，默认将变化大的参数放在前面，变化小的参数放在后面，这样变化小的参数就能够更多地使用默认参数

3.默认参数必须指向不可变对象，如果指向可变对象，如list

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

调用多次默认参数时，发现函数每次都把上次添加了**‘END’** 之后的list 当做这次的默认值

>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

因为在定义函数时，已经确定 L 这个变量指向了对象 [] ,而在该函数中，对L自身进行了改动，[]作为一个可变对象，调用函数时被改变了，而 L 依旧指向这个被改变了的 list ，所以函数的默认参数的内容也被改变。

如果要避免出现这种情况，则需要将默认参数设置为一个不可变对象，如 None，然后通过判断默认参数是否等于None，来给L赋值 []

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

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

优点

使用默认参数，能降低调用函数的难度。

默认参数调用格式

以下面的代码为例：

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)

age 和 city 为默认参数。
调用 enroll(‘Bob’, ‘M’, 7) 时，按照顺序传入值，7 传给了 age ，而 city 使用默认值
也可以不按照顺序提供部分默认参数，但是必须将参数名写上：enroll(‘Adam’, ‘M’, city=‘Tianjin’)

可变参数

可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。
由于参数个数不确定，可以使用一个list 或者 tuple 作为参数

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

但是在调用时，需要先组装出一个list 或 tuple

但是设定可变参数，可以简化这一步骤

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

调用函数时，就需要这么写

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数.

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以使用 list[0], 也可以在list前加一个*, 如calc(*nums)。

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

*nums 表示把 nums 这个list的所有元素作为可变参数传递进去。

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

关键字参数

关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数实际上在函数内部组装成一个dict

对于 * 号的作用，进行了分析

>>> a=(1,2,3,4)
>>> b=[1,2,3,4]
>>> print(*a)
1 2 3 4
>>> print(*b)
1 2 3 4
>>>

这里可以看到， * 号可以将一个list 或者 tuple 转变为多个参数

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

调用如下

>>> person('Michael', 30)
name: Michael age: 30 other: {}

关键字参数的个数没有要求。

与可变参数类似，也可以直接将一个dict传入函数，但是在该dict前需要加两个星号 ** ，或者按照dict内元素调用的方法。
加 **

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

dict 元素调用 dict[key]

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

extra表示把extra这个dict的所有key-value用关键字参数传入到函数的 **kw 参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的 extra。

命名关键字

如果要限制关键字参数的名字，就可以使用命名关键字参数。如只接受 city 和 job 作为关键字参数

def person(name, age, *, city, job):
    print(name, age, city, job)

此时，只能接受 city 和 job 作为关键字参数，如果有别的关键字参数传入，则会报错，获得了一个不希望得到的关键字。

>>> person(1,2,city=1,j=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() got an unexpected keyword argument 'j'
>>> person(1,2,city=1,job=2)
1 2 1 2

如果函数定义中已经有了一个可变参数，则后面跟着的命名关键字参数就不需要加特殊分隔符 *

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

对于没有加可变参数的，提示位置参数只需要两个但是给了4个

>>> def person(name, age, *, city, job):
...     print(name, age, city, job)
...
>>>
>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

加了可变参数的，提示丢失了两个必须的命名关键字参数

>>> 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 <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'

命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

由于命名关键字参数city具有默认值，调用时，可不传入city参数：

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个作为特殊分隔符。如果缺少，Python解释器将无法识别位置参数和命名关键字参数：

参数组合顺序

参数定义的顺序必须为：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。即参数传入时的格式相同，可有可无的放后面，必选和默认都是可以直接传入单个参数，而默认可以为空，所以优先传入必选，而默认和可变参数传入时的格式一个为单个单数，另一个为任意个数参数。后者的范围更大，所以可变参数放后面，关键字参数的表达形式与他们都不同，但是关键字参数的范围比命名关键字参数大，所以放在最后。

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)
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种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

扩展知识

转自 https://www.qingsword.com/qing/python-12.html

引言

在Python中，星号除了用于乘法数值运算和幂运算外，还有一种特殊的用法"在变量前添加单个星号或两个星号"，实现多参数的传入或变量的拆解。

简介

最初，星号变量是用在函数的参数传递上的，在下面的实例中，单个星号代表这个位置接收任意多个非关键字参数，在函数的*b位置上将其转化成元组，而双星号代表这个位置接收任意多个关键字参数，在**b位置上将其转化成字典：

#!/usr/bin/env python
#coding=utf-8
#--------
def one(a,*b):
    """a是一个普通传入参数，*b是一个非关键字星号参数"""
    print(b)
one(1,2,3,4,5,6)
#--------
def two(a=1,**b):
    """a是一个普通关键字参数，**b是一个关键字双星号参数"""
    print(b)
two(a=1,b=2,c=3,d=4,e=5,f=6)
#程序输出
(2, 3, 4, 5, 6)
{'b': 2, 'c': 3, 'e': 5, 'f': 6, 'd': 4}
 
#从输出中可以看到，第一个函数中，*b的位置可以传入任意多没有关键字的参数，*b会将这些传入参数转化成一个元组，下面的调用
one(1,2,3,4,5,6)
#传入one(a,*b)后，等价于
one(1,(2,3,4,5,6))
 
#第二个函数中，**b的位置可以接收任意多个关键字参数，下面的调用
two(a=1,b=2,c=3,d=4,e=5,f=6)
#传入one(a,*b)后，等价与
two(a=1,{'b': 2, 'c': 3, 'e': 5, 'f': 6, 'd': 4})

扩展用法

单星号变量实例

单星号变量不仅仅可以用在函数定义时的参数中，如果在一个普通变量前加*，会将该变量拆分为单个元素

>>> a=(1,2,3,4)
>>> b=[1,2,3,4]
>>> print(*a)
1 2 3 4
>>> print(*b)
1 2 3 4
>>>

>>>def one(*x):
	'''输出传入的第一个参数'''
>>>   print(x[0])
#------
>>>lst = ["a","b","c","d"]
>>>stri = "www.baidu.com"
>>>one(stri,lst)
www.baidu.com
>>>one(*lst)
a
>>>one(stri)
w

#第一次调用one(stri,lst)，代入one(*x)后等价与
one(("www.qingsword.com",["a","b","c","d"]))
 
#第二次调用one(*lst)，代入one(*x)后等价与
one(("a","b","c","d"))

#第三次调用one(*stri)，代入one(*x)后等价与
one(("w","w","w",".","q","i","n","g","s","w","o","r","d",".","c","o","m"))

如果在变量前面使用单星号，实际上是对变量的一次拆解操作，将变量中单独的元素拆解出来，然后依次传入one()函数，而传入one()函数后，one()函数会将这些传入的单个元素保存成一个元组，这就是为什么我们 print(x[0])能够提取第一个元素的原因
如果传入的为字典元素，那么输出的时候只会有字典元素的键，而不包含值，如果想要读取值，需要使用双星号

双星号变量实例

#!/usr/bin/env python
#coding=utf-8
03
#--------
def one(**x):
    """将传入的关键字参数的值保存成元组输出"""
    print(x)
    b=()
    for a in x.values():
        b+=(a,)
    print(b)
     
dect={"one":1,"two":2,"three":3}
one(**dect)

#程序输出
{'three': 3, 'one': 1, 'two': 2}
(3, 1, 2)
 
#对一个字典使用双星号前缀，就相当于将其拆分成关键字参数的形式，**dect相当于将字典拆分成下面这种样子
one=1,two=2,three=3
 
#将上面这些关键字参数传入one(**x)，就等价与（还记得前面说的，双星号将接收到的所有关键字参数都保存成一个字典吧）
one({"one":1,"two":2,"three":3})
 
#既然是字典，那么字典中的所有方法都能使用，使用for循环遍历这个字典的值，添加到一个元组中，最后打印出这个元组

Ps：注意，使用这种方法将字典传入函数的时候，字典的键的命名要符合python变量的命名规则，通过上面的分析也不难看出，双星号会将字典首先转换成关键字参数的形式，就相当于使用字典中的键作为变量名，如果键不符合变量命名规则，则会抛出一个"TypeError"异常，大家可以尝试着颠倒一下上面字典中的键和值，使用数字作为键，看看会出现什么问题。

练习

以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：

# -*- coding: utf-8 -*-

def product(*x):
   if not x:
      raise TypeError("x doesn't exist")
   m = 1
   for v in x:
      m = m * v		
   return m

# 测试
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('测试成功!')

小结

1.默认参数一定要选用不可变对象，如果使用可变对象，程序运行会有逻辑错误

2.在定义函数时，单星号意味着将多个元素组成一个tuple传入，在调用函数时，使用的单星号意味着对变量进行一次拆解操作，将单独的元素拆解出来。

3.定义函数时，双星号意味着接收到的所有关键字参数保存在一个字典里传入，调用函数时在字典前加双星号意味着将该字典拆解为关键字参数。

4.默认 *args 为可变参数，接受的是一个tuple， **kw 是关键字参数，kw接受的是一个字典

5.可变参数可以直接传入，也可以在一个list或者tuple前加* 传入。

6.关键字参数可以直接传入，也可以在一个dict前加**传入

7.命名关键字参数限制了传入的关键字，同时也可以提供默认值，命名关键字参数前需要加星号再用分隔符逗号分割开来或者在其之前有可变参数

熊猫憨憨

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Python初学第四天函数之函数的参数

函数的参数位置参数对于函数 power() ，参数 x 就是一个位置参数，当我们调用函数 power() 时，必须传入有且仅有一个参数xdef power(x): return x * x如果函数有两个以上的位置参数时，调用函数时，传入的值按照位置顺序依次赋给位置参数。def power(x, n): s = 1 while n > 0: ...
复制链接

扫一扫