zoukankan      html  css  js  c++  java
  • 函数的参数

    #参数 : 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 国际」知识共享许可协议进行许可。

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

  • 相关阅读:
    HDU 2844 Coins(多重背包)
    HDU 4540 威威猫系列故事——打地鼠(DP)
    Codeforces Round #236 (Div. 2)
    FZU 2140 Forever 0.5
    HDU 1171 Big Event in HDU(DP)
    HDU 1160 FatMouse's Speed(DP)
    ZOJ 3490 String Successor
    ZOJ 3609 Modular Inverse
    ZOJ 3603 Draw Something Cheat
    ZOJ 3705 Applications
  • 原文地址:https://www.cnblogs.com/passengerlee/p/10344289.html
Copyright © 2011-2022 走看看