Python之函数的参数

Python之函数的参数

传参的方式只有两种：位置和关键字。

位置参数在默认参数的左边。

参数是可以是任何数据类型。

可以传递0个或多个参数。

一、形参和实参

实参：函数调用的时候传入的参数值

形参：函数定义的时候，定义的参数名

def mylen(s) 里的s是形参

leng = mylen("adfadsfasfasd") 里的adfasdfasdf是实参

def mylen(s):   #参数的接收
    """
    计算字符串的长度                  ===函数的功能
    参数s：要计算的字符串              ===参数的信息
    :return:返回要计算的字符串的长度    ===返回值的信息
    """
    length = 0
    for i in s:
        length += 1
    return length

# mylen()的括号里可以写参数，这里是参数传入的地方
leng = mylen("1234455666787")
print(leng)

二、位置参数

在调用函数时，传参数：

　　按照位置传参

　　按照关键字传参

在传参的角度：按顺序定义参数　

def my_max(a,b):
    """
    返回两个值之间的最大值
    :return:
    """
    if a > b:
        return a
    else:
        return b
print(my_max(40,3))

关键字参数

def my_max(a,b):
    """
    返回两个值之间的最大值
    :return:
    """
    if a > b:
        return a
    else:
        return b
my_max(a=40,b=1)

def lonin(user,passwd):                       
    if user == "george" and passwd == "123":  
        return True                           
    else:                                     
        return False                          
                                              
ret = lonin('george','13')                    
if ret:                                       
    print('ok')                               
else:                                         
    print('no')                               
                                              

三、默认参数

默认参数可以不传值，但是，如何给默认参数传值，新的值就会覆盖定义好的旧的值。

def login(name,sex = 'male'):                  
    print('name:%s,sex:%s'%(name,sex))         
                                               
login('george')                                

                                                     
def login(name,sex = 'male'):                        
    print('name:%s,sex:%s'%(name,sex))               
                                                     
login('george')                                      
login('george','man')                                
                                                     

s = 'man'                                 
def login(name,sex=s):                    
    print('name:%s,sex:%s'%(name,sex))    
                                          
s='male'  #不影响定义时sex的值                                
login('george')                           

默认参数：首先不要设置可变类型的默认参数

　　　　　　对于变化小额参数可以设置默认参数

　　　　　　默认的参数可以不传，不传的时候用的就是默认值

　　　　　　如果传，就会覆盖默认值

　　　　　　默认值是在定义函数的时候，就已经确定了的。

b = []
def func(a = []): #不要设置可变数据类型的默认参数
    a.append(1)
    print(a)
# func()
# func()
# func()
# func()

# func([])
# func([])
# func([])
# func([])

四、动态参数（*args，**kwargs）

*args：接收列表类型或元组类型

**kwargs：接收字典类型

位置传参，是a和b相加，而args就是一个空的元组。

def func(a,b,*args):        
    print(a,b,args)         
    return a+b              
                            
print(func(3,1))            

同样位置传参，是a和b相加，但是args就是一个有值的元组。

def func(a,b,*args):          
    print(a,b,args)           
    return a+b                
                              
print(func(1,2,3))            
                              

按关键字传参数，c和d是关键字传参kwargs

def dun(a,b,**kwargs):    
    print(a,b,kwargs)     
                          
dun(a=1,b=2,c=333,d=333)  

*args和**kwargs合用

def f(a,b,*args,**kwargs):
    print(a,b,args,kwargs)

f(1,2,3,4,5,6,7,c=1,d=4)

参数的放置位置：位置参数，*args，默认参数，**kwargs

def fun(*args):    # *args代表把散列的元素拼成元组
    print(args)
t = (1,2,3,4)
l = [1,2,3,4]
fun(*t)    # *代表把一个元组、列表拆了
fun(*l)    # *代表把一个元组、列表拆了

def fun(**kwargs):  # **kwargs代表把关键字传来的参数拼成字典
    print(kwargs)

fun(a=1,b=2)  
d={'a':1,'b':2}
fun(**d)      # **kwargs代表把一个字典拆了

参数在调用函数的角度看：

　　1.按照位置传参

　　2.按照关键字传参

