#函数参数

# 位置参数
# 计算一个数的平方
def power(x):
    return x*x

# 计算一个数的n次方
def powers(x,n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

#默认参数
# 必选参数在前面，默认参数在后面
# 多个参数时：变化大的参数在前面，变化小的参数在后面。
def powerA(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
# 学生注册函数
def eroll(name, gender):
    print('name:',name)
    print('gender:',gender)
eroll('Sarah','F')
# name: Sarah
# gender: F
#上面的函数 继续传入 年龄，城市信息
def erollA(name, gender, age = 6, city = 'Beijing'):
    print('name:',name)
    print('gender:',gender)
    print('age:',age)
    print('city:',city)

erollA('Tim','A')
# name: Tim
# gender: A
# age: 6
# city: Beijing

erollA('Bob','M',7)
# 不按照 默认参数顺序传入，直接写上对应参数名
erollA('Adam','M',city='Tianjin')

#默认参数的坑
# 在传入list 后面加上 END
def add_end(L=[]):
    L.append('END')
    return L

#abc =  add_end([1,2,3])#[1, 2, 3, 'END']
add_end()
add_end()#['END', 'END']
#连续调用两次 add_end() 函数后， 会出现不正确的结果
# 因此，默认参数必须是不可变对象

#上面的函数 优化一下
def add_endA(L=None):
    if L is None:
        L = []
    L.append('END')
    return L
# 这下无论调用多少次都不会出问题了


# 可变参数
# 允许你传入 0 个或者任意个参数
# 给定一组数字，a, b, c .... 计算 a^2 + b^2 + c^2 + ,,,,,,
def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
jkj = calc([1,2,3,4])#30
jkj = calc([1,3,5,7])#84

# 把上面的函数修改为可变参数
def calcA(*numbers):# numbers 相当于 tuple
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
calcA(1,2)#5
calcA()#0

nums = [1,2,3]
calcA(*nums)# 可以在 list tuple 前面加上*号，当做可变参数传入
nums = (1,2,3)
calcA(*nums)



# 关键字参数
# 允许你传入 0 个 或者人一个含参数名的参数， 这些关键字参数在函数内部自动组装成一个dict
def person(name, age, **kw):
    print('name:',name,'age:',age,'other:',kw)

# 只传入必选参数
person('Michael', 30)#name: Michael age: 30 other: {}
#传入任意个数的关键字参数
person('Bob',35,city='Beijing')#name: Bob age: 35 other: {'city': 'Beijing'}

#也可以先组装成一个dict 然后把该dict 转换为关键字传进去
extra = {'city':'Beijing','Job':'Engineer'}
person('Jack',24,**extra)#name: Jack age: 24 other: {'city': 'Beijing', 'Job': 'Engineer'}
# 函数内对 extra 的拷贝 进行处理， 不会影响到 extra本身

#命名关键字参数
def personY(name, age, **kw):
    if 'city' in kw:
        #说明有 city 参数
        pass
    if 'job' in kw:
        # 说明有job参数
        pass
    print('name:',name, 'age:',age,'other:',kw)
# 调用者可以传入不受限制的关键字参数
personY('Jack',24,city = 'Beijing', addr = 'Chaoyang',zipcode=123456)
# name: Jack age: 24 other: {'city': 'Beijing', 'addr': 'Chaoyang', 'zipcode': 123456}

# 限制关键字参数的名字 需要用到 * 号， * 号 后面的参数被视为命名关键字参数
# 所有参数都必须传入， 不然会报错
# 关键字参数必须传入参数名字
def personX(name, age, * ,city, job):
    print(name, age, city, job)
personX('Jack',24,city = 'Beijing',job='Enginner')

# 如果函数中有一个可变参数， 后面跟着的命名参数不需要 * 来分隔了
def personZ(name, age, *args, city, job):
    print(name, age, args, city, job)
personZ('Jack',24,city='Beijing',job='Enginner')

#命名关键字 缺省
def personT(name, age, *  , city='Beijing',job):
    print(name,age,city,job)
personT('Jack',24,job='Enginner')

#参数组合， 顺序为 必选参数，默认参数，可变参数，关键字参数，命名关键字参数
def f1(a, b, c = 0, *args, **kwargs):
    print('a = ',a,'b = ',b, 'c = ',c, 'args = ',args, 'kargs = ',kwargs )

def f2(a,b,c=0,*,d,**kwargs):
    print('a = ',a, 'b =  ',b, 'c = ',c, 'd = ',d, 'kwargs = ',kwargs)

f1(1,2)
#a =  1 b =  2 c =  0 args =  () kargs =  {}
f1(1,2,c=3)
#a =  1 b =  2 c =  3 args =  () kargs =  {}
f1(1,2,3,'a','b')
#a =  1 b =  2 c =  3 args =  ('a', 'b') kargs =  {}
f1(1,2,3,'a','b',x=99)
#a =  1 b =  2 c =  3 args =  ('a', 'b') kargs =  {'x': 99}
f2(1,2,d=99,extra = None)
#a =  1 b =   2 c =  0 d =  99 kwargs =  {'extra': None}

# 通过一个tupel 和 dict 也可以像上面那样传参
args = (1,2,3,4)
kw = {'d':99,'x':'#'}
f1(*args,**kw)
#a =  1 b =  2 c =  3 args =  (4,) kargs =  {'d': 99, 'x': '#'}
args = (1,2,3)
kw = {'d':88,'x':'#'}
f2(*args,**kw)
#a =  1 b =   2 c =  3 d =  88 kwargs =  {'x': '#'}

# 所有任意函数 都可以通过类似func(*args,**kw)的形式调用。