函数定义

函数定义

返回首页

  函数定义:使用函数最基本的意义就是解决代码复用问题,解决代码冗余,解决代码可维护性差的问题。

  函数的写法: 

def test():  #定义函数名,括号里可以加参数,arg1,arg2用“,”分隔开。
    """
    函数的基本描述信息
    :return:
    """
    print('hello world !')  #这是函数的实现功能代码
   return 1   #return返回值,后面可以跟任何数据类型。
test() #这是调用函数  这是无参函数,所以调用时也不参

 

  空函数:设计程序功能函数,用pass代替函数体。

def test():
    pass

 

  函数的参数:括号里有值的,叫有参函数,没值的,叫无参函数。

  无参函数:就是一些普通的语句。完全不依赖外部传入的值,就可以运行的函数,就是无参函数。 

def print_line():
    print("#"*13)

def print_msg():
    print("hello world !")
# 这就是无参函数

 

  有参函数:就是依赖外部传入的值,才可以调用的函数,就是有参函数。最为直观的就是函数名括号里有值。

  有参函数,在定义时有参数,那么在调用时,就需要传入对应的参数。 ret = test(1,5) 是函数调用的表达式形式。

def test(x,y):
    print("from test")
   res
= x+y #将x和y的结果赋给res return res #return返回的res是函数test的结果。 ret = test(1,5) #test函数定义时有参,调用时需要传参,test函数会拿到return的返回值,将返回值赋给一个变量ret,就可以打印结果了 print(ret)

 

  函数的返回值:有三种情况,一种是无参函数。一种是返回一个值。还有一种是返回多个值。

  注意:函数只能执行一个return的返回值。只要执行一个return,函数就执行完了。

  无参函数不需要写return。返回一个值的,就是函数定义里面return返回的1,也可以返回多个值,因为return可以返回任何数据类型

  无参函数返回值:

def test():
    """
    不写返回值的情况,结果是None。
    :return:
    """
    print('from the test')

res = test()
print(res)  #打印结果是None。也算是有返回值的。

  有参函数返回一个值:

def test(x,y):
    """
    有返回值的情况, 返回结果
    :param x:
    :param y:
    :return:
    """
    res=x if x>y else y
    return res

res = test(1,4)
print(res)

  有参函数返回多个值:因为return可以返回任何数据类型。返回多个值是以元组的形式。

def test(x,y):
    """
    return可以返回任何数据类型
    :param x:
    :param y:
    :return:
    """
    return 1,2,3,[1,2],{'a':1},{1,2,3}

res = test(1,2)
print(res)
res1,res2,res3,res4,res5,res6 = test(1,2) #这样就可以打印return返回的多个值
print(res1,res2,res3,res4,res5,res6)

 

  函数的实参和形参:实参是调用函数时,传入的参数。形参是定义函数时,定义的参数。

  形参就好比是变量名,实参就好比是变量明确的值。在实参传值给形参时,就是按参数位置传参。1传给x,5传给y。

  注意:实参的数据类型要用不可变的数据类型,有数字,元组,字符串。

  实参在函数调用使用后失效。

def test(x,y):   #函数定义阶段,括号里的参数是形式参数
    print(x)
    print(y)

test(1,5)     #调用函数时,括号内加的参数是实际参数

  在实参中,还有一种赋值方法,就是按关键字传值。在传参中,直接赋予变量值。

def test(x,y):   #函数定义阶段,括号里的参数是形式参数
    print(x)
    print(y)
test(x=3,y=4)  #直接在传参中,赋予变量值。
test(y=7,x=8)

  当然,关键字参数和位置参数可以混用。

  注意:混用的注意事项是位置参数必须在关键字参数前面。

def test(x,y):   #函数定义阶段,括号里的参数是形式参数
    print(x)
    print(y)

test(1,y=2)     #调用函数时,括号内加的参数是实际参数
##### 问题一:按位置传值必须在按关键字传值的前面
 test(y=2,1)  #报错,因为关键字参数在位置参数前面

  对于参数,不能重复赋值。