　　3.动态传参 *tuple **dic

调用函数的规则：

1.函数名()
    函数名后面+圆括号就是函数的调用。
2.参数：
    圆括号用来接收参数。
    若传入多个参数：
        应按先位置传值，再按关键字传值
        具体的传入顺序应按照函数定义的参数情况而定
3.返回值
    如果函数有返回值，还应该定义“变量”接收返回值
    如果返回值有多个，也可以用多个变量来接收，变量数应和返回值数目一致

无返回值的情况：
函数名()

有返回值的情况：
变量 = 函数名()

多个变量接收多返回值：
变量1，变量2，... = 函数名()

总结：

　　参数：

　　　　实参：调用函数的时候传入的参数。

　　　　形参：定义函数的时候用于接收参数的字母。

　　　　位置参数：必须传值

　　　　　　def test(a,b):

　　　　　　　　print(a,b)

　　　　　　test(1,2)

　　　　默认参数：可以不传值

　　　　　　def test(x=10):

　　　　　　　　print(x)

　　　　　　test()

　　　　　　test(20)

　　　　动态参数：*args，**kwargs　　　　　

　　　　　　*args:

　　　　　　　　def ccc(*args):#1,2,3,4,5
　　　　　　　　　　print(args)

　　　　　　　　ccc(1,2,3,4,5)#按位置传参数

　　　　　　　　t = (1,2,3,4,5)
　　　　　　　　ccc(t) ((1, 2, 3, 4, 5),)
　　　　　　　　ccc(*t) (1, 2, 3, 4, 5)

　　　　　　**kwargs:

　　　　　　　　def ddd(**kwargs):
　　　　　　　　　　print(kwargs)

　　　　　　　　ddd(k = 'a',j = 'b')#按关键字传参数

　　　　　　　　def eee(*args,**kwargs):
　　　　　　　　　　print(args,kwargs)

　　　　　　　　eee(12,123) #先按位置传参，再按关键字传参

　　　　　　　　def ccc(*args):
　　　　　　　　　　print('ccc:',args) #(1,2,3,4,5)
　　　　　　　　def inner(a,b,c,d,e):
　　　　　　　　　　print('inner',a,b,c,d,e)
　　　　　　　　inner(*args) #*(1,2,3,4,5) 打散

　　　　　　　　def inner(a,b,c,d,e):
　　　　　　　　　　print('inner',a,b,c,d,e)
　　　　　　　　ccc(1,2,3,4,5)
　　　　　　　　inner(1,2,3,4,5)

　　　　　　

============================================

函数的形参与实参：

#形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定

#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题：
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型


#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        结果：
            2
            (3, 4, 5)
            3
            {'c': 4, 'd': 5}

　

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

 定义默认参数要牢记一点：默认参数必须指向不变对象！

 *接受列表和元组，**接受字典

小结

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

1、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操作

def modify_file(filename,old,new):
    import os
    with open(filename,'r',encoding='utf-8') as read_f,
        open('.bak.swap','w',encoding='utf-8') as write_f:
        for line in read_f:
            if old in line:
                line=line.replace(old,new)
            write_f.write(line)
    os.remove(filename)
    os.rename('.bak.swap',filename)

modify_file('/Users/George/PycharmProjects/Python/a.txt','George','NB')

2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

def check_str(msg):
    res={
        'num':0,
        'string':0,
        'space':0,
        'other':0,
    }
    for s in msg:
        if s.isdigit():
            res['num']+=1
        elif s.isalpha():
            res['string']+=1
        elif s.isspace():
            res['space']+=1
        else:
            res['other']+=1
    return res

res=check_str('hello name:George passowrd:111')
print(res)

3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。

4、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def func1(seq):
    if len(seq) > 2:
        seq=seq[0:2]
    return seq
print(func1([1,2,3,4]))

5、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

def func2(seq):
    return seq[::2]
print(func2([1,2,3,4,5,6,7]))

6、写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表

def func3(dic):
    d={}
    for k,v in dic.items():
        if len(v) > 2:
            d[k]=v[0:2]
    return d
print(func3({'k1':'abcdef','k2':[1,2,3,4],'k3':('a','b','c')}))