函数的参数

#参数 ： 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)