def test(x,y):   #函数定义阶段,括号里的参数是形式参数
    print(x)
    print(y)

test(1,x=1,y=2)  #这就是对参数x多次赋值。会报错。

   可变数据类型会改变原有的实参参数。这样操作会有副作用,他会改变全局变量。也就会导致可控性很差。(不推荐使用可变数据类型)

def test(x,y):   #函数定义阶段,括号里的参数是形式参数
    print(x)
    x.append(4)
    print(y)

a = [1,2,3]  #可变数据类型
b = 6
test(a,b)
print(a,b)

 

  注意:

    形参角度:

      一、位置参数:必须传值的参数,并且形参定义几个参数,就要传几个参数,传多或传少都不行。

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

# foo(1)   #传少报错
# foo(1,2,3) #传多报错
foo(y=2,x=1)

      二、默认参数:形参定义好的参数,在传值时,对于定义好的参数可以不传值,如果传值,新值会覆盖定义好的默认值。

def foo(x,y=1):  #默认参数定义好y=1,那么在传参数时,对于y就可以不传
    print(x)
    print(y)

foo(1)  #只传一个值,按位置给x,但结果依旧是1,1。
foo(1,2) #传两个值,按位置y的实参会覆盖默认的y=1,结果是1,2
foo(y=2,x=2)  #按关键字传值,y的默认值也会被实参覆盖

      注意:默认参数必须在位置参数后面。

#默认参数必须注意的问题是:默认参数必须放到位置参数的后面
def register(sex='male',name): #报错 name 应该在sex前面
    print("name:", name)
    print("sex:", sex)
register('george')

  

  可变参数:*args,**kwargs。

   *args:当位置参数传入多余的值,就交给*args处理,并且将这些多余的值,存成元组的形式。

def foo(x,*args): #args=(2, 3, 4, 5, 6, 6, 'a', 'b')
    print(x)
    print(args)

foo(1,2,3,4,5,6,6,'a','b')

  样例:应用*args。

#sum求和函数
def test_sum(*args):
    res = 0
    for i in args:
        res+=i
    return res

print(test_sum(1,2,3,4,5))

  注意: *args 与位置参数和默认参数混用方式,是 *args 要放到位置参数后面。

def foo(x,*args,y=1):  # *args在位置参数后面
    print(x)
    print(y)
    print(args)

foo(1,2,3,4,5,6,7,8,9,10,y=10000000)

 

  **kwargs:当关键字传值传入多余的值,就交给**kwargs处理,并且将这些多余的值,存成字典的形式。

def foo(x,**kwargs):
    print(x)
    print(kwargs)

foo(1,y=1,z=2)

  如果函数foo()的参数是1,2,3,4,并且都有位置参数接收,那么**kwargs的结果就是一个空字典。 

  问题:当位置参数和*args以及**kwargs混用的时候。会出现位置参数后的值赋给*args处理,处理成元组。而之后的关键字参数会交给**kwargs处理,处理成字典。

def foo(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)

foo(1,2,3,4,5,y=1,z=2)

 

  *args和**kwargs的最终使用方式:位置参数的实参交给*args处理,关键字参数的实参交给**kwargs处理。

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

foo(1,1,1,1,1,1,a=1,b=2)

 

   *args和**kwargs的应用:

def auth(name,password,sex='male'):
    print(name)
    print(password)
    print(sex)

def foo(*args,**kwargs): #args=('george','123') kwargs={}
    print('from foo')
    auth(*args,**kwargs)
    # auth(*'george','123'),   ###**{})--->auth('george','123')

foo('george','123')
foo(1,2,3,4,x=5,y=6)  #报错
foo('george','456',sex='female')
foo(name='george',password='789',sex='female')

 

 

------------- END --------------

posted @ 2020-08-01 23:07  王先生是胖子  阅读(452)  评论(0编辑  收藏  举报