python re match第一个 python第一个参数

转载

桃太郎 2024-02-21 22:02:22

文章标签 python re match第一个 ci 默认参数可变参数 文章分类 Python 后端开发

函数的参数

位置参数

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

扩展知识

引言

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