• 函数的参数


    #参数 : argument(s)
    s = 'I love you, Mia'
    def func(s):  # (自)定义函数,()内即为参数,只需要0个参数即可,用来 :接收参数,也叫“形式参数”,形参
        i = 0 
        for k in s:
            i += 1
        return i
    
    #s = 'I love you, Mia'  # 放这里也可
    print(func(s)) #  传递参数,传参 >> 对func(s)而言
    func1 = func(s) #  传递参数:传参;实际参数,实参
    func1 = func([5,2,0]) # 传递参数,传参
    print(func1) 
    
    # 形参就是“传过去”的实参 !!!如本例中的形参's'就是实参'[5,2,0]'或“ 'I love you, Mia' ”或其他
            

    1:看下面顺序,不要弄混哦!

    # 大方面从上到下执行     
    def f1(l1):   # 1
        for i in l1:  # 5
            print(i)  # 6
    
    def f2(l1):  # 2
        f1(l1)   # 4
        for i in l1: # 7
            print(i) # 8
    
    f2([5,2,0],)  # 3
    
    
    
    def f2(l1):  # 1
        f1(l1)   # 4
        for i in l1:
            print(i)
     
    def f1(l1):  # 2
        for i in l1:
            print(i)
            
    f2([5,2,0])  # 3
    
    
    def f1(l1):
        for i in l1:
            print(i)
            
    def f2(l1):
        for i in l1:
            print(i)
            
    f1([5,2,0])
    f2([5,2,0])

    2:

    参数
       没有参数
            定义函数和调用函数时括号里都不写内容
       有一个参数
            传什么就是什么
       有多个参数
            位置参数

    # 位置参数
    def func(a,b):
        res = a + b
        return res
    
    print(func(1,2))
    sum = func(2,4)
    print(sum)

    站在实参的角度上:
          按照位置传参
          按照关键字传参
          混着用可以:但是 必须先按照位置传参,再按照关键字传参数
          不能给同一个变量传多个值

    站在形参的角度上
          位置参数:必须传,且有几个参数就传几个值
          默认参数: 可以不传,如果不传就是用默认的参数,如果传了就用传的(参数)

    def func(a,b):
        res = a + b
        return res
    
    sum = func(2,b=4)  # 两者都按关键字传参,或先按位置传参再按关键字传参
    print(sum)

    def lover(name,sex): print('%s:%s' % (name,sex)) lover('Mia','Female') lover('Shaw','Male')

    def lover(name,sex = 'Female'): # sex = 'Female' 是默认参数(必须第一个定义位置参数) print('%s:%s' % (name,sex)) lover('Mia') lover('Mia','Female') lover('Mia',sex = 'Famale') lover(name = 'Mia') lover('Lee') lover('Lee','Male')

    只有调用函数的时候
          按照位置传 : 直接写参数的值
          按照关键字: 关键字 = 值(加引号)

    定义函数的时候:
           位置参数 : 直接定义参数
           默认参数,关键字参数 :参数名 = '默认的值'
           动态参数 : 可以接受任意多个参数
           参数名之前加*,习惯参数名args,
           参数名之前加**,习惯参数名kwargs
           顺序:位置参数,*args,默认参数,**kwargs

     动态参数有两种:可以接受任意个参数

          *args : 接收的是按照位置传参的值,组织成一个元组

          **kwargs: 接受的是按照关键字传参的值,组织成一个字典

    # 定义函数中的“动态参数”
    def func(*args):  # 加“*”使args(也可以是其他的如ment等等,但习惯用这个)这个参数变为“动态参数”
        n = 0
        for i in args:
            n += i
        print(n)
    
    func(1,2)
    func(1,2,3)
    func(1,2,3,4)
    func(5,2,0)
    
    
    
    def sum(*args):
        n = 0
        for i in args:
            n += i
        return n  # 注意必须有“n”!!!
    
    print(sum(5,2,0))
    print(sum(1,2,3))
    
    
    
    
    def sum(*args):
        n = 0
        for i in args:
            n += i
        return n  # 注意必须有“n”!!!
    
    print(sum(5,2,0))
    print(sum(1,2,3))
    
    
    
    
    def func(*args): 
        print(args)
        
    func(5,2,0,'lover',['hair','red'])
    
    
    
    
    def func(**kwargs):
        print(kwargs)
    
    func(Mia = 'Fairy')
    func(Chen = 'Cutie')
    func(We = 18)
    
    
    
    
    def func(*args,**kwargs):  # 前面只能是*args,后面才是**args
        print(args,kwargs)
    
    func(5,2,0,age = 18,Mia = 'Fairy')  # 如此例,必须是位置参数在前,关键字参数在后
    
    
    
    def func(a,*args,default = 2,**kwargs):
        print(args,kwargs)
    
    func(5,2,0,default = 4,Mia = 'Fairy')
    
    
    
    # 动态传参的另一种传参方式
    def func(*args):  # 站在形参的角度上,给变量加上*,就是组合所有传来的值
        print(args)
    
    func(5,2,0)
    l = [5,2,0]
    func(l[0],l[1],l[2])
    func(*l)  # 站在实参的角度上,给一个序列加上*,就是将这个序列按照顺序打散
    
    
    
    def func(**kwargs):
        print(kwargs)
        
    func(Mia = 'beauty',Chen = 'cutie')
    dic = {'Mia':'beauty','Chen' : 'cutie','age':18}
    func(**dic)
    
    
    
    # 函数的注释
    def func():
        '''
        这个函数实现了什么功能
        参数1:
        参数2:
        return返回的是什么
        '''
        pass

    3:默认函数的陷阱

     如果默认参数的值是一个可变数据类型,
    那么每一次调用函数的时候
    如果不传值就公用这个数据类型的资源

    # 默认函数的陷阱
    def func(li = []):  # 括号内是默认参数
        li.append(1)
        print(li)
    func()
    func([])
    func()
    func()
    
    
    def func(dic = {}):
        dic['k'] = 'v'
        print(dic)
    func()
    func()
    func()
    func()
    # 不断覆盖
    
    
    def func(k,dic = {}):
        dic['k'] = 'v'
        print(dic)
    func(1)
    func(2)
    func(3)
    func(4)
    
    
    def func(k,dic = {}):
        dic[k] = 'v'
        print(dic)
    func(1)
    func(2)
    func(3)
    func(4)

    作者:chauncylii

    出处:https://www.cnblogs.com/passengerlee/p/11965398.html

    版权:本文采用「署名-非商业性使用-相同方式共享 4.0 国际」知识共享许可协议进行许可。

    觉得文章不错,点个关注呗!

  • 相关阅读:
    四则运算 2
    《你的灯亮着吗》读后感 (前两篇)
    四则运算设计思路
    读书目标
    课堂总结
    人月神话感想
    软件工程概论11
    软件工程概论10
    bnu——GCD SUM (莫比乌斯反演)
    POJ1108_Split Windows 解题报告
  • 原文地址:https://www.cnblogs.com/passengerlee/p/10344289.html
Copyright © 2020-2023  润新